PostgreSQL ಕ್ವೆರಿ ಪ್ರೊಫೈಲರ್: ಯೋಜನೆ ಮತ್ತು ಪ್ರಶ್ನೆಯನ್ನು ಹೇಗೆ ಹೊಂದಿಸುವುದು

ಈಗಾಗಲೇ ಬಳಸುತ್ತಿರುವ ಅನೇಕರು ವಿವರಿಸಿ.tensor.ru - ನಮ್ಮ PostgreSQL ಯೋಜನೆ ದೃಶ್ಯೀಕರಣ ಸೇವೆಯು ಅದರ ಒಂದು ಮಹಾಶಕ್ತಿಯ ಬಗ್ಗೆ ತಿಳಿದಿರದಿರಬಹುದು - ಸರ್ವರ್ ಲಾಗ್‌ನ ಓದಲು ಕಷ್ಟದ ತುಣುಕನ್ನು ತಿರುಗಿಸುತ್ತದೆ...

... ಅನುಗುಣವಾದ ಪ್ಲಾನ್ ನೋಡ್‌ಗಳಿಗಾಗಿ ಸಂದರ್ಭೋಚಿತ ಸುಳಿವುಗಳೊಂದಿಗೆ ಸುಂದರವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಪ್ರಶ್ನೆಗೆ:

ಅವರ ಎರಡನೇ ಭಾಗದ ಈ ಪ್ರತಿಲಿಪಿಯಲ್ಲಿ PGConf.Russia 2020 ನಲ್ಲಿ ವರದಿ ನಾವು ಇದನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತಿದ್ದೇವೆ ಎಂದು ನಾನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ.

ವಿಶಿಷ್ಟವಾದ ಪ್ರಶ್ನೆ ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಗಳು ಮತ್ತು ಅವುಗಳ ಪರಿಹಾರಗಳಿಗೆ ಮೀಸಲಾಗಿರುವ ಮೊದಲ ಭಾಗದ ಪ್ರತಿಲೇಖನವನ್ನು ಲೇಖನದಲ್ಲಿ ಕಾಣಬಹುದು "ಅಸ್ವಸ್ಥ SQL ಪ್ರಶ್ನೆಗಳಿಗೆ ಪಾಕವಿಧಾನಗಳು".

ಮೊದಲಿಗೆ, ನಾವು ಬಣ್ಣವನ್ನು ಪ್ರಾರಂಭಿಸೋಣ - ಮತ್ತು ನಾವು ಇನ್ನು ಮುಂದೆ ಯೋಜನೆಯನ್ನು ಬಣ್ಣ ಮಾಡುವುದಿಲ್ಲ, ನಾವು ಈಗಾಗಲೇ ಅದನ್ನು ಬಣ್ಣಿಸಿದ್ದೇವೆ, ನಾವು ಈಗಾಗಲೇ ಅದನ್ನು ಸುಂದರ ಮತ್ತು ಅರ್ಥವಾಗುವಂತಹದ್ದಾಗಿದೆ, ಆದರೆ ವಿನಂತಿ.

ಅಂತಹ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡದ "ಶೀಟ್" ನೊಂದಿಗೆ ಲಾಗ್ನಿಂದ ಎಳೆಯಲಾದ ವಿನಂತಿಯು ತುಂಬಾ ಕೊಳಕು ಮತ್ತು ಆದ್ದರಿಂದ ಅನಾನುಕೂಲವಾಗಿ ಕಾಣುತ್ತದೆ ಎಂದು ನಮಗೆ ತೋರುತ್ತದೆ.


ವಿಶೇಷವಾಗಿ ಡೆವಲಪರ್‌ಗಳು ವಿನಂತಿಯ ದೇಹವನ್ನು ಕೋಡ್‌ನಲ್ಲಿ "ಅಂಟು" ಮಾಡಿದಾಗ (ಇದು ಸಹಜವಾಗಿ, ಆಂಟಿಪ್ಯಾಟರ್ನ್, ಆದರೆ ಅದು ಸಂಭವಿಸುತ್ತದೆ) ಒಂದು ಸಾಲಿನಲ್ಲಿ. ಭಯಾನಕ!

ಇದನ್ನು ಹೇಗಾದರೂ ಹೆಚ್ಚು ಸುಂದರವಾಗಿ ಚಿತ್ರಿಸೋಣ.


ಮತ್ತು ನಾವು ಇದನ್ನು ಸುಂದರವಾಗಿ ಸೆಳೆಯಲು ಸಾಧ್ಯವಾದರೆ, ಅಂದರೆ, ವಿನಂತಿಯ ದೇಹವನ್ನು ಡಿಸ್ಅಸೆಂಬಲ್ ಮಾಡಿ ಮತ್ತು ಮತ್ತೆ ಒಟ್ಟಿಗೆ ಸೇರಿಸಿದರೆ, ನಂತರ ನಾವು ಈ ವಿನಂತಿಯ ಪ್ರತಿಯೊಂದು ವಸ್ತುವಿಗೆ ಸುಳಿವನ್ನು "ಲಗತ್ತಿಸಬಹುದು" - ಯೋಜನೆಯ ಅನುಗುಣವಾದ ಹಂತದಲ್ಲಿ ಏನಾಯಿತು.

ಪ್ರಶ್ನೆ ಸಿಂಟ್ಯಾಕ್ಸ್ ಟ್ರೀ

ಇದನ್ನು ಮಾಡಲು, ವಿನಂತಿಯನ್ನು ಮೊದಲು ಪಾರ್ಸ್ ಮಾಡಬೇಕು.


ಏಕೆಂದರೆ ನಾವು ಹೊಂದಿದ್ದೇವೆ ವ್ಯವಸ್ಥೆಯ ಮುಖ್ಯಭಾಗವು NodeJS ನಲ್ಲಿ ಚಲಿಸುತ್ತದೆ, ನಂತರ ನಾವು ಅದಕ್ಕೆ ಮಾಡ್ಯೂಲ್ ಮಾಡಿದ್ದೇವೆ, ನೀವು ಮಾಡಬಹುದು ಅದನ್ನು GitHub ನಲ್ಲಿ ಹುಡುಕಿ. ವಾಸ್ತವವಾಗಿ, ಇವುಗಳು PostgreSQL ಪಾರ್ಸರ್‌ನ ಇಂಟರ್ನಲ್‌ಗಳಿಗೆ ವಿಸ್ತೃತ "ಬೈಂಡಿಂಗ್‌ಗಳು". ಅಂದರೆ, ವ್ಯಾಕರಣವನ್ನು ಸರಳವಾಗಿ ದ್ವಿಮಾನವಾಗಿ ಸಂಕಲಿಸಲಾಗಿದೆ ಮತ್ತು ಅದಕ್ಕೆ NodeJS ನಿಂದ ಬೈಂಡಿಂಗ್‌ಗಳನ್ನು ಮಾಡಲಾಗಿದೆ. ನಾವು ಇತರ ಜನರ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಆಧಾರವಾಗಿ ತೆಗೆದುಕೊಂಡಿದ್ದೇವೆ - ಇಲ್ಲಿ ಯಾವುದೇ ದೊಡ್ಡ ರಹಸ್ಯವಿಲ್ಲ.

ನಾವು ವಿನಂತಿಯ ದೇಹವನ್ನು ನಮ್ಮ ಕಾರ್ಯಕ್ಕೆ ಇನ್‌ಪುಟ್ ಆಗಿ ನೀಡುತ್ತೇವೆ - ಔಟ್‌ಪುಟ್‌ನಲ್ಲಿ ನಾವು JSON ಆಬ್ಜೆಕ್ಟ್‌ನ ರೂಪದಲ್ಲಿ ಪಾರ್ಸ್ ಮಾಡಿದ ಸಿಂಟ್ಯಾಕ್ಸ್ ಟ್ರೀ ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ.


ಈಗ ನಾವು ಈ ಮರದ ಮೂಲಕ ವಿರುದ್ಧ ದಿಕ್ಕಿನಲ್ಲಿ ಓಡಬಹುದು ಮತ್ತು ನಮಗೆ ಬೇಕಾದ ಇಂಡೆಂಟ್‌ಗಳು, ಬಣ್ಣ ಮತ್ತು ಫಾರ್ಮ್ಯಾಟಿಂಗ್‌ನೊಂದಿಗೆ ವಿನಂತಿಯನ್ನು ಜೋಡಿಸಬಹುದು. ಇಲ್ಲ, ಇದು ಗ್ರಾಹಕೀಯಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ಇದು ಅನುಕೂಲಕರವಾಗಿದೆ ಎಂದು ನಮಗೆ ತೋರುತ್ತದೆ.

ಮ್ಯಾಪಿಂಗ್ ಪ್ರಶ್ನೆ ಮತ್ತು ಪ್ಲಾನ್ ನೋಡ್‌ಗಳು

ಮೊದಲ ಹಂತದಲ್ಲಿ ನಾವು ವಿಶ್ಲೇಷಿಸಿದ ಯೋಜನೆಯನ್ನು ಮತ್ತು ಎರಡನೇ ಹಂತದಲ್ಲಿ ನಾವು ವಿಶ್ಲೇಷಿಸಿದ ಪ್ರಶ್ನೆಯನ್ನು ಹೇಗೆ ಸಂಯೋಜಿಸಬಹುದು ಎಂಬುದನ್ನು ಈಗ ನೋಡೋಣ.

ಸರಳವಾದ ಉದಾಹರಣೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ - ನಾವು CTE ಅನ್ನು ರಚಿಸುವ ಪ್ರಶ್ನೆಯನ್ನು ಹೊಂದಿದ್ದೇವೆ ಮತ್ತು ಅದರಿಂದ ಎರಡು ಬಾರಿ ಓದುತ್ತೇವೆ. ಅವನು ಅಂತಹ ಯೋಜನೆಯನ್ನು ರೂಪಿಸುತ್ತಾನೆ.

ಭಾಗಗಳಲ್ಲಿ CTE

ನೀವು ಅದನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ನೋಡಿದರೆ, ಆವೃತ್ತಿ 12 ರವರೆಗೆ (ಅಥವಾ ಕೀವರ್ಡ್‌ನಿಂದ ಪ್ರಾರಂಭಿಸಿ MATERIALIZED) ರಚನೆ CTE ಯೋಜಕರಿಗೆ ಸಂಪೂರ್ಣ ತಡೆಗೋಡೆಯಾಗಿದೆ.


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

ನಕ್ಷತ್ರ ಚಿಹ್ನೆಯೊಂದಿಗೆ ಸಮಸ್ಯೆ: CTE ಗಳನ್ನು ನೆಸ್ಟ್ ಮಾಡಬಹುದು.

ತುಂಬಾ ಕಳಪೆ ಗೂಡುಕಟ್ಟುವವುಗಳಿವೆ, ಮತ್ತು ಅದೇ ಹೆಸರಿನವುಗಳೂ ಇವೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ಒಳಗೆ ಮಾಡಬಹುದು CTE A ಮಾಡಿ CTE X, ಮತ್ತು ಒಳಗೆ ಅದೇ ಮಟ್ಟದಲ್ಲಿ CTE B ಮತ್ತೆ ಮಾಡಿ CTE X:

WITH A AS (
  WITH X AS (...)
  SELECT ...
)
, B AS (
  WITH X AS (...)
  SELECT ...
)
...

ಹೋಲಿಸಿದಾಗ, ನೀವು ಇದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು. "ನಿಮ್ಮ ಕಣ್ಣುಗಳಿಂದ" ಇದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು - ಯೋಜನೆಯನ್ನು ನೋಡುವುದು, ವಿನಂತಿಯ ದೇಹವನ್ನು ನೋಡುವುದು ಸಹ - ತುಂಬಾ ಕಷ್ಟ. ನಿಮ್ಮ CTE ಪೀಳಿಗೆಯು ಸಂಕೀರ್ಣವಾಗಿದ್ದರೆ, ನೆಸ್ಟೆಡ್ ಆಗಿದ್ದರೆ ಮತ್ತು ವಿನಂತಿಗಳು ದೊಡ್ಡದಾಗಿದ್ದರೆ, ಅದು ಸಂಪೂರ್ಣವಾಗಿ ಪ್ರಜ್ಞಾಹೀನವಾಗಿರುತ್ತದೆ.

ಒಕ್ಕೂಟ

ನಾವು ಪ್ರಶ್ನೆಯಲ್ಲಿ ಕೀವರ್ಡ್ ಹೊಂದಿದ್ದರೆ UNION [ALL] (ಎರಡು ಮಾದರಿಗಳನ್ನು ಸೇರುವ ಆಪರೇಟರ್), ನಂತರ ಯೋಜನೆಯಲ್ಲಿ ಅದು ನೋಡ್‌ಗೆ ಅನುರೂಪವಾಗಿದೆ Append, ಅಥವಾ ಕೆಲವು Recursive Union.


ಮೇಲಿನ "ಮೇಲೆ" ಯಾವುದು UNION - ಇದು ನಮ್ಮ ನೋಡ್‌ನ ಮೊದಲ ವಂಶಸ್ಥರು, ಅದು “ಕೆಳಗೆ” - ಎರಡನೆಯದು. ಮೂಲಕ ವೇಳೆ UNION ನಾವು ಹಲವಾರು ಬ್ಲಾಕ್ಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ "ಅಂಟಿಕೊಂಡಿದ್ದೇವೆ", ನಂತರ Append- ಇನ್ನೂ ಒಂದೇ ನೋಡ್ ಇರುತ್ತದೆ, ಆದರೆ ಅದು ಎರಡು ಅಲ್ಲ, ಆದರೆ ಅನೇಕ ಮಕ್ಕಳನ್ನು ಹೊಂದಿರುತ್ತದೆ - ಕ್ರಮವಾಗಿ ಅವರು ಹೋಗುವ ಕ್ರಮದಲ್ಲಿ:

  (...) -- #1
UNION ALL
  (...) -- #2
UNION ALL
  (...) -- #3

Append
  -> ... #1
  -> ... #2
  -> ... #3

ನಕ್ಷತ್ರ ಚಿಹ್ನೆಯೊಂದಿಗೆ ಸಮಸ್ಯೆ: ಒಳಗೆ ಪುನರಾವರ್ತಿತ ಮಾದರಿ ಉತ್ಪಾದನೆ (WITH RECURSIVE) ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಇರಬಹುದು UNION. ಆದರೆ ಕೊನೆಯದ ನಂತರದ ಕೊನೆಯ ಬ್ಲಾಕ್ ಮಾತ್ರ ಯಾವಾಗಲೂ ಪುನರಾವರ್ತಿತವಾಗಿರುತ್ತದೆ UNION. ಮೇಲಿನ ಎಲ್ಲವೂ ಒಂದೇ, ಆದರೆ ವಿಭಿನ್ನವಾಗಿದೆ UNION:

WITH RECURSIVE T AS(
  (...) -- #1
UNION ALL
  (...) -- #2, тут кончается генерация стартового состояния рекурсии
UNION ALL
  (...) -- #3, только этот блок рекурсивный и может содержать обращение к T
)
...

ಅಂತಹ ಉದಾಹರಣೆಗಳನ್ನು ನೀವು "ಹೊರಗೆ ಹಾಕಲು" ಸಹ ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ನಾವು ಅದನ್ನು ನೋಡುತ್ತೇವೆ UNION- ನಮ್ಮ ವಿನಂತಿಯಲ್ಲಿ 3 ವಿಭಾಗಗಳಿವೆ. ಅದರಂತೆ, ಒಂದು UNION ಗೆ ಅನುರೂಪವಾಗಿದೆ Append-ನೋಡ್, ಮತ್ತು ಇನ್ನೊಂದಕ್ಕೆ - Recursive Union.

ಓದಲು-ಬರೆಯಲು ಡೇಟಾ

ಎಲ್ಲವನ್ನೂ ಹಾಕಲಾಗಿದೆ, ಈಗ ಯಾವ ವಿನಂತಿಯ ಭಾಗವು ಯೋಜನೆಯ ಯಾವ ಭಾಗಕ್ಕೆ ಅನುರೂಪವಾಗಿದೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ. ಮತ್ತು ಈ ತುಣುಕುಗಳಲ್ಲಿ ನಾವು ಸುಲಭವಾಗಿ ಮತ್ತು ನೈಸರ್ಗಿಕವಾಗಿ "ಓದಬಲ್ಲ" ವಸ್ತುಗಳನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು.

ಪ್ರಶ್ನೆಯ ದೃಷ್ಟಿಕೋನದಿಂದ, ಇದು ಟೇಬಲ್ ಅಥವಾ CTE ಎಂದು ನಮಗೆ ತಿಳಿದಿಲ್ಲ, ಆದರೆ ಅವುಗಳನ್ನು ಒಂದೇ ನೋಡ್‌ನಿಂದ ಗೊತ್ತುಪಡಿಸಲಾಗಿದೆ RangeVar. ಮತ್ತು "ಓದಬಲ್ಲ" ಪರಿಭಾಷೆಯಲ್ಲಿ, ಇದು ಸಾಕಷ್ಟು ಸೀಮಿತವಾದ ನೋಡ್ಗಳ ಗುಂಪಾಗಿದೆ:

• Seq Scan on [tbl]
• Bitmap Heap Scan on [tbl]
• Index [Only] Scan [Backward] using [idx] on [tbl]
• CTE Scan on [cte]
• Insert/Update/Delete on [tbl]

ನಾವು ಯೋಜನೆ ಮತ್ತು ಪ್ರಶ್ನೆಯ ರಚನೆಯನ್ನು ತಿಳಿದಿದ್ದೇವೆ, ಬ್ಲಾಕ್ಗಳ ಪತ್ರವ್ಯವಹಾರವನ್ನು ನಾವು ತಿಳಿದಿದ್ದೇವೆ, ವಸ್ತುಗಳ ಹೆಸರುಗಳನ್ನು ನಾವು ತಿಳಿದಿದ್ದೇವೆ - ನಾವು ಒಂದರಿಂದ ಒಂದು ಹೋಲಿಕೆಯನ್ನು ಮಾಡುತ್ತೇವೆ.


ಮತ್ತೆ ಕಾರ್ಯ "ನಕ್ಷತ್ರ ಚಿಹ್ನೆಯೊಂದಿಗೆ". ನಾವು ವಿನಂತಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ, ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ, ನಮಗೆ ಯಾವುದೇ ಅಲಿಯಾಸ್ಗಳಿಲ್ಲ - ನಾವು ಒಂದೇ CTE ಯಿಂದ ಎರಡು ಬಾರಿ ಓದುತ್ತೇವೆ.


ನಾವು ಯೋಜನೆಯನ್ನು ನೋಡುತ್ತೇವೆ - ಸಮಸ್ಯೆ ಏನು? ನಮಗೆ ಅಲಿಯಾಸ್ ಏಕೆ ಇತ್ತು? ನಾವು ಆರ್ಡರ್ ಮಾಡಿಲ್ಲ. ಅಂತಹ "ಸಂಖ್ಯೆಯ ಸಂಖ್ಯೆ" ಅವನು ಎಲ್ಲಿ ಪಡೆಯುತ್ತಾನೆ?

PostgreSQL ಅದನ್ನು ಸ್ವತಃ ಸೇರಿಸುತ್ತದೆ. ನೀವು ಅದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು ಅಂತಹ ಅಲಿಯಾಸ್ ನಮಗೆ, ಯೋಜನೆಯೊಂದಿಗೆ ಹೋಲಿಕೆಯ ಉದ್ದೇಶಗಳಿಗಾಗಿ, ಇದು ಯಾವುದೇ ಅರ್ಥವಿಲ್ಲ, ಅದನ್ನು ಸರಳವಾಗಿ ಇಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ. ನಾವು ಅವನತ್ತ ಗಮನ ಹರಿಸಬಾರದು.

ಎರಡನೆಯದು ಕಾರ್ಯ "ನಕ್ಷತ್ರ ಚಿಹ್ನೆಯೊಂದಿಗೆ": ನಾವು ವಿಭಜಿತ ಕೋಷ್ಟಕದಿಂದ ಓದುತ್ತಿದ್ದರೆ, ನಾವು ನೋಡ್ ಅನ್ನು ಪಡೆಯುತ್ತೇವೆ Append ಅಥವಾ Merge Append, ಇದು ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ "ಮಕ್ಕಳನ್ನು" ಒಳಗೊಂಡಿರುತ್ತದೆ, ಮತ್ತು ಪ್ರತಿಯೊಂದೂ ಹೇಗಾದರೂ ಇರುತ್ತದೆ Scanಟೇಬಲ್ ವಿಭಾಗದಿಂದ 'ಓಂ: Seq Scan, Bitmap Heap Scan ಅಥವಾ Index Scan. ಆದರೆ, ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ, ಈ “ಮಕ್ಕಳು” ಸಂಕೀರ್ಣ ಪ್ರಶ್ನೆಗಳಾಗುವುದಿಲ್ಲ - ಈ ನೋಡ್‌ಗಳನ್ನು ಹೇಗೆ ಪ್ರತ್ಯೇಕಿಸಬಹುದು Append ನಲ್ಲಿ UNION.


ನಾವು ಅಂತಹ ಗಂಟುಗಳನ್ನು ಸಹ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ, ಅವುಗಳನ್ನು "ಒಂದು ರಾಶಿಯಲ್ಲಿ" ಸಂಗ್ರಹಿಸಿ ಮತ್ತು ಹೇಳುತ್ತೇವೆ: "ಮೆಗಾಟೇಬಲ್‌ನಿಂದ ನೀವು ಓದುವ ಎಲ್ಲವೂ ಇಲ್ಲಿ ಮತ್ತು ಮರದ ಕೆಳಗೆ ಇದೆ".

"ಸರಳ" ಡೇಟಾ ಸ್ವೀಕರಿಸುವ ನೋಡ್‌ಗಳು

Values Scan ಯೋಜನೆಯಲ್ಲಿ ಅನುರೂಪವಾಗಿದೆ VALUES ವಿನಂತಿಯಲ್ಲಿ.

Result ಇಲ್ಲದ ಕೋರಿಕೆಯಾಗಿದೆ FROM ಹಾಗೆ SELECT 1. ಅಥವಾ ನೀವು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ತಪ್ಪು ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಹೊಂದಿರುವಾಗ WHERE-ಬ್ಲಾಕ್ (ನಂತರ ಗುಣಲಕ್ಷಣವು ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ One-Time Filter):

EXPLAIN ANALYZE
SELECT * FROM pg_class WHERE FALSE; -- или 0 = 1

Result  (cost=0.00..0.00 rows=0 width=230) (actual time=0.000..0.000 rows=0 loops=1)
  One-Time Filter: false

Function Scan ಅದೇ ಹೆಸರಿನ SRF ಗಳಿಗೆ "ನಕ್ಷೆ".

ಆದರೆ ನೆಸ್ಟೆಡ್ ಪ್ರಶ್ನೆಗಳೊಂದಿಗೆ ಎಲ್ಲವೂ ಹೆಚ್ಚು ಜಟಿಲವಾಗಿದೆ - ದುರದೃಷ್ಟವಶಾತ್, ಅವು ಯಾವಾಗಲೂ ಬದಲಾಗುವುದಿಲ್ಲ InitPlan/SubPlan. ಕೆಲವೊಮ್ಮೆ ಅವು ಬದಲಾಗುತ್ತವೆ ... Join ಅಥವಾ ... Anti Join, ವಿಶೇಷವಾಗಿ ನೀವು ಏನನ್ನಾದರೂ ಬರೆಯುವಾಗ WHERE NOT EXISTS .... ಮತ್ತು ಇಲ್ಲಿ ಅವುಗಳನ್ನು ಸಂಯೋಜಿಸಲು ಯಾವಾಗಲೂ ಸಾಧ್ಯವಿಲ್ಲ - ಯೋಜನೆಯ ಪಠ್ಯದಲ್ಲಿ ಯೋಜನೆಯ ನೋಡ್‌ಗಳಿಗೆ ಅನುಗುಣವಾದ ನಿರ್ವಾಹಕರು ಇಲ್ಲ.

ಮತ್ತೆ ಕಾರ್ಯ "ನಕ್ಷತ್ರ ಚಿಹ್ನೆಯೊಂದಿಗೆ": ಕೆಲವು VALUES ವಿನಂತಿಯಲ್ಲಿ. ಈ ಸಂದರ್ಭದಲ್ಲಿ ಮತ್ತು ಯೋಜನೆಯಲ್ಲಿ ನೀವು ಹಲವಾರು ನೋಡ್ಗಳನ್ನು ಪಡೆಯುತ್ತೀರಿ Values Scan.


"ಸಂಖ್ಯೆಯ" ಪ್ರತ್ಯಯಗಳು ಅವುಗಳನ್ನು ಪರಸ್ಪರ ಪ್ರತ್ಯೇಕಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ - ಅನುಗುಣವಾದವುಗಳು ಕಂಡುಬರುವ ಕ್ರಮದಲ್ಲಿ ಅವುಗಳನ್ನು ನಿಖರವಾಗಿ ಸೇರಿಸಲಾಗುತ್ತದೆ VALUESಮೇಲಿನಿಂದ ಕೆಳಕ್ಕೆ ವಿನಂತಿಯ ಉದ್ದಕ್ಕೂ ನಿರ್ಬಂಧಿಸುತ್ತದೆ.

ಮಾಹಿತಿ ಸಂಸ್ಕರಣೆ

ನಮ್ಮ ವಿನಂತಿಯಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ವಿಂಗಡಿಸಲಾಗಿದೆ ಎಂದು ತೋರುತ್ತಿದೆ - ಅದು ಉಳಿದಿದೆ Limit.


ಆದರೆ ಇಲ್ಲಿ ಎಲ್ಲವೂ ಸರಳವಾಗಿದೆ - ಅಂತಹ ನೋಡ್ಗಳು Limit, Sort, Aggregate, WindowAgg, Unique ವಿನಂತಿಯಲ್ಲಿ ಅನುಗುಣವಾದ ಆಪರೇಟರ್‌ಗಳು ಇದ್ದಲ್ಲಿ "ನಕ್ಷೆ" ಒಂದರಿಂದ ಒಂದಕ್ಕೆ. ಇಲ್ಲಿ ಯಾವುದೇ "ನಕ್ಷತ್ರಗಳು" ಅಥವಾ ತೊಂದರೆಗಳಿಲ್ಲ.

ಸೇರಿರಿ

ನಾವು ಸಂಯೋಜಿಸಲು ಬಯಸಿದಾಗ ತೊಂದರೆಗಳು ಉದ್ಭವಿಸುತ್ತವೆ JOIN ತಮ್ಮ ನಡುವೆ. ಇದು ಯಾವಾಗಲೂ ಸಾಧ್ಯವಿಲ್ಲ, ಆದರೆ ಇದು ಸಾಧ್ಯ.


ಪ್ರಶ್ನೆ ಪಾರ್ಸರ್‌ನ ದೃಷ್ಟಿಕೋನದಿಂದ, ನಾವು ನೋಡ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ JoinExpr, ಇದು ನಿಖರವಾಗಿ ಇಬ್ಬರು ಮಕ್ಕಳನ್ನು ಹೊಂದಿದೆ - ಎಡ ಮತ್ತು ಬಲ. ಇದು, ಅದರ ಪ್ರಕಾರ, ನಿಮ್ಮ ಸೇರ್ಪಡೆ "ಮೇಲೆ" ಮತ್ತು ವಿನಂತಿಯಲ್ಲಿ "ಕೆಳಗೆ" ಏನು ಬರೆಯಲಾಗಿದೆ.

ಮತ್ತು ಯೋಜನೆಯ ದೃಷ್ಟಿಕೋನದಿಂದ, ಇವು ಕೆಲವರ ಇಬ್ಬರು ವಂಶಸ್ಥರು * Loop/* Join-ನೋಡ್. Nested Loop, Hash Anti Join,... - ಆ ರೀತಿಯ.

ಸರಳವಾದ ತರ್ಕವನ್ನು ಬಳಸೋಣ: ನಾವು ಯೋಜನೆಯಲ್ಲಿ ಪರಸ್ಪರ "ಸೇರುವ" A ಮತ್ತು B ಕೋಷ್ಟಕಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ನಂತರ ವಿನಂತಿಯಲ್ಲಿ ಅವುಗಳನ್ನು ಪತ್ತೆ ಮಾಡಬಹುದು A-JOIN-B, ಅಥವಾ B-JOIN-A. ಈ ರೀತಿಯಲ್ಲಿ ಸಂಯೋಜಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ, ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಸಂಯೋಜಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ, ಮತ್ತು ನಾವು ಅಂತಹ ಜೋಡಿಗಳನ್ನು ರನ್ ಔಟ್ ಮಾಡುವವರೆಗೆ.

ನಮ್ಮ ಸಿಂಟ್ಯಾಕ್ಸ್ ಮರವನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ, ನಮ್ಮ ಯೋಜನೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ, ಅವುಗಳನ್ನು ನೋಡಿ ... ಇದೇ ಅಲ್ಲ!


ಅದನ್ನು ಗ್ರಾಫ್‌ಗಳ ರೂಪದಲ್ಲಿ ಮತ್ತೆ ಚಿತ್ರಿಸೋಣ - ಓಹ್, ಇದು ಈಗಾಗಲೇ ಏನಾದರೂ ತೋರುತ್ತಿದೆ!


ನಾವು ಏಕಕಾಲದಲ್ಲಿ B ಮತ್ತು C ಮಕ್ಕಳನ್ನು ಹೊಂದಿರುವ ನೋಡ್ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ನಾವು ಗಮನಿಸೋಣ - ನಾವು ಯಾವ ಕ್ರಮದಲ್ಲಿ ಹೆದರುವುದಿಲ್ಲ. ಅವುಗಳನ್ನು ಒಗ್ಗೂಡಿ ಮತ್ತು ನೋಡ್ನ ಚಿತ್ರವನ್ನು ತಿರುಗಿಸೋಣ.


ಮತ್ತೊಮ್ಮೆ ನೋಡೋಣ. ಈಗ ನಾವು ಮಕ್ಕಳ A ಮತ್ತು ಜೋಡಿಗಳೊಂದಿಗೆ ನೋಡ್ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ (B + C) - ಅವರೊಂದಿಗೆ ಸಹ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ.


ಗ್ರೇಟ್! ನಾವು ಈ ಇಬ್ಬರು ಎಂದು ತಿರುಗುತ್ತದೆ JOIN ಪ್ಲಾನ್ ನೋಡ್‌ಗಳೊಂದಿಗೆ ವಿನಂತಿಯನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಸಂಯೋಜಿಸಲಾಗಿದೆ.

ಅಯ್ಯೋ, ಈ ಸಮಸ್ಯೆಯನ್ನು ಯಾವಾಗಲೂ ಪರಿಹರಿಸಲಾಗುವುದಿಲ್ಲ.


ಉದಾಹರಣೆಗೆ, ವಿನಂತಿಯಲ್ಲಿದ್ದರೆ A JOIN B JOIN C, ಮತ್ತು ಯೋಜನೆಯಲ್ಲಿ, ಮೊದಲನೆಯದಾಗಿ, "ಹೊರ" ನೋಡ್‌ಗಳು A ಮತ್ತು C ಅನ್ನು ಸಂಪರ್ಕಿಸಲಾಗಿದೆ. ಆದರೆ ವಿನಂತಿಯಲ್ಲಿ ಅಂತಹ ಯಾವುದೇ ಆಪರೇಟರ್ ಇಲ್ಲ, ನಮಗೆ ಹೈಲೈಟ್ ಮಾಡಲು ಏನೂ ಇಲ್ಲ, ಸುಳಿವು ಲಗತ್ತಿಸಲು ಏನೂ ಇಲ್ಲ. ನೀವು ಬರೆಯುವಾಗ "ಅಲ್ಪವಿರಾಮ" ದಂತೆಯೇ ಇರುತ್ತದೆ A, B.

ಆದರೆ, ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಬಹುತೇಕ ಎಲ್ಲಾ ನೋಡ್‌ಗಳನ್ನು "ಬಿಚ್ಚಬಹುದು" ಮತ್ತು ನೀವು ಈ ರೀತಿಯ ಪ್ರೊಫೈಲಿಂಗ್ ಅನ್ನು ಸಮಯಕ್ಕೆ ಎಡಭಾಗದಲ್ಲಿ ಪಡೆಯಬಹುದು - ಅಕ್ಷರಶಃ, ನೀವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸಿದಾಗ Google Chrome ನಂತೆ. ಪ್ರತಿ ಸಾಲು ಮತ್ತು ಪ್ರತಿ ಹೇಳಿಕೆಯು "ಕಾರ್ಯಗತಗೊಳಿಸಲು" ಎಷ್ಟು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ನೋಡಬಹುದು.


ಮತ್ತು ಈ ಎಲ್ಲವನ್ನೂ ಬಳಸಲು ನಿಮಗೆ ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗುವಂತೆ, ನಾವು ಸಂಗ್ರಹಣೆಯನ್ನು ಮಾಡಿದ್ದೇವೆ ಆರ್ಕೈವ್, ಅಲ್ಲಿ ನೀವು ಉಳಿಸಬಹುದು ಮತ್ತು ನಂತರ ಸಂಬಂಧಿತ ವಿನಂತಿಗಳೊಂದಿಗೆ ನಿಮ್ಮ ಯೋಜನೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು ಅಥವಾ ಯಾರೊಂದಿಗಾದರೂ ಲಿಂಕ್ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳಬಹುದು.

ನೀವು ಓದಲಾಗದ ಪ್ರಶ್ನೆಯನ್ನು ಸಮರ್ಪಕ ರೂಪಕ್ಕೆ ತರಬೇಕಾದರೆ, ಬಳಸಿ ನಮ್ಮ "ಸಾಮಾನ್ಯಕಾರಕ".

ಮೂಲ: www.habr.com