à²ªà²¾à²¤à³à²° à²à²¨à³ SAFE_CAST() BigQuery UDF à²à²³à²²à³à²²à²¿?

BigQuery ಸಂಬಂಧಿತ

Daniel Marino

ಗುರುವಾರ, ಅಕ್ಟೋಬರ್ 24, 2024 05:32:33 ಅಪರಾಹ್ನ

BigQuery UDF ಗಳು ಮತ್ತು ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಉಪಪ್ರಶ್ನೆಗಳು: ಸವಾಲುಗಳನ್ನು ಮೀರುವುದು

ಆಧುನಿಕ ಡೇಟಾ ಸಂಸ್ಕರಣೆ ಕೆಲಸದ ಹರಿವುಗಳಲ್ಲಿ, ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ಸಂಕೀರ್ಣ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ನಿರ್ವಹಿಸಲು Google ಕ್ಲೌಡ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನ BigQuery ಅನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ಕಾರ್ಯಗಳು (UDF ಗಳು) ಮತ್ತು ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಉಪಪ್ರಶ್ನೆಗಳ ಮೂಲಕ ನಿರ್ದಿಷ್ಟ ವ್ಯವಹಾರ ತರ್ಕವನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುವಾಗ ಬಳಕೆದಾರರು ಆಗಾಗ್ಗೆ ಮಿತಿಗಳನ್ನು ಎದುರಿಸುತ್ತಾರೆ. ಇದು ಸವಾಲುಗಳನ್ನು ರಚಿಸಬಹುದು, ವಿಶೇಷವಾಗಿ ರಜಾದಿನದ ಫ್ಲ್ಯಾಗ್‌ಗಳು ಅಥವಾ ಇತರ ಸಮಯ-ಸೂಕ್ಷ್ಮ ಡೇಟಾದಂತಹ ಸಿಬ್ಬಂದಿಯಿಂದ ನಿಯಮಿತವಾಗಿ ನವೀಕರಿಸಲಾಗುವ ಡೈನಾಮಿಕ್ ಕೋಷ್ಟಕಗಳನ್ನು ಉಲ್ಲೇಖಿಸುವಾಗ.

ದಿನಾಂಕ-ಚಾಲಿತ ವ್ಯವಹಾರ ಲೆಕ್ಕಾಚಾರಗಳೊಂದಿಗೆ ನೈಜ-ಸಮಯದ ಟೇಬಲ್ ಡೇಟಾವನ್ನು ಸಂಯೋಜಿಸಲು ಪ್ರಯತ್ನಿಸುವಾಗ UDF ಗಳಲ್ಲಿನ ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಉಪಪ್ರಶ್ನೆಗಳ ಸಮಸ್ಯೆಯು ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ. ಅಂತಹ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ, ಬಹು ಕೋಷ್ಟಕಗಳು ಮತ್ತು ಷರತ್ತುಬದ್ಧ ತರ್ಕವನ್ನು ಒಳಗೊಂಡಿರುವಾಗ ಲೆಕ್ಕಾಚಾರಗಳು ವಿಫಲಗೊಳ್ಳಬಹುದು. ಹಾರ್ಡ್‌ಕೋಡ್ ಮಾಡಲಾದ ಮೌಲ್ಯಗಳು ಕೆಲಸ ಮಾಡುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಸಮಸ್ಯಾತ್ಮಕವಾಗಿರುತ್ತದೆ, ಆದರೆ ಈ ಮಿತಿಗಳಿಂದಾಗಿ ಡೈನಾಮಿಕ್ ಡೇಟಾ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.

ಈ ಲೇಖನದಲ್ಲಿ, UDF ಯು ಎರಡು ದಿನಾಂಕಗಳ ನಡುವಿನ ಒಟ್ಟು ವಿಳಂಬವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಉದ್ದೇಶಿಸಿರುವ ಸಮಸ್ಯೆಯ ನಿರ್ದಿಷ್ಟ ಉದಾಹರಣೆಯ ಮೂಲಕ ನಾವು ನಡೆಯುತ್ತೇವೆ, ರಜಾದಿನಗಳು ಮತ್ತು ಕೆಲಸ ಮಾಡದ ದಿನಗಳ ಅಪವರ್ತನ, ಆದರೆ ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಉಪಪ್ರಶ್ನೆಗಳ ಮೇಲಿನ BigQuery ಮಿತಿಗಳಿಂದಾಗಿ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ. ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ನಾವು ಸಂಭಾವ್ಯ ಪರಿಹಾರಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಸಹ ಅನ್ವೇಷಿಸುತ್ತೇವೆ.

ನೀವು ಇದೇ ರೀತಿಯ ಸವಾಲುಗಳನ್ನು ಎದುರಿಸುತ್ತಿದ್ದರೆ, ಈ ಮಾರ್ಗದರ್ಶಿಯು ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಸಬ್‌ಕ್ವೆರಿ ದೋಷಗಳನ್ನು ನಿಭಾಯಿಸಲು ಮತ್ತು BigQuery ನಲ್ಲಿ ನಿಮ್ಮ UDF ಗಳನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿಸಲು ಒಳನೋಟಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಉದಾಹರಣೆಯಲ್ಲಿ ಧುಮುಕೋಣ ಮತ್ತು ಈ ಸಾಮಾನ್ಯ ರಸ್ತೆ ತಡೆಗಳನ್ನು ಹೇಗೆ ಜಯಿಸುವುದು ಎಂಬುದನ್ನು ಅನ್ವೇಷಿಸೋಣ.

ಆಜ್ಞೆ	ಬಳಕೆಯ ಉದಾಹರಣೆ
GENERATE_DATE_ARRAY()	ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಮಧ್ಯಂತರದೊಂದಿಗೆ ಎರಡು ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕಗಳ ನಡುವೆ ದಿನಾಂಕಗಳ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಲು ಈ ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಕೆಲಸದ ದಿನಗಳು ಮತ್ತು ಕೆಲಸ ಮಾಡದ ದಿನಗಳನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಕೆಲಸದ ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತಿಮ ದಿನಾಂಕಗಳ ನಡುವಿನ ದಿನಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಲು ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
UNNEST()	ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಸಾಲುಗಳ ಗುಂಪಿಗೆ ಅನ್‌ನೆಸ್ಟ್ ಮಾಡುತ್ತದೆ. ದಿನಾಂಕ ಶ್ರೇಣಿಗಳು ಅಥವಾ ರಜಾದಿನದ ಫ್ಲ್ಯಾಗ್‌ಗಳಂತಹ ಸರಣಿಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಈ ಸರಣಿಗಳನ್ನು ಹೆಚ್ಚಿನ ಪ್ರಶ್ನೆಗಾಗಿ ಪ್ರತ್ಯೇಕ ಸಾಲುಗಳಾಗಿ ಪರಿವರ್ತಿಸುವುದು ಅತ್ಯಗತ್ಯ.
ARRAY_AGG()	ಈ ಕಾರ್ಯವು ಅನೇಕ ಸಾಲುಗಳನ್ನು ಅರೇ ಆಗಿ ಒಟ್ಟುಗೂಡಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ರಜಾದಿನಗಳನ್ನು ಕೆಲಸದ ದಿನಗಳಿಂದ ಹೊರಗಿಡಲು UDF ಒಳಗೆ ಸುಲಭವಾಗಿ ಹುಡುಕಲು ರಜಾದಿನದ ದಿನಾಂಕಗಳು ಮತ್ತು ಧ್ವಜಗಳನ್ನು ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
EXTRACT()	ವಾರದ ದಿನದಂತಹ ದಿನಾಂಕ ಅಥವಾ ಸಮಯಸ್ಟ್ಯಾಂಪ್‌ನ ಭಾಗವನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ. ವಾರಾಂತ್ಯಗಳನ್ನು (ಶನಿವಾರ ಮತ್ತು ಭಾನುವಾರ) ಕೆಲಸದ ದಿನಗಳಿಂದ ಫಿಲ್ಟರ್ ಮಾಡುವಾಗ ಇದು ಮುಖ್ಯವಾಗಿದೆ, ವಾರದ ದಿನಗಳಲ್ಲಿ ಮಾತ್ರ ವಿಳಂಬವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
SAFE_CAST()	ಮೌಲ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಡೇಟಾ ಪ್ರಕಾರಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ, ಪರಿವರ್ತನೆ ವಿಫಲವಾದಲ್ಲಿ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಇನ್‌ಪುಟ್ ದಿನಾಂಕಗಳಲ್ಲಿ ಸಂಭಾವ್ಯ ದಿನಾಂಕ ಸ್ವರೂಪದ ಸಮಸ್ಯೆಗಳನ್ನು ನಿಭಾಯಿಸಲು ಮತ್ತು ದಿನಾಂಕ-ಸಂಬಂಧಿತ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ದೃಢವಾದ ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಈ ಆಜ್ಞೆಯು ಉಪಯುಕ್ತವಾಗಿದೆ.
LEFT JOIN	ಎರಡು ಕೋಷ್ಟಕಗಳನ್ನು ಸೇರುತ್ತದೆ, ಆದರೆ ಬಲ ಕೋಷ್ಟಕದಲ್ಲಿ ಯಾವುದೇ ಹೊಂದಾಣಿಕೆ ಇಲ್ಲದಿದ್ದರೂ ಎಡ ಕೋಷ್ಟಕದಿಂದ ಎಲ್ಲಾ ದಾಖಲೆಗಳನ್ನು ಇರಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ರಜಾದಿನದ ಕೋಷ್ಟಕದಲ್ಲಿ ಯಾವುದೇ ಹೊಂದಾಣಿಕೆಯ ರಜಾದಿನದ ದಿನಾಂಕಗಳು ಇಲ್ಲದಿದ್ದರೂ ಸಹ, ಎಲ್ಲಾ ದಿನಾಂಕಗಳನ್ನು ಲೆಕ್ಕಾಚಾರದಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.
STRUCT()	ರಚನಾತ್ಮಕ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ರಚಿಸುತ್ತದೆ, ಸಾಮಾನ್ಯವಾಗಿ ಸಂಬಂಧಿತ ಮೌಲ್ಯಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸೇರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಒದಗಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, UDF ನಲ್ಲಿ ಸುಲಭವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ದಿನಾಂಕ ಮತ್ತು ರಜಾದಿನದ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಒಂದೇ ರಚನೆಯಲ್ಲಿ ಸಂಯೋಜಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
TIMESTAMP_DIFF()	ಈ ಕಾರ್ಯವು ಎರಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ. ಕೆಲಸ ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತಿಮ ಸಮಯದ ನಡುವಿನ ಸಮಯದ ವಿಳಂಬವನ್ನು ನಿರ್ಧರಿಸಲು ಇದು ಮುಖ್ಯವಾಗಿದೆ, ಗಂಟೆಗಳಲ್ಲಿ ವಿಳಂಬವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವಾಗ ಬಳಸಲಾಗುತ್ತದೆ.
DATE_SUB()	ದಿನಾಂಕದಿಂದ ನಿಗದಿತ ಮಧ್ಯಂತರವನ್ನು ಕಳೆಯುತ್ತದೆ. ದಿನಾಂಕ ಶ್ರೇಣಿಯ ಲೆಕ್ಕಾಚಾರಗಳಲ್ಲಿ ಅಂತಿಮ ದಿನಾಂಕವನ್ನು ಸರಿಹೊಂದಿಸಲು, ನಿಖರವಾದ ಹೋಲಿಕೆಗಳನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಮತ್ತು ದಿನಾಂಕದ ಮಧ್ಯಂತರಗಳ ನಿರ್ವಹಣೆಯನ್ನು ಇಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.

BigQuery UDF ಗಳು ಮತ್ತು ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಸಬ್‌ಕ್ವೆರಿ ಪರಿಹಾರಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ರಜಾದಿನಗಳು ಮತ್ತು ವಾರಾಂತ್ಯಗಳಂತಹ ವ್ಯಾಪಾರ-ನಿರ್ದಿಷ್ಟ ಅಂಶಗಳನ್ನು ಅಪವರ್ತಿಸುವಾಗ ಎರಡು ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳ ನಡುವಿನ ಒಟ್ಟು ಕೆಲಸದ ಸಮಯವನ್ನು ಲೆಕ್ಕಹಾಕುವುದು ಮೇಲೆ ಒದಗಿಸಲಾದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಪ್ರಾಥಮಿಕ ಗುರಿಯಾಗಿದೆ. ಕೆಲಸ ಮಾಡದ ದಿನಗಳನ್ನು ಹೊರತುಪಡಿಸಿ ಕೆಲಸದ ಅವಧಿಯನ್ನು ಅಳೆಯುವ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ವರದಿ ಮಾಡಲು ಈ ಲೆಕ್ಕಾಚಾರವು ನಿರ್ಣಾಯಕವಾಗಿದೆ. Google BigQuery ನಲ್ಲಿ ಈ ತರ್ಕವನ್ನು ಎನ್ಕ್ಯಾಪ್ಸುಲೇಟ್ ಮಾಡಲು ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ಕಾರ್ಯವನ್ನು (UDF) ಇಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. ಎದುರಿಸುತ್ತಿರುವ ಪ್ರಮುಖ ಸವಾಲುಗಳಲ್ಲಿ ಒಂದು ವ್ಯವಹರಿಸುವುದು ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಉಪಪ್ರಶ್ನೆಗಳು UDF ಗಳಲ್ಲಿ, ಇದು ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಪ್ರಶ್ನಿಸುವಾಗ ದೋಷಗಳು ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರಮುಖ ಅಂಶಗಳಲ್ಲಿ ಒಂದು ಬಳಕೆಯಾಗಿದೆ GENERATE_DATE_ARRAY ಕಾರ್ಯ. ಈ ಕಾರ್ಯವು ಎರಡು ನೀಡಲಾದ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್‌ಗಳ ನಡುವಿನ ಎಲ್ಲಾ ದಿನಾಂಕಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸುತ್ತದೆ. ದಿನಾಂಕ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುವ ಮೂಲಕ, ಕೆಲಸದ ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತಿಮ ಸಮಯದ ನಡುವೆ ಎಷ್ಟು ಕೆಲಸದ ದಿನಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ ಎಂಬುದನ್ನು ಸ್ಕ್ರಿಪ್ಟ್ ನಿಖರವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡಬಹುದು. ಈ ಪಟ್ಟಿಯಿಂದ ರಜಾದಿನಗಳು ಮತ್ತು ವಾರಾಂತ್ಯಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು, ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುತ್ತದೆ ARRAY_AGG ರಜಾ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಕಾರ್ಯ ಮತ್ತು UNNEST ಸುಲಭವಾದ ಹೋಲಿಕೆಗಾಗಿ ಅರೇಗಳನ್ನು ಸಾಲುಗಳಾಗಿ ಪರಿವರ್ತಿಸುವ ಕಾರ್ಯ.

ಪರಿಹಾರದ ಮತ್ತೊಂದು ನಿರ್ಣಾಯಕ ಭಾಗವೆಂದರೆ ರಜೆಯ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುವುದು. ಸಿಬ್ಬಂದಿಯಿಂದ ನಿಯಮಿತವಾಗಿ ನವೀಕರಿಸಲಾಗುವ ಹಾಲಿಡೇ ಟೇಬಲ್ ಅನ್ನು ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ರಜಾದಿನಗಳು ಅಥವಾ ವಾರಾಂತ್ಯಗಳೊಂದಿಗೆ ಹೊಂದಿಕೆಯಾಗುವ ಯಾವುದೇ ದಿನಾಂಕಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ. ಸಂಯೋಜನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಸಾಧಿಸಲಾಗುತ್ತದೆ ಎಡಕ್ಕೆ ಸೇರಿಕೊಳ್ಳಿ ಮತ್ತು ದಿ ಹೊರತೆಗೆಯಿರಿ ಕಾರ್ಯ, ಇದು ವಾರದ ದಿನದಂತಹ ದಿನಾಂಕದ ನಿರ್ದಿಷ್ಟ ಭಾಗಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುತ್ತದೆ. ವಾರಾಂತ್ಯಗಳನ್ನು (ಶನಿವಾರ ಮತ್ತು ಭಾನುವಾರ) ಫಿಲ್ಟರ್ ಮಾಡುವುದರಿಂದ ಕೆಲಸದ ದಿನಗಳು ಮಾತ್ರ ಅಂತಿಮ ವಿಳಂಬ ಲೆಕ್ಕಾಚಾರಕ್ಕೆ ಕೊಡುಗೆ ನೀಡುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಅಂತಿಮವಾಗಿ, UDF ಅನ್ನು ಬಳಸಿಕೊಂಡು ಇನ್‌ಪುಟ್ ಮೌಲ್ಯಗಳು ಸರಿಯಾದ ಸ್ವರೂಪದಲ್ಲಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಕೆಲವು ದಿನಾಂಕದ ಮೌಲ್ಯೀಕರಣವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ SAFE_CAST ಕಾರ್ಯ. ಅಮಾನ್ಯವಾದ ದಿನಾಂಕ ಸ್ವರೂಪವನ್ನು ನಮೂದಿಸಿದರೆ UDF ವಿಫಲಗೊಳ್ಳುವುದನ್ನು ಈ ಕಾರ್ಯವು ತಡೆಯುತ್ತದೆ, ಇದು ಹೆಚ್ಚುವರಿ ಭದ್ರತೆಯ ಪದರವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಅಂತಿಮ ಫಲಿತಾಂಶವನ್ನು ಕೆಲಸದ ದಿನಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸಿ ಮತ್ತು ಭಾಗಶಃ ಕೆಲಸದ ದಿನಗಳಲ್ಲಿ ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತಿಮ ಸಮಯವನ್ನು ಹೊಂದಿಸುವ ಮೂಲಕ ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ. ಈ ವಿಧಾನವು UDF ಮಿತಿಗಳಿಗೆ ಬದ್ಧವಾಗಿರುವಾಗ BigQuery ನಲ್ಲಿ ವಿಳಂಬವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವ ಸಂಕೀರ್ಣ ಸಮಸ್ಯೆಗೆ ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಪರಿಹಾರವನ್ನು ನೀಡುತ್ತದೆ.

BigQuery UDF ಆಪ್ಟಿಮೈಸೇಶನ್: ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಸಬ್ಕ್ವೆರಿ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವುದು

BigQuery UDF ಗಳಿಗಾಗಿ ಆಪ್ಟಿಮೈಸ್ಡ್ ಅರೇ ಹ್ಯಾಂಡ್ಲಿಂಗ್‌ನೊಂದಿಗೆ ಸ್ಟ್ಯಾಂಡರ್ಡ್ SQL ಅನ್ನು ಬಳಸುವ ಪರಿಹಾರ

CREATE OR REPLACE FUNCTION my.gcp.optimized_function(ip_start_date TIMESTAMP, ip_end_date TIMESTAMP)
RETURNS NUMERIC AS ((
WITH temp_date AS (
  SELECT
    CASE
      WHEN ip_start_date > ip_end_date THEN DATE(ip_end_date)
      ELSE DATE(ip_start_date)
    END AS ip_date_01,
    CASE
      WHEN ip_start_date > ip_end_date THEN DATE(ip_start_date)
      ELSE DATE(ip_end_date)
    END AS ip_date_02
),
holiday_array AS (
  SELECT ARRAY_AGG(STRUCT(DATE(cal_date) AS cal_date, holiday_flag)) AS holidays
  FROM dataset.staff_time
),
working_days AS (
  SELECT
    CASE
      WHEN DATE(ip_start_date) <> DATE(ip_end_date) THEN
        SUM(CASE
          WHEN cal_date NOT IN (SELECT cal_date FROM UNNEST(holiday_array.holidays)) THEN 1
          ELSE 0
        END)
      ELSE 
    END AS working_day
  FROM UNNEST(GENERATE_DATE_ARRAY(ip_start_date, ip_end_date, INTERVAL 1 DAY)) AS cal_date
  WHERE cal_date NOT IN (SELECT cal_date FROM UNNEST(holiday_array.holidays))
),
SELECT working_day
FROM working_days));

ಸಬ್‌ಕ್ವೆರಿ ಸೇರ್ಪಡೆಗಳೊಂದಿಗೆ BigQuery UDF ಪರಸ್ಪರ ಸಂಬಂಧ ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ಉಪಪ್ರಶ್ನೆ ಸಮಸ್ಯೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡಲು LEFT JOIN ಮತ್ತು ಅರೇ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುವ ಮೂಲಕ ಪರಿಹಾರ

CREATE OR REPLACE FUNCTION my.gcp.function_v2(ip_start_date TIMESTAMP, ip_end_date TIMESTAMP)
RETURNS NUMERIC AS ((
WITH temp_date AS (
  SELECT
    CASE
      WHEN ip_start_date > ip_end_date THEN DATE(ip_end_date)
      ELSE DATE(ip_start_date)
    END AS ip_date_01,
    CASE
      WHEN ip_start_date > ip_end_date THEN DATE(ip_start_date)
      ELSE DATE(ip_end_date)
    END AS ip_date_02
),
holiday_array AS (
  SELECT ARRAY_AGG(STRUCT(DATE(cal_date) AS cal_date, holiday_flag)) AS holidays
  FROM dataset.staff_time
),
working_days AS (
  SELECT
    CASE
      WHEN DATE(ip_start_date) <> DATE(ip_end_date) THEN
        SUM(CASE
          WHEN ot.cal_date IS  AND EXTRACT(DAYOFWEEK FROM cal_date) NOT IN (1, 7) THEN 1
          ELSE 0
        END)
      ELSE 
    END AS working_day
  FROM UNNEST(GENERATE_DATE_ARRAY(SAFE_CAST(ip_start_date AS DATE),
  DATE_SUB(SAFE_CAST(ip_end_date AS DATE), INTERVAL 1 DAY), INTERVAL 1 DAY)) AS cal_date
  LEFT JOIN holiday_array ot
  ON cal_date = ot.cal_date
  WHERE ot.cal_date IS 
    AND EXTRACT(DAYOFWEEK FROM cal_date) NOT IN (1, 7)
),
SELECT working_day
FROM working_days));

BigQuery UDF ಮಿತಿಗಳನ್ನು ಮೀರುವುದು: ಪ್ರಶ್ನೆ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು

ಯಾವುದೇ ದೊಡ್ಡ ಪ್ರಮಾಣದ ಡೇಟಾ ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ, ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ದಕ್ಷತೆ ಅತ್ಯಗತ್ಯ. BigQuery ನಲ್ಲಿ ಉದ್ಭವಿಸುವ ಒಂದು ಪ್ರಮುಖ ಸವಾಲು ಎಂದರೆ ಸೀಮಿತ ಸಾಮರ್ಥ್ಯ ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ಕಾರ್ಯಗಳು (UDFs) ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಉಪಪ್ರಶ್ನೆಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸಲು, ವಿಶೇಷವಾಗಿ UDF ಬಾಹ್ಯ ಕೋಷ್ಟಕಗಳನ್ನು ಉಲ್ಲೇಖಿಸಿದಾಗ ಅಥವಾ ಬಹು ಸೇರ್ಪಡೆಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕಾದಾಗ. ಈ ಸಮಸ್ಯೆಗಳು ಸಾಮಾನ್ಯವಾಗಿ ನಿಧಾನಗತಿಯ ಕಾರ್ಯಕ್ಷಮತೆ ಅಥವಾ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತವೆ. ರಜಾದಿನದ ಕೋಷ್ಟಕಗಳಂತಹ ಆಗಾಗ್ಗೆ ನವೀಕರಿಸುವ ಡೇಟಾವನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಎಳೆಯಲು ತರ್ಕವು ಅಗತ್ಯವಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದು ವಿಶೇಷವಾಗಿ ಸಮಸ್ಯಾತ್ಮಕವಾಗಿರುತ್ತದೆ. ಇದನ್ನು ನಿವಾರಿಸಲು, ಈ ಮಿತಿಗಳನ್ನು ಬೈಪಾಸ್ ಮಾಡಲು ನಿಮ್ಮ ಪ್ರಶ್ನೆಗಳನ್ನು ರಚಿಸುವ ಪರ್ಯಾಯ ಮಾರ್ಗಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಬಹಳ ಮುಖ್ಯ.

ಮಧ್ಯಂತರ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅಥವಾ ಸಮಯಕ್ಕಿಂತ ಮುಂಚಿತವಾಗಿ ಡೇಟಾವನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವ ಮೂಲಕ ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಉಪಪ್ರಶ್ನೆಗಳ ಮೇಲಿನ ಅವಲಂಬನೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು ಒಂದು ವಿಧಾನವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಕಾರ್ಯದಲ್ಲಿ ಹಾಲಿಡೇ ಟೇಬಲ್ ಅನ್ನು ಹಲವು ಬಾರಿ ಉಲ್ಲೇಖಿಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿ, ಒಟ್ಟುಗೂಡಿಸಿದ ರಚನೆ ಅಥವಾ ತಾತ್ಕಾಲಿಕ ಕೋಷ್ಟಕದಂತಹ ಹೆಚ್ಚು ಪ್ರವೇಶಿಸಬಹುದಾದ ಸ್ವರೂಪದಲ್ಲಿ ರಜಾದಿನದ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ. ಇದು ನಿಮ್ಮ UDF ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯದಲ್ಲಿ ನೈಜ-ಸಮಯದ ಸೇರ್ಪಡೆಗಳ ಅಗತ್ಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಇದಲ್ಲದೆ, ಹತೋಟಿ ರಚನೆಯ ಕಾರ್ಯಗಳು ಇಷ್ಟ ARRAY_AGG() ಮತ್ತು UNNEST() ಪುನರಾವರ್ತಿತ ಉಪಪ್ರಶ್ನೆಗಳೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪೆನಾಲ್ಟಿಗಳಿಲ್ಲದೆ ನೀವು ಸಂಕೀರ್ಣ ಡೇಟಾ ರಚನೆಗಳನ್ನು ನಿಭಾಯಿಸಬಹುದು ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಮತ್ತೊಂದು ತಂತ್ರವು BigQuery ಅನ್ನು ಬಳಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ SAFE_CAST() ಸಂಭಾವ್ಯ ಸ್ವರೂಪದ ಸಮಸ್ಯೆಗಳನ್ನು ಆಕರ್ಷಕವಾಗಿ ನಿಭಾಯಿಸಲು ಕಾರ್ಯ, ಇದು ಅನಗತ್ಯ ಪ್ರಶ್ನೆ ವೈಫಲ್ಯಗಳನ್ನು ತಡೆಯುತ್ತದೆ. ಇನ್‌ಪುಟ್ ಡೇಟಾದ ದೃಢತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಮತ್ತು ಆಂತರಿಕವಾಗಿ ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ UDF ವಿಫಲಗೊಳ್ಳಲು ಕಾರಣವಾಗುವ ರನ್‌ಟೈಮ್ ಸಮಸ್ಯೆಗಳನ್ನು ನೀವು ತಡೆಯಬಹುದು. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಸಂಸ್ಕರಣೆಯನ್ನು ಸ್ಟ್ರೀಮ್‌ಲೈನ್ ಮಾಡಲು ನಿರ್ದಿಷ್ಟ ಲೆಕ್ಕಾಚಾರವನ್ನು ಯುಡಿಎಫ್‌ನ ಹೊರಗೆ ಸರಳೀಕರಿಸಬಹುದೇ ಅಥವಾ ಆಫ್‌ಲೋಡ್ ಮಾಡಬಹುದೇ ಎಂದು ಯಾವಾಗಲೂ ಪರಿಗಣಿಸಿ. BigQuery ನ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಪರಿಸರದ ಮಿತಿಗಳಿಗೆ ಬದ್ಧವಾಗಿರುವಾಗ ನಿಮ್ಮ UDF ಗಳು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂದು ಅಂತಹ ವಿಧಾನಗಳು ಖಚಿತಪಡಿಸುತ್ತವೆ.

BigQuery UDF ಗಳು ಮತ್ತು ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಉಪಪ್ರಶ್ನೆಗಳಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

BigQuery ನಲ್ಲಿ ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಸಬ್‌ಕ್ವೆರಿ ದೋಷಗಳನ್ನು ನಾನು ಹೇಗೆ ತಪ್ಪಿಸಬಹುದು?
ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಉಪಪ್ರಶ್ನೆ ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಲು, ಬಳಸಲು ನಿಮ್ಮ ಪ್ರಶ್ನೆಗಳನ್ನು ಪುನರ್ರಚಿಸಲು ಪ್ರಯತ್ನಿಸಿ ARRAY_AGG() ಮತ್ತು UNNEST() ಯುಡಿಎಫ್‌ಗಳ ಒಳಗೆ ಸೇರುವ ಅಗತ್ಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಕಾರ್ಯಗಳು ಅಥವಾ ಪೂರ್ವ-ಒಟ್ಟಾರೆ ಡೇಟಾ.
ಬಾಹ್ಯ ಕೋಷ್ಟಕವನ್ನು ಉಲ್ಲೇಖಿಸುವಾಗ ನನ್ನ BigQuery UDF ಏಕೆ ನಿಧಾನವಾಗಿದೆ?
BigQuery UDF ಗಳು ಬಾಹ್ಯ ಕೋಷ್ಟಕಗಳನ್ನು ಪದೇ ಪದೇ ಉಲ್ಲೇಖಿಸಿದಾಗ ನಿಧಾನವಾಗುತ್ತವೆ, ವಿಶೇಷವಾಗಿ ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಉಪಪ್ರಶ್ನೆಗಳಲ್ಲಿ. ಇದನ್ನು ಸರಿಪಡಿಸಲು, ತಾತ್ಕಾಲಿಕ ಕೋಷ್ಟಕಗಳಲ್ಲಿ ನಿರ್ಣಾಯಕ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಿ ಅಥವಾ ಪ್ರಶ್ನೆ ಓವರ್ಹೆಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಕ್ಯಾಶಿಂಗ್ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಬಳಸಿ.
ಪಾತ್ರ ಏನು SAFE_CAST() BigQuery UDF ಗಳಲ್ಲಿ?
ದಿ SAFE_CAST() ಮೌಲ್ಯಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಪರಿವರ್ತಿಸುವ ಮೂಲಕ ಮತ್ತು ಪರಿವರ್ತನೆ ವಿಫಲವಾದಲ್ಲಿ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಮೂಲಕ ಅಮಾನ್ಯ ದಿನಾಂಕ ಸ್ವರೂಪಗಳು ಅಥವಾ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಪ್ರಶ್ನೆಯ ವೈಫಲ್ಯಕ್ಕೆ ಕಾರಣವಾಗುವುದಿಲ್ಲ ಎಂದು ಕಾರ್ಯವು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ದಿನಾಂಕ ಶ್ರೇಣಿಗಳು ಮತ್ತು ರಜಾದಿನಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನನ್ನ UDF ಅನ್ನು ನಾನು ಹೇಗೆ ಆಪ್ಟಿಮೈಜ್ ಮಾಡಬಹುದು?
ಮುಂತಾದ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿ GENERATE_DATE_ARRAY() ದಿನಾಂಕ ಶ್ರೇಣಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು EXTRACT() ಲೆಕ್ಕಾಚಾರಗಳಿಂದ ವಾರಾಂತ್ಯ ಅಥವಾ ರಜಾದಿನಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು. ಇವುಗಳು ನಿಮ್ಮ UDF ನಲ್ಲಿ ಕೆಲಸದ ದಿನಗಳ ನಿಖರವಾದ ನಿರ್ವಹಣೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತವೆ.
ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗಾಗಿ ನಾನು BigQuery UDF ಗಳನ್ನು ಬಳಸಬಹುದೇ?
ಹೌದು, ಆದರೆ ನಿಮ್ಮ ಪ್ರಶ್ನೆಗಳನ್ನು ನೀವು ಎಚ್ಚರಿಕೆಯಿಂದ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಬಾಹ್ಯ ಕೋಷ್ಟಕಗಳನ್ನು ಎಷ್ಟು ಬಾರಿ ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಕಡಿಮೆ ಮಾಡಿ ಮತ್ತು ದಕ್ಷ ರಚನೆಯ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿ ARRAY_AGG() ಸಂಕೀರ್ಣ ಡೇಟಾ ರಚನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು.

BigQuery UDF ಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವ ಕುರಿತು ಅಂತಿಮ ಆಲೋಚನೆಗಳು

BigQuery ನಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಉಪಪ್ರಶ್ನೆಗಳು ಮುಖ್ಯ ಮಿತಿಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಪೂರ್ವ-ಸಂಯೋಜಿತ ಡೇಟಾ, ಅರೇ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು ಬುದ್ಧಿವಂತ ದಿನಾಂಕ ನಿರ್ವಹಣೆಯಂತಹ ಪರ್ಯಾಯ ವಿಧಾನಗಳನ್ನು ನಿಯಂತ್ರಿಸುವ ಮೂಲಕ, ಈ ಮಿತಿಗಳನ್ನು ತಗ್ಗಿಸಬಹುದು, ಪ್ರಶ್ನೆ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು.

ಪ್ರಶ್ನೆ ವಿನ್ಯಾಸವನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು ಮತ್ತು UDF ಒಳಗೆ ಬಾಹ್ಯ ಕೋಷ್ಟಕಗಳ ಉಲ್ಲೇಖಗಳನ್ನು ಕಡಿಮೆಗೊಳಿಸುವುದರಿಂದ ದೋಷಗಳು ಮತ್ತು ನಿಧಾನಗತಿಯನ್ನು ಗಣನೀಯವಾಗಿ ಕಡಿಮೆ ಮಾಡಬಹುದು. ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಡೆವಲಪರ್‌ಗಳಿಗೆ, ಈ ತಂತ್ರಗಳನ್ನು ಅನ್ವಯಿಸುವುದರಿಂದ BigQuery ನಲ್ಲಿ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ವರದಿ ಮತ್ತು ಕಡಿಮೆ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

ಮೂಲಗಳು ಮತ್ತು ಉಲ್ಲೇಖಗಳು

BigQuery UDF ಮಿತಿಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳ ವಿವರಗಳನ್ನು ಇಲ್ಲಿ ಕಾಣಬಹುದು Google BigQuery ಡಾಕ್ಯುಮೆಂಟೇಶನ್ .
ಪರಸ್ಪರ ಸಂಬಂಧಿತ ಉಪಪ್ರಶ್ನೆಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಮತ್ತು BigQuery ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸುವ ಕುರಿತು ಹೆಚ್ಚಿನ ಒಳನೋಟಗಳಿಗಾಗಿ, ಭೇಟಿ ನೀಡಿ ಡೇಟಾ ಸೈನ್ಸ್ ಕಡೆಗೆ - BigQuery ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು .
ಸಾಮಾನ್ಯ BigQuery ದೋಷಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ದೋಷನಿವಾರಣೆ ವಿಧಾನಗಳನ್ನು ಇಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ BigQuery ಕ್ವೆರಿ ಸಿಂಟ್ಯಾಕ್ಸ್ ಮತ್ತು ಟ್ರಬಲ್‌ಶೂಟಿಂಗ್ .

BigQuery ಸಂಬಂಧಿತ ಉಪಪ್ರಶ್ನೆಗಳು ಮತ್ತು UDF ಮಿತಿಗಳನ್ನು ಪರಿಹರಿಸುವುದು: ಪ್ರಾಯೋಗಿಕ ಮಾರ್ಗದರ್ಶಿ