C#.NET ನಲ್ಲಿ LINQ ಪ್ರಶ್ನೆಗಳನ್ನು ಉತ್ತಮಗೊಳಿಸುವ ವಿಧಾನಗಳು

ಪರಿಚಯ

В ಈ ಲೇಖನ ಕೆಲವು ಆಪ್ಟಿಮೈಸೇಶನ್ ವಿಧಾನಗಳನ್ನು ಪರಿಗಣಿಸಲಾಗಿದೆ LINQ ಪ್ರಶ್ನೆಗಳು.
ಇಲ್ಲಿ ನಾವು ಕೋಡ್ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಇನ್ನೂ ಕೆಲವು ವಿಧಾನಗಳನ್ನು ಪ್ರಸ್ತುತಪಡಿಸುತ್ತೇವೆ LINQ ಪ್ರಶ್ನೆಗಳು.

ಅದು ತಿಳಿದಿದೆ ಲಿಂಕ್(ಭಾಷೆ-ಸಂಯೋಜಿತ ಪ್ರಶ್ನೆ) ಡೇಟಾ ಮೂಲವನ್ನು ಪ್ರಶ್ನಿಸಲು ಸರಳ ಮತ್ತು ಅನುಕೂಲಕರ ಭಾಷೆಯಾಗಿದೆ.

А SQL ಗೆ ಲಿಂಕ್ DBMS ನಲ್ಲಿ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸುವ ತಂತ್ರಜ್ಞಾನವಾಗಿದೆ. ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಇದು ಪ್ರಬಲ ಸಾಧನವಾಗಿದೆ, ಅಲ್ಲಿ ಪ್ರಶ್ನೆಗಳನ್ನು ಘೋಷಣಾ ಭಾಷೆಯ ಮೂಲಕ ನಿರ್ಮಿಸಲಾಗುತ್ತದೆ, ನಂತರ ಅದನ್ನು ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ SQL ಪ್ರಶ್ನೆಗಳು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಡೇಟಾಬೇಸ್ ಸರ್ವರ್‌ಗೆ ಕಳುಹಿಸಲಾಗಿದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, DBMS ಮೂಲಕ ನಾವು ಅರ್ಥ MS SQL ಸರ್ವರ್.

ಆದಾಗ್ಯೂ, LINQ ಪ್ರಶ್ನೆಗಳು ಅತ್ಯುತ್ತಮವಾಗಿ ಬರೆಯಲ್ಪಟ್ಟವುಗಳಾಗಿ ಪರಿವರ್ತಿಸಲಾಗಿಲ್ಲ SQL ಪ್ರಶ್ನೆಗಳು, ಇದು ಅನುಭವಿ DBA ಆಪ್ಟಿಮೈಸೇಶನ್‌ನ ಎಲ್ಲಾ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳೊಂದಿಗೆ ಬರೆಯಬಹುದು SQL ಪ್ರಶ್ನೆಗಳು:

1. ಅತ್ಯುತ್ತಮ ಸಂಪರ್ಕಗಳು (ಸೇರಿರಿ) ಮತ್ತು ಫಲಿತಾಂಶಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು (ಎಲ್ಲಿ)
2. ಸಂಪರ್ಕಗಳು ಮತ್ತು ಗುಂಪು ಪರಿಸ್ಥಿತಿಗಳನ್ನು ಬಳಸುವಲ್ಲಿ ಅನೇಕ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳು
3. ಪರಿಸ್ಥಿತಿಗಳನ್ನು ಬದಲಿಸುವಲ್ಲಿ ಅನೇಕ ವ್ಯತ್ಯಾಸಗಳು IN ಮೇಲೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆи IN ಅಲ್ಲ, <> ಆನ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ
4. ತಾತ್ಕಾಲಿಕ ಕೋಷ್ಟಕಗಳು, CTE, ಟೇಬಲ್ ವೇರಿಯೇಬಲ್‌ಗಳ ಮೂಲಕ ಫಲಿತಾಂಶಗಳ ಮಧ್ಯಂತರ ಕ್ಯಾಶಿಂಗ್
5. ವಾಕ್ಯದ ಬಳಕೆ (ಆಯ್ಕೆ) ಸೂಚನೆಗಳು ಮತ್ತು ಟೇಬಲ್ ಸುಳಿವುಗಳೊಂದಿಗೆ ಜೊತೆ (...)
6. ಆಯ್ಕೆಗಳ ಸಮಯದಲ್ಲಿ ಅನಗತ್ಯ ಡೇಟಾ ರೀಡಿಂಗ್‌ಗಳನ್ನು ತೊಡೆದುಹಾಕಲು ಒಂದು ಸಾಧನವಾಗಿ ಸೂಚ್ಯಂಕ ವೀಕ್ಷಣೆಗಳನ್ನು ಬಳಸುವುದು

ಫಲಿತಾಂಶದ ಮುಖ್ಯ ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳು SQL ಪ್ರಶ್ನೆಗಳು ಕಂಪೈಲ್ ಮಾಡುವಾಗ LINQ ಪ್ರಶ್ನೆಗಳು ಅವು:

1. ಒಂದು ವಿನಂತಿಯಲ್ಲಿ ಸಂಪೂರ್ಣ ಡೇಟಾ ಆಯ್ಕೆ ಕಾರ್ಯವಿಧಾನದ ಏಕೀಕರಣ
2. ಒಂದೇ ರೀತಿಯ ಕೋಡ್ ಬ್ಲಾಕ್‌ಗಳನ್ನು ನಕಲು ಮಾಡುವುದು, ಇದು ಅಂತಿಮವಾಗಿ ಬಹು ಅನಗತ್ಯ ಡೇಟಾ ರೀಡ್‌ಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ
3. ಬಹು-ಘಟಕ ಪರಿಸ್ಥಿತಿಗಳ ಗುಂಪುಗಳು (ತಾರ್ಕಿಕ "ಮತ್ತು" ಮತ್ತು "ಅಥವಾ") - ಮತ್ತು и OR, ಸಂಕೀರ್ಣ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ಸಂಯೋಜಿಸುವುದು, ಆಪ್ಟಿಮೈಜರ್, ಅಗತ್ಯ ಕ್ಷೇತ್ರಗಳಿಗೆ ಸೂಕ್ತವಾದ ಕ್ಲಸ್ಟರ್ ಅಲ್ಲದ ಸೂಚ್ಯಂಕಗಳನ್ನು ಹೊಂದಿದ್ದು, ಅಂತಿಮವಾಗಿ ಕ್ಲಸ್ಟರ್ಡ್ ಇಂಡೆಕ್ಸ್ ವಿರುದ್ಧ ಸ್ಕ್ಯಾನ್ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ (ಇಂಡೆಕ್ಸ್ ಸ್ಕ್ಯಾನ್) ಷರತ್ತುಗಳ ಗುಂಪುಗಳಿಂದ
4. ಸಬ್ಕ್ವೆರಿಗಳ ಆಳವಾದ ಗೂಡುಕಟ್ಟುವಿಕೆ ಪಾರ್ಸಿಂಗ್ ಅನ್ನು ಬಹಳ ಸಮಸ್ಯಾತ್ಮಕವಾಗಿಸುತ್ತದೆ SQL ಹೇಳಿಕೆಗಳು ಮತ್ತು ಅಭಿವರ್ಧಕರ ಕಡೆಯಿಂದ ಪ್ರಶ್ನೆ ಯೋಜನೆಯ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ಡಿಬಿಎ

ಆಪ್ಟಿಮೈಸೇಶನ್ ವಿಧಾನಗಳು

ಈಗ ಆಪ್ಟಿಮೈಸೇಶನ್ ವಿಧಾನಗಳಿಗೆ ನೇರವಾಗಿ ಹೋಗೋಣ.

1) ಹೆಚ್ಚುವರಿ ಸೂಚ್ಯಂಕ

ಮುಖ್ಯ ಆಯ್ಕೆ ಕೋಷ್ಟಕಗಳಲ್ಲಿ ಫಿಲ್ಟರ್‌ಗಳನ್ನು ಪರಿಗಣಿಸುವುದು ಉತ್ತಮವಾಗಿದೆ, ಏಕೆಂದರೆ ಆಗಾಗ್ಗೆ ಸಂಪೂರ್ಣ ಪ್ರಶ್ನೆಯನ್ನು ಒಂದು ಅಥವಾ ಎರಡು ಮುಖ್ಯ ಕೋಷ್ಟಕಗಳ ಸುತ್ತಲೂ (ಅಪ್ಲಿಕೇಶನ್‌ಗಳು-ಜನರು-ಕಾರ್ಯಾಚರಣೆಗಳು) ಮತ್ತು ಪ್ರಮಾಣಿತ ಷರತ್ತುಗಳೊಂದಿಗೆ (ಮುಚ್ಚಲಾಗಿದೆ, ರದ್ದುಗೊಳಿಸಲಾಗಿದೆ, ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ, ಸ್ಥಿತಿ) ನಿರ್ಮಿಸಲಾಗಿದೆ. ಗುರುತಿಸಲಾದ ಮಾದರಿಗಳಿಗೆ ಸೂಕ್ತವಾದ ಸೂಚ್ಯಂಕಗಳನ್ನು ರಚಿಸುವುದು ಮುಖ್ಯವಾಗಿದೆ.

ಈ ಕ್ಷೇತ್ರಗಳನ್ನು ಆಯ್ಕೆಮಾಡುವಾಗ ಈ ಪರಿಹಾರವು ಅರ್ಥಪೂರ್ಣವಾಗಿದೆ ಪ್ರಶ್ನೆಗೆ ಹಿಂತಿರುಗಿದ ಸೆಟ್ ಅನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಮಿತಿಗೊಳಿಸುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ, ನಾವು 500000 ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಆದಾಗ್ಯೂ, ಕೇವಲ 2000 ಸಕ್ರಿಯ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿವೆ. ನಂತರ ಸರಿಯಾಗಿ ಆಯ್ಕೆಮಾಡಿದ ಸೂಚ್ಯಂಕವು ನಮ್ಮನ್ನು ಉಳಿಸುತ್ತದೆ ಇಂಡೆಕ್ಸ್ ಸ್ಕ್ಯಾನ್ ದೊಡ್ಡ ಕೋಷ್ಟಕದಲ್ಲಿ ಮತ್ತು ಕ್ಲಸ್ಟರ್ ಮಾಡದ ಸೂಚ್ಯಂಕದ ಮೂಲಕ ಡೇಟಾವನ್ನು ತ್ವರಿತವಾಗಿ ಆಯ್ಕೆ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಅಲ್ಲದೆ, ಪ್ರಶ್ನೆ ಯೋಜನೆಗಳನ್ನು ಪಾರ್ಸಿಂಗ್ ಮಾಡಲು ಅಥವಾ ಸಿಸ್ಟಮ್ ವೀಕ್ಷಣೆಯ ಅಂಕಿಅಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಪ್ರಾಂಪ್ಟ್‌ಗಳ ಮೂಲಕ ಸೂಚ್ಯಂಕಗಳ ಕೊರತೆಯನ್ನು ಗುರುತಿಸಬಹುದು. MS SQL ಸರ್ವರ್:

1. sys.dm_db_missing_index_groups
2. sys.dm_db_missing_index_group_stats
3. sys.dm_db_missing_index_details

ಎಲ್ಲಾ ವೀಕ್ಷಣೆ ಡೇಟಾವು ಪ್ರಾದೇಶಿಕ ಸೂಚಿಕೆಗಳನ್ನು ಹೊರತುಪಡಿಸಿ, ಕಾಣೆಯಾದ ಸೂಚಿಕೆಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ.

ಆದಾಗ್ಯೂ, ಸೂಚ್ಯಂಕಗಳು ಮತ್ತು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವಿಕೆಯು ಸಾಮಾನ್ಯವಾಗಿ ಕಳಪೆಯಾಗಿ ಬರೆಯಲ್ಪಟ್ಟ ಪರಿಣಾಮಗಳನ್ನು ಎದುರಿಸುವ ವಿಧಾನಗಳಾಗಿವೆ LINQ ಪ್ರಶ್ನೆಗಳು и SQL ಪ್ರಶ್ನೆಗಳು.

ಜೀವನದ ಕಠೋರ ಅಭ್ಯಾಸವು ತೋರಿಸುವಂತೆ, ಕೆಲವು ಗಡುವುಗಳ ಮೂಲಕ ವ್ಯವಹಾರದ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ವ್ಯಾಪಾರವು ಸಾಮಾನ್ಯವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ. ಮತ್ತು ಆದ್ದರಿಂದ, ಭಾರೀ ವಿನಂತಿಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವುದರೊಂದಿಗೆ ಹಿನ್ನೆಲೆಗೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ.

ಇದು ಭಾಗಶಃ ಸಮರ್ಥನೆಯಾಗಿದೆ, ಏಕೆಂದರೆ ಬಳಕೆದಾರರಿಗೆ ಯಾವಾಗಲೂ ಇತ್ತೀಚಿನ ಡೇಟಾ ಅಗತ್ಯವಿಲ್ಲ ಮತ್ತು ಬಳಕೆದಾರ ಇಂಟರ್ಫೇಸ್‌ನ ಸ್ವೀಕಾರಾರ್ಹ ಮಟ್ಟದ ಸ್ಪಂದಿಸುವಿಕೆ ಇರುತ್ತದೆ.

ಈ ವಿಧಾನವು ವ್ಯವಹಾರದ ಅಗತ್ಯಗಳನ್ನು ಪರಿಹರಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಅಂತಿಮವಾಗಿ ಸಮಸ್ಯೆಗಳಿಗೆ ಪರಿಹಾರಗಳನ್ನು ವಿಳಂಬಗೊಳಿಸುವ ಮೂಲಕ ಮಾಹಿತಿ ವ್ಯವಸ್ಥೆಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.

ಸೇರಿಸಲು ಅಗತ್ಯವಾದ ಸೂಚ್ಯಂಕಗಳನ್ನು ಹುಡುಕುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಸಲಹೆಗಳನ್ನು ಸಹ ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳುವುದು ಯೋಗ್ಯವಾಗಿದೆ MS SQL ಈ ಕೆಳಗಿನ ಷರತ್ತುಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಆಪ್ಟಿಮೈಸೇಶನ್ ತಪ್ಪಾಗಿರಬಹುದು:

1. ಒಂದೇ ರೀತಿಯ ಕ್ಷೇತ್ರಗಳೊಂದಿಗೆ ಈಗಾಗಲೇ ಸೂಚ್ಯಂಕಗಳು ಇದ್ದಲ್ಲಿ
2. ಸೂಚ್ಯಂಕ ನಿರ್ಬಂಧಗಳ ಕಾರಣದಿಂದಾಗಿ ಕೋಷ್ಟಕದಲ್ಲಿನ ಕ್ಷೇತ್ರಗಳನ್ನು ಸೂಚಿಕೆ ಮಾಡಲಾಗದಿದ್ದರೆ (ಹೆಚ್ಚು ವಿವರವಾಗಿ ವಿವರಿಸಲಾಗಿದೆ ಇಲ್ಲಿ).

2) ಒಂದು ಹೊಸ ಗುಣಲಕ್ಷಣದಲ್ಲಿ ಗುಣಲಕ್ಷಣಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವುದು

ಕೆಲವೊಮ್ಮೆ ಒಂದು ಕೋಷ್ಟಕದಿಂದ ಕೆಲವು ಕ್ಷೇತ್ರಗಳು, ಪರಿಸ್ಥಿತಿಗಳ ಗುಂಪಿಗೆ ಆಧಾರವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಒಂದು ಹೊಸ ಕ್ಷೇತ್ರವನ್ನು ಪರಿಚಯಿಸುವ ಮೂಲಕ ಬದಲಾಯಿಸಬಹುದು.

ಸಾಮಾನ್ಯವಾಗಿ ಬಿಟ್ ಅಥವಾ ಪೂರ್ಣಾಂಕದ ಪ್ರಕಾರದ ಸ್ಥಿತಿ ಕ್ಷೇತ್ರಗಳಿಗೆ ಇದು ವಿಶೇಷವಾಗಿ ಸತ್ಯವಾಗಿದೆ.

ಉದಾಹರಣೆ:

ಮುಚ್ಚಲಾಗಿದೆ = 0 ಮತ್ತು ರದ್ದುಗೊಳಿಸಲಾಗಿದೆ = 0 ಮತ್ತು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ = 0 ನಿಂದ ಬದಲಿಸಲಾಗಿದೆ ಸ್ಥಿತಿ = 1.

ಇಲ್ಲಿ ಪೂರ್ಣಾಂಕ ಸ್ಥಿತಿ ಗುಣಲಕ್ಷಣವನ್ನು ಪರಿಚಯಿಸಲಾಗಿದೆ, ಈ ಸ್ಥಿತಿಗಳು ಕೋಷ್ಟಕದಲ್ಲಿ ಜನಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು. ಮುಂದೆ, ಈ ಹೊಸ ಗುಣಲಕ್ಷಣವನ್ನು ಸೂಚಿಕೆ ಮಾಡಲಾಗಿದೆ.

ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಗೆ ಇದು ಮೂಲಭೂತ ಪರಿಹಾರವಾಗಿದೆ, ಏಕೆಂದರೆ ನಾವು ಅನಗತ್ಯ ಲೆಕ್ಕಾಚಾರಗಳಿಲ್ಲದೆ ಡೇಟಾವನ್ನು ಪ್ರವೇಶಿಸುತ್ತೇವೆ.

3) ನೋಟದ ವಸ್ತುೀಕರಣ

ದುರದೃಷ್ಟವಶಾತ್, ರಲ್ಲಿ LINQ ಪ್ರಶ್ನೆಗಳು ತಾತ್ಕಾಲಿಕ ಕೋಷ್ಟಕಗಳು, CTE ಗಳು ಮತ್ತು ಟೇಬಲ್ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ನೇರವಾಗಿ ಬಳಸಲಾಗುವುದಿಲ್ಲ.

ಆದಾಗ್ಯೂ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಲು ಇನ್ನೊಂದು ಮಾರ್ಗವಿದೆ - ಸೂಚ್ಯಂಕ ವೀಕ್ಷಣೆಗಳು.

ಷರತ್ತು ಗುಂಪು (ಮೇಲಿನ ಉದಾಹರಣೆಯಿಂದ) ಮುಚ್ಚಲಾಗಿದೆ = 0 ಮತ್ತು ರದ್ದುಗೊಳಿಸಲಾಗಿದೆ = 0 ಮತ್ತು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ = 0 (ಅಥವಾ ಇತರ ರೀತಿಯ ಪರಿಸ್ಥಿತಿಗಳ ಒಂದು ಸೆಟ್) ಅವುಗಳನ್ನು ಸೂಚ್ಯಂಕ ವೀಕ್ಷಣೆಯಲ್ಲಿ ಬಳಸಲು ಉತ್ತಮ ಆಯ್ಕೆಯಾಗುತ್ತದೆ, ದೊಡ್ಡ ಗುಂಪಿನಿಂದ ಡೇಟಾದ ಸಣ್ಣ ಸ್ಲೈಸ್ ಅನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುತ್ತದೆ.

ಆದರೆ ದೃಷ್ಟಿಕೋನವನ್ನು ಸಾಕಾರಗೊಳಿಸುವಾಗ ಹಲವಾರು ನಿರ್ಬಂಧಗಳಿವೆ:

1. ಉಪಪ್ರಶ್ನೆಗಳು, ಷರತ್ತುಗಳ ಬಳಕೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಬಳಸಿಕೊಂಡು ಬದಲಿಸಬೇಕು ಸೇರಿರಿ
2. ನೀವು ವಾಕ್ಯಗಳನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ ಒಕ್ಕೂಟ, ಎಲ್ಲಾ UNION, ವಿನಾಯಿತಿ, ಇಂಟರ್ಸೆಕ್ಟ್
3. ನೀವು ಟೇಬಲ್ ಸುಳಿವುಗಳು ಮತ್ತು ಷರತ್ತುಗಳನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ ಆಯ್ಕೆ
4. ಚಕ್ರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಸಾಧ್ಯತೆಯಿಲ್ಲ
5. ವಿಭಿನ್ನ ಕೋಷ್ಟಕಗಳಿಂದ ಒಂದೇ ವೀಕ್ಷಣೆಯಲ್ಲಿ ಡೇಟಾವನ್ನು ಪ್ರದರ್ಶಿಸುವುದು ಅಸಾಧ್ಯ

ಸೂಚ್ಯಂಕ ವೀಕ್ಷಣೆಯನ್ನು ಬಳಸುವುದರ ನಿಜವಾದ ಪ್ರಯೋಜನವನ್ನು ವಾಸ್ತವವಾಗಿ ಸೂಚಿಕೆ ಮಾಡುವ ಮೂಲಕ ಮಾತ್ರ ಸಾಧಿಸಬಹುದು ಎಂಬುದನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ.

ಆದರೆ ವೀಕ್ಷಣೆಗೆ ಕರೆ ಮಾಡುವಾಗ, ಈ ಸೂಚಿಕೆಗಳನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ, ಮತ್ತು ಅವುಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಬಳಸಲು, ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು ಇದರೊಂದಿಗೆ (NOEXPAND).

ರಿಂದ LINQ ಪ್ರಶ್ನೆಗಳು ಟೇಬಲ್ ಸುಳಿವುಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಅಸಾಧ್ಯ, ಆದ್ದರಿಂದ ನೀವು ಇನ್ನೊಂದು ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ - ಈ ಕೆಳಗಿನ ರೂಪದ "ಹೊದಿಕೆ":

CREATE VIEW ИМЯ_представления AS SELECT * FROM MAT_VIEW WITH (NOEXPAND);

4) ಟೇಬಲ್ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುವುದು

ಆಗಾಗ್ಗೆ ಒಳಗೆ LINQ ಪ್ರಶ್ನೆಗಳು ಸಂಕೀರ್ಣ ರಚನೆಯೊಂದಿಗೆ ವೀಕ್ಷಣೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಉಪಪ್ರಶ್ನೆಗಳು ಅಥವಾ ಬ್ಲಾಕ್‌ಗಳ ದೊಡ್ಡ ಬ್ಲಾಕ್‌ಗಳು ಅತ್ಯಂತ ಸಂಕೀರ್ಣ ಮತ್ತು ಸಬ್‌ಪ್ಟಿಮಲ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ರಚನೆಯೊಂದಿಗೆ ಅಂತಿಮ ಪ್ರಶ್ನೆಯನ್ನು ರೂಪಿಸುತ್ತವೆ.

ಟೇಬಲ್ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುವ ಪ್ರಮುಖ ಪ್ರಯೋಜನಗಳು LINQ ಪ್ರಶ್ನೆಗಳು:

1. ಸಾಮರ್ಥ್ಯ, ವೀಕ್ಷಣೆಗಳ ಸಂದರ್ಭದಲ್ಲಿ, ವಸ್ತುವಾಗಿ ಬಳಸಲು ಮತ್ತು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು, ಆದರೆ ನೀವು ಇನ್ಪುಟ್ ನಿಯತಾಂಕಗಳ ಗುಂಪನ್ನು ರವಾನಿಸಬಹುದು:
   ಫಂಕ್ಷನ್‌ನಿಂದ(@param1, @param2 ...)
   ಪರಿಣಾಮವಾಗಿ, ಹೊಂದಿಕೊಳ್ಳುವ ಡೇಟಾ ಮಾದರಿಯನ್ನು ಸಾಧಿಸಬಹುದು
2. ಟೇಬಲ್ ಕಾರ್ಯವನ್ನು ಬಳಸುವ ಸಂದರ್ಭದಲ್ಲಿ, ಮೇಲೆ ವಿವರಿಸಿದ ಸೂಚ್ಯಂಕ ವೀಕ್ಷಣೆಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಯಾವುದೇ ಬಲವಾದ ನಿರ್ಬಂಧಗಳಿಲ್ಲ:
   1. ಟೇಬಲ್ ಸುಳಿವುಗಳು:
      ಮೂಲಕ ಲಿಂಕ್ ಯಾವ ಸೂಚ್ಯಂಕಗಳನ್ನು ಬಳಸಬೇಕು ಮತ್ತು ಪ್ರಶ್ನಿಸುವಾಗ ಡೇಟಾ ಪ್ರತ್ಯೇಕತೆಯ ಮಟ್ಟವನ್ನು ನಿರ್ಧರಿಸಲು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗುವುದಿಲ್ಲ.
      ಆದರೆ ಕಾರ್ಯವು ಈ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೊಂದಿದೆ.
      ಕಾರ್ಯದೊಂದಿಗೆ, ನೀವು ಸಾಕಷ್ಟು ಸ್ಥಿರವಾದ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಪ್ರಶ್ನೆ ಯೋಜನೆಯನ್ನು ಸಾಧಿಸಬಹುದು, ಅಲ್ಲಿ ಸೂಚ್ಯಂಕಗಳು ಮತ್ತು ಡೇಟಾ ಪ್ರತ್ಯೇಕತೆಯ ಮಟ್ಟಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ನಿಯಮಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ
   2. ಕಾರ್ಯವನ್ನು ಬಳಸುವುದರಿಂದ ಸೂಚ್ಯಂಕದ ವೀಕ್ಷಣೆಗಳೊಂದಿಗೆ ಹೋಲಿಸಿದರೆ, ಪಡೆಯಲು ಅನುಮತಿಸುತ್ತದೆ:
      • ಸಂಕೀರ್ಣ ದತ್ತಾಂಶ ಮಾದರಿ ತರ್ಕ (ಲೂಪ್‌ಗಳನ್ನು ಸಹ ಬಳಸುವುದು)
      • ವಿವಿಧ ಕೋಷ್ಟಕಗಳಿಂದ ಡೇಟಾವನ್ನು ಪಡೆಯುವುದು
      • ಬಳಕೆ ಒಕ್ಕೂಟ и ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ

3. ಆಫರ್ ಆಯ್ಕೆ ನಾವು ಏಕಕಾಲಿಕ ನಿಯಂತ್ರಣವನ್ನು ಒದಗಿಸಬೇಕಾದಾಗ ತುಂಬಾ ಉಪಯುಕ್ತವಾಗಿದೆ ಆಯ್ಕೆ(MAXDOP N), ಪ್ರಶ್ನೆ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಯೋಜನೆಯ ಕ್ರಮ. ಉದಾಹರಣೆಗೆ:
   • ನೀವು ಪ್ರಶ್ನೆ ಯೋಜನೆಯ ಬಲವಂತದ ಮರು-ಸೃಷ್ಟಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು ಆಯ್ಕೆ (ರಿಕಂಪೈಲ್)
   • ಪ್ರಶ್ನೆಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸೇರ್ಪಡೆ ಕ್ರಮವನ್ನು ಬಳಸಲು ಪ್ರಶ್ನೆ ಯೋಜನೆಯನ್ನು ಒತ್ತಾಯಿಸಬೇಕೆ ಎಂದು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು ಆಯ್ಕೆ (ಫೋರ್ಸ್ ಆರ್ಡರ್)

   ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ವಿವರಗಳು ಆಯ್ಕೆ ವಿವರಿಸಲಾಗಿದೆ ಇಲ್ಲಿ.

4. ಕಿರಿದಾದ ಮತ್ತು ಹೆಚ್ಚು ಅಗತ್ಯವಿರುವ ಡೇಟಾ ಸ್ಲೈಸ್ ಅನ್ನು ಬಳಸುವುದು:
   ಕ್ಯಾಶ್‌ಗಳಲ್ಲಿ ದೊಡ್ಡ ಡೇಟಾ ಸೆಟ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಅಗತ್ಯವಿಲ್ಲ (ಇಂಡೆಕ್ಸ್ ಮಾಡಿದ ವೀಕ್ಷಣೆಗಳಂತೆಯೇ), ಇದರಿಂದ ನೀವು ಇನ್ನೂ ಪ್ಯಾರಾಮೀಟರ್ ಮೂಲಕ ಡೇಟಾವನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ.
   ಉದಾಹರಣೆಗೆ, ಫಿಲ್ಟರ್ ಇರುವ ಟೇಬಲ್ ಇದೆ ಎಲ್ಲಿ ಮೂರು ಕ್ಷೇತ್ರಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ (ಎ, ಬಿ, ಸಿ).

   ಸಾಂಪ್ರದಾಯಿಕವಾಗಿ, ಎಲ್ಲಾ ವಿನಂತಿಗಳು ನಿರಂತರ ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿರುತ್ತವೆ a = 0 ಮತ್ತು b = 0.

   ಆದರೆ, ಕ್ಷೇತ್ರಕ್ಕೆ ಮನವಿ c ಹೆಚ್ಚು ವೇರಿಯಬಲ್.

   ಷರತ್ತು ಬಿಡಿ a = 0 ಮತ್ತು b = 0 ಅಗತ್ಯವಿರುವ ಫಲಿತಾಂಶದ ಸೆಟ್ ಅನ್ನು ಸಾವಿರಾರು ದಾಖಲೆಗಳಿಗೆ ಮಿತಿಗೊಳಿಸಲು ಇದು ನಿಜವಾಗಿಯೂ ನಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಆದರೆ ಸ್ಥಿತಿ ಆನ್ ಆಗಿದೆ с ಆಯ್ಕೆಯನ್ನು ನೂರು ದಾಖಲೆಗಳಿಗೆ ಸಂಕುಚಿತಗೊಳಿಸುತ್ತದೆ.

   ಇಲ್ಲಿ ಟೇಬಲ್ ಕಾರ್ಯವು ಉತ್ತಮ ಆಯ್ಕೆಯಾಗಿರಬಹುದು.

   ಅಲ್ಲದೆ, ಟೇಬಲ್ ಕಾರ್ಯವು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯದಲ್ಲಿ ಹೆಚ್ಚು ಊಹಿಸಬಹುದಾದ ಮತ್ತು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ.

ಉದಾಹರಣೆಗಳು

ಪ್ರಶ್ನೆಗಳ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಉದಾಹರಣೆಯಾಗಿ ಬಳಸಿಕೊಂಡು ಉದಾಹರಣೆ ಅನುಷ್ಠಾನವನ್ನು ನೋಡೋಣ.

ವಿನಂತಿ ಇದೆ ಆಯ್ಕೆಮಾಡಿ, ಇದು ಹಲವಾರು ಕೋಷ್ಟಕಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ ಮತ್ತು ಒಂದು ವೀಕ್ಷಣೆಯನ್ನು ಬಳಸುತ್ತದೆ (ಆಪರೇಟಿವ್ ಪ್ರಶ್ನೆಗಳು), ಇದರಲ್ಲಿ ಸಂಬಂಧವನ್ನು ಇಮೇಲ್ ಮೂಲಕ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ (ಮೂಲಕ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ) "ಆಪರೇಟಿವ್ ಪ್ರಶ್ನೆಗಳಿಗೆ":

ವಿನಂತಿ ಸಂಖ್ಯೆ 1

(@p__linq__0 nvarchar(4000))SELECT
1 AS [C1],
[Extent1].[Id] AS [Id],
[Join2].[Object_Id] AS [Object_Id],
[Join2].[ObjectType_Id] AS [ObjectType_Id],
[Join2].[Name] AS [Name],
[Join2].[ExternalId] AS [ExternalId]
FROM [dbo].[Questions] AS [Extent1]
INNER JOIN (SELECT [Extent2].[Object_Id] AS [Object_Id],
[Extent2].[Question_Id] AS [Question_Id], [Extent3].[ExternalId] AS [ExternalId],
[Extent3].[ObjectType_Id] AS [ObjectType_Id], [Extent4].[Name] AS [Name]
FROM [dbo].[ObjectQuestions] AS [Extent2]
INNER JOIN [dbo].[Objects] AS [Extent3] ON [Extent2].[Object_Id] = [Extent3].[Id]
LEFT OUTER JOIN [dbo].[ObjectTypes] AS [Extent4] 
ON [Extent3].[ObjectType_Id] = [Extent4].[Id] ) AS [Join2] 
ON [Extent1].[Id] = [Join2].[Question_Id]
WHERE ([Extent1].[AnswerId] IS NULL) AND (0 = [Extent1].[Exp]) AND ( EXISTS (SELECT
1 AS [C1]
FROM [dbo].[OperativeQuestions] AS [Extent5]
WHERE (([Extent5].[Email] = @p__linq__0) OR (([Extent5].[Email] IS NULL) 
AND (@p__linq__0 IS NULL))) AND ([Extent5].[Id] = [Extent1].[Id])
));

ನೋಟವು ಸಂಕೀರ್ಣವಾದ ರಚನೆಯನ್ನು ಹೊಂದಿದೆ: ಇದು ಉಪಪ್ರಶ್ನೆ ಸೇರುವಿಕೆಯನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ವಿಂಗಡಣೆಯನ್ನು ಬಳಸುತ್ತದೆ ವಿಶಿಷ್ಟ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಸಾಕಷ್ಟು ಸಂಪನ್ಮೂಲ-ತೀವ್ರ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ.

ಆಪರೇಟಿವ್ ಪ್ರಶ್ನೆಗಳ ಮಾದರಿಯು ಸುಮಾರು ಹತ್ತು ಸಾವಿರ ದಾಖಲೆಗಳನ್ನು ಹೊಂದಿದೆ.

ಈ ಪ್ರಶ್ನೆಯ ಮುಖ್ಯ ಸಮಸ್ಯೆಯೆಂದರೆ, ಹೊರಗಿನ ಪ್ರಶ್ನೆಯಿಂದ ದಾಖಲೆಗಳಿಗಾಗಿ, [ಆಪರೇಟಿವ್ ಪ್ರಶ್ನೆಗಳು] ವೀಕ್ಷಣೆಯಲ್ಲಿ ಆಂತರಿಕ ಉಪಪ್ರಶ್ನೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಇದು [ಇಮೇಲ್] = @p__linq__0 ನಮಗೆ ಔಟ್‌ಪುಟ್ ಆಯ್ಕೆಯನ್ನು ಮಿತಿಗೊಳಿಸಲು ಅನುಮತಿಸುತ್ತದೆ (ಮೂಲಕ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ) ನೂರಾರು ದಾಖಲೆಗಳವರೆಗೆ.

ಮತ್ತು ಸಬ್‌ಕ್ವೆರಿಯು ದಾಖಲೆಗಳನ್ನು ಒಮ್ಮೆ [ಇಮೇಲ್] = @p__linq__0 ಮೂಲಕ ಲೆಕ್ಕಾಚಾರ ಮಾಡಬೇಕು ಎಂದು ತೋರುತ್ತದೆ, ಮತ್ತು ನಂತರ ಈ ಒಂದೆರಡು ನೂರು ದಾಖಲೆಗಳನ್ನು ಪ್ರಶ್ನೆಗಳೊಂದಿಗೆ ಐಡಿ ಮೂಲಕ ಸಂಪರ್ಕಿಸಬೇಕು ಮತ್ತು ಪ್ರಶ್ನೆಯು ವೇಗವಾಗಿರುತ್ತದೆ.

ವಾಸ್ತವವಾಗಿ, ಎಲ್ಲಾ ಕೋಷ್ಟಕಗಳ ಅನುಕ್ರಮ ಸಂಪರ್ಕವಿದೆ: ಆಪರೇಟಿವ್ ಪ್ರಶ್ನೆಗಳಿಂದ ಐಡಿಯೊಂದಿಗೆ ಐಡಿ ಪ್ರಶ್ನೆಗಳ ಪತ್ರವ್ಯವಹಾರವನ್ನು ಪರಿಶೀಲಿಸುವುದು ಮತ್ತು ಇಮೇಲ್ ಮೂಲಕ ಫಿಲ್ಟರ್ ಮಾಡುವುದು.

ವಾಸ್ತವವಾಗಿ, ವಿನಂತಿಯು ಎಲ್ಲಾ ಹತ್ತಾರು ಆಪರೇಟಿವ್ ಪ್ರಶ್ನೆಗಳ ದಾಖಲೆಗಳೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಆದರೆ ಇಮೇಲ್ ಮೂಲಕ ಆಸಕ್ತಿಯ ಡೇಟಾ ಮಾತ್ರ ಅಗತ್ಯವಿದೆ.

ಆಪರೇಟಿವ್ ಪ್ರಶ್ನೆಗಳು ಪಠ್ಯವನ್ನು ವೀಕ್ಷಿಸಿ:

ವಿನಂತಿ ಸಂಖ್ಯೆ 2

 
CREATE VIEW [dbo].[OperativeQuestions]
AS
SELECT DISTINCT Q.Id, USR.email AS Email
FROM            [dbo].Questions AS Q INNER JOIN
                         [dbo].ProcessUserAccesses AS BPU ON BPU.ProcessId = CQ.Process_Id 
OUTER APPLY
                     (SELECT   1 AS HasNoObjects
                      WHERE   NOT EXISTS
                                    (SELECT   1
                                     FROM     [dbo].ObjectUserAccesses AS BOU
                                     WHERE   BOU.ProcessUserAccessId = BPU.[Id] AND BOU.[To] IS NULL)
) AS BO INNER JOIN
                         [dbo].Users AS USR ON USR.Id = BPU.UserId
WHERE        CQ.[Exp] = 0 AND CQ.AnswerId IS NULL AND BPU.[To] IS NULL 
AND (BO.HasNoObjects = 1 OR
              EXISTS (SELECT   1
                           FROM   [dbo].ObjectUserAccesses AS BOU INNER JOIN
                                      [dbo].ObjectQuestions AS QBO 
                                                  ON QBO.[Object_Id] =BOU.ObjectId
                               WHERE  BOU.ProcessUserAccessId = BPU.Id 
                               AND BOU.[To] IS NULL AND QBO.Question_Id = CQ.Id));

DbContext (EF ಕೋರ್ 2) ನಲ್ಲಿ ಆರಂಭಿಕ ವೀಕ್ಷಣೆ ಮ್ಯಾಪಿಂಗ್

public class QuestionsDbContext : DbContext
{
    //...
    public DbQuery<OperativeQuestion> OperativeQuestions { get; set; }
    //...
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Query<OperativeQuestion>().ToView("OperativeQuestions");
    }
}

ಆರಂಭಿಕ LINQ ಪ್ರಶ್ನೆ

var businessObjectsData = await context
    .OperativeQuestions
    .Where(x => x.Email == Email)
    .Include(x => x.Question)
    .Select(x => x.Question)
    .SelectMany(x => x.ObjectQuestions,
                (x, bo) => new
                {
                    Id = x.Id,
                    ObjectId = bo.Object.Id,
                    ObjectTypeId = bo.Object.ObjectType.Id,
                    ObjectTypeName = bo.Object.ObjectType.Name,
                    ObjectExternalId = bo.Object.ExternalId
                })
    .ToListAsync();

ಈ ನಿರ್ದಿಷ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ಮೂಲಸೌಕರ್ಯ ಬದಲಾವಣೆಗಳಿಲ್ಲದೆಯೇ, ಸಿದ್ದಪಡಿಸಿದ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ ("ಸಕ್ರಿಯ ಪ್ರಶ್ನೆಗಳು") ಪ್ರತ್ಯೇಕ ಕೋಷ್ಟಕವನ್ನು ಪರಿಚಯಿಸದೆಯೇ ನಾವು ಈ ಸಮಸ್ಯೆಗೆ ಪರಿಹಾರವನ್ನು ಪರಿಗಣಿಸುತ್ತಿದ್ದೇವೆ, ಇದು ಡೇಟಾವನ್ನು ತುಂಬಲು ಮತ್ತು ಅದನ್ನು ನವೀಕೃತವಾಗಿರಿಸಲು ಯಾಂತ್ರಿಕತೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ. .

ಇದು ಉತ್ತಮ ಪರಿಹಾರವಾಗಿದ್ದರೂ, ಈ ಸಮಸ್ಯೆಯನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿಸಲು ಇನ್ನೊಂದು ಆಯ್ಕೆ ಇದೆ.

ಆಪರೇಟಿವ್ ಪ್ರಶ್ನೆಗಳ ವೀಕ್ಷಣೆಯಿಂದ [ಇಮೇಲ್] = @p__linq__0 ಮೂಲಕ ನಮೂದುಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದು ಮುಖ್ಯ ಉದ್ದೇಶವಾಗಿದೆ.

ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಟೇಬಲ್ ಕಾರ್ಯವನ್ನು ಪರಿಚಯಿಸಿ [dbo].[OperativeQuestionsUserMail].

ಇಮೇಲ್ ಅನ್ನು ಇನ್‌ಪುಟ್ ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿ ಕಳುಹಿಸುವ ಮೂಲಕ, ನಾವು ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ:

ವಿನಂತಿ ಸಂಖ್ಯೆ 3

CREATE FUNCTION [dbo].[OperativeQuestionsUserMail]
(
    @Email  nvarchar(4000)
)
RETURNS
@tbl TABLE
(
    [Id]           uniqueidentifier,
    [Email]      nvarchar(4000)
)
AS
BEGIN
        INSERT INTO @tbl ([Id], [Email])
        SELECT Id, @Email
        FROM [OperativeQuestions]  AS [x] WHERE [x].[Email] = @Email;
     
    RETURN;
END

ಇದು ಪೂರ್ವನಿರ್ಧರಿತ ಡೇಟಾ ರಚನೆಯೊಂದಿಗೆ ಮೌಲ್ಯಗಳ ಕೋಷ್ಟಕವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

OperativeQuestionsUserMail ಗೆ ಪ್ರಶ್ನೆಗಳು ಸೂಕ್ತವಾಗಿರಲು ಮತ್ತು ಸೂಕ್ತವಾದ ಪ್ರಶ್ನೆ ಯೋಜನೆಗಳನ್ನು ಹೊಂದಲು, ಕಟ್ಟುನಿಟ್ಟಾದ ರಚನೆಯ ಅಗತ್ಯವಿದೆ ಮತ್ತು ಅಲ್ಲ ಹಿಂತಿರುಗಿದಂತೆ ಟೇಬಲ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ...

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಅಗತ್ಯವಿರುವ ಪ್ರಶ್ನೆ 1 ಅನ್ನು ಪ್ರಶ್ನೆ 4 ಆಗಿ ಪರಿವರ್ತಿಸಲಾಗುತ್ತದೆ:

ವಿನಂತಿ ಸಂಖ್ಯೆ 4

(@p__linq__0 nvarchar(4000))SELECT
1 AS [C1],
[Extent1].[Id] AS [Id],
[Join2].[Object_Id] AS [Object_Id],
[Join2].[ObjectType_Id] AS [ObjectType_Id],
[Join2].[Name] AS [Name],
[Join2].[ExternalId] AS [ExternalId]
FROM (
    SELECT Id, Email FROM [dbo].[OperativeQuestionsUserMail] (@p__linq__0)
) AS [Extent0]
INNER JOIN [dbo].[Questions] AS [Extent1] ON([Extent0].Id=[Extent1].Id)
INNER JOIN (SELECT [Extent2].[Object_Id] AS [Object_Id], [Extent2].[Question_Id] AS [Question_Id], [Extent3].[ExternalId] AS [ExternalId], [Extent3].[ObjectType_Id] AS [ObjectType_Id], [Extent4].[Name] AS [Name]
FROM [dbo].[ObjectQuestions] AS [Extent2]
INNER JOIN [dbo].[Objects] AS [Extent3] ON [Extent2].[Object_Id] = [Extent3].[Id]
LEFT OUTER JOIN [dbo].[ObjectTypes] AS [Extent4] 
ON [Extent3].[ObjectType_Id] = [Extent4].[Id] ) AS [Join2] 
ON [Extent1].[Id] = [Join2].[Question_Id]
WHERE ([Extent1].[AnswerId] IS NULL) AND (0 = [Extent1].[Exp]);

DbContext ನಲ್ಲಿ ಮ್ಯಾಪಿಂಗ್ ವೀಕ್ಷಣೆಗಳು ಮತ್ತು ಕಾರ್ಯಗಳು (EF ಕೋರ್ 2)

public class QuestionsDbContext : DbContext
{
    //...
    public DbQuery<OperativeQuestion> OperativeQuestions { get; set; }
    //...
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Query<OperativeQuestion>().ToView("OperativeQuestions");
    }
}
 
public static class FromSqlQueries
{
    public static IQueryable<OperativeQuestion> GetByUserEmail(this DbQuery<OperativeQuestion> source, string Email)
        => source.FromSql($"SELECT Id, Email FROM [dbo].[OperativeQuestionsUserMail] ({Email})");
}

ಅಂತಿಮ LINQ ಪ್ರಶ್ನೆ

var businessObjectsData = await context
    .OperativeQuestions
    .GetByUserEmail(Email)
    .Include(x => x.Question)
    .Select(x => x.Question)
    .SelectMany(x => x.ObjectQuestions,
                (x, bo) => new
                {
                    Id = x.Id,
                    ObjectId = bo.Object.Id,
                    ObjectTypeId = bo.Object.ObjectType.Id,
                    ObjectTypeName = bo.Object.ObjectType.Name,
                    ObjectExternalId = bo.Object.ExternalId
                })
    .ToListAsync();

ಮರಣದಂಡನೆಯ ಸಮಯದ ಕ್ರಮವು 200-800 ms ನಿಂದ 2-20 ms ಗೆ ಇಳಿದಿದೆ, ಇತ್ಯಾದಿ. ಅಂದರೆ ಹತ್ತಾರು ಪಟ್ಟು ವೇಗವಾಗಿ.

ನಾವು ಅದನ್ನು ಹೆಚ್ಚು ಸರಾಸರಿ ತೆಗೆದುಕೊಂಡರೆ, 350 ಎಂಎಸ್ ಬದಲಿಗೆ ನಮಗೆ 8 ಎಂಎಸ್ ಸಿಕ್ಕಿತು.

ಸ್ಪಷ್ಟ ಪ್ರಯೋಜನಗಳಿಂದ ನಾವು ಸಹ ಪಡೆಯುತ್ತೇವೆ:

1. ಓದುವ ಹೊರೆಯಲ್ಲಿ ಸಾಮಾನ್ಯ ಕಡಿತ,
2. ತಡೆಯುವ ಸಾಧ್ಯತೆಯಲ್ಲಿ ಗಮನಾರ್ಹ ಕಡಿತ
3. ಸ್ವೀಕಾರಾರ್ಹ ಮೌಲ್ಯಗಳಿಗೆ ಸರಾಸರಿ ತಡೆಯುವ ಸಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು

ತೀರ್ಮಾನಕ್ಕೆ

ಡೇಟಾಬೇಸ್ ಕರೆಗಳ ಆಪ್ಟಿಮೈಸೇಶನ್ ಮತ್ತು ಫೈನ್-ಟ್ಯೂನಿಂಗ್ MS SQL ಮೂಲಕ ಲಿಂಕ್ ಪರಿಹರಿಸಬಹುದಾದ ಸಮಸ್ಯೆಯಾಗಿದೆ.

ಈ ಕೆಲಸದಲ್ಲಿ ಗಮನ ಮತ್ತು ಸ್ಥಿರತೆ ಬಹಳ ಮುಖ್ಯ.

ಪ್ರಕ್ರಿಯೆಯ ಆರಂಭದಲ್ಲಿ:

1. ವಿನಂತಿಯು ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಡೇಟಾವನ್ನು ಪರಿಶೀಲಿಸುವುದು ಅವಶ್ಯಕ (ಮೌಲ್ಯಗಳು, ಆಯ್ಕೆಮಾಡಿದ ಡೇಟಾ ಪ್ರಕಾರಗಳು)
2. ಈ ಡೇಟಾದ ಸರಿಯಾದ ಇಂಡೆಕ್ಸಿಂಗ್ ಅನ್ನು ಕೈಗೊಳ್ಳಿ
3. ಕೋಷ್ಟಕಗಳ ನಡುವೆ ಸೇರುವ ಪರಿಸ್ಥಿತಿಗಳ ಸರಿಯಾದತೆಯನ್ನು ಪರಿಶೀಲಿಸಿ

ಮುಂದಿನ ಆಪ್ಟಿಮೈಸೇಶನ್ ಪುನರಾವರ್ತನೆಯು ಬಹಿರಂಗಪಡಿಸುತ್ತದೆ:

1. ವಿನಂತಿಯ ಆಧಾರ ಮತ್ತು ಮುಖ್ಯ ವಿನಂತಿಯ ಫಿಲ್ಟರ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ
2. ಒಂದೇ ರೀತಿಯ ಪ್ರಶ್ನೆ ಬ್ಲಾಕ್ಗಳನ್ನು ಪುನರಾವರ್ತಿಸುವುದು ಮತ್ತು ಪರಿಸ್ಥಿತಿಗಳ ಛೇದನವನ್ನು ವಿಶ್ಲೇಷಿಸುವುದು
3. SSMS ಅಥವಾ ಇತರ GUI ನಲ್ಲಿ SQL ಸರ್ವರ್ ಸ್ವತಃ ಉತ್ತಮಗೊಳಿಸುತ್ತದೆ SQL ಪ್ರಶ್ನೆ (ಮಧ್ಯಂತರ ಡೇಟಾ ಸಂಗ್ರಹಣೆಯನ್ನು ನಿಯೋಜಿಸುವುದು, ಈ ಸಂಗ್ರಹಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಫಲಿತಾಂಶದ ಪ್ರಶ್ನೆಯನ್ನು ನಿರ್ಮಿಸುವುದು (ಹಲವು ಇರಬಹುದು))
4. ಕೊನೆಯ ಹಂತದಲ್ಲಿ, ಫಲಿತಾಂಶವನ್ನು ಆಧಾರವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ SQL ಪ್ರಶ್ನೆ, ರಚನೆಯನ್ನು ಮರುನಿರ್ಮಾಣ ಮಾಡಲಾಗುತ್ತಿದೆ LINQ ಪ್ರಶ್ನೆ

ಪರಿಣಾಮವಾಗಿ LINQ ಪ್ರಶ್ನೆ ಗುರುತಿಸಲಾದ ಆಪ್ಟಿಮಲ್‌ಗೆ ರಚನೆಯಲ್ಲಿ ಒಂದೇ ಆಗಿರಬೇಕು SQL ಪ್ರಶ್ನೆ ಪಾಯಿಂಟ್ 3 ರಿಂದ.

ಸ್ವೀಕೃತಿಗಳು

ಸಹೋದ್ಯೋಗಿಗಳಿಗೆ ತುಂಬಾ ಧನ್ಯವಾದಗಳು jobgemws и alex_ozr ಕಂಪನಿಯಿಂದ ಫೋರ್ಟಿಸ್ ಈ ವಸ್ತುವನ್ನು ತಯಾರಿಸಲು ಸಹಾಯಕ್ಕಾಗಿ.

ಮೂಲ: www.habr.com