SQL ಟೆಸ್ಟ್ ಅಭ್ಯಾಸ

ನಿಜವಾದ ಪರೀಕ್ಷೆ ಸಾಮಾನ್ಯವಾಗಿ ಹೇಗಿರುತ್ತದೆ

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

• HackerRank‌ನ SQL ಕೌಶಲ್ಯ ಪರೀಕ್ಷೆಗಳು. HackerRank ತನ್ನ SQL (Basic) ಕೌಶಲ್ಯ ಪರೀಕ್ಷೆಯಲ್ಲಿ ಸರಳ queries ನಂತಹ ವಿಷಯಗಳನ್ನು ಒಳಗೊಂಡಂತೆ 30 ನಿಮಿಷಗಳಲ್ಲಿ 2 ಪ್ರಶ್ನೆಗಳು ಇರುತ್ತವೆ ಎಂದು ಪಟ್ಟಿ ಮಾಡಿದೆ (HackerRank). ಅದರ SQL (Intermediate) ಪರೀಕ್ಷೆಯಲ್ಲಿ ಸಂಕೀರ್ಣ joins ನಂತಹ ವಿಷಯಗಳನ್ನು ಒಳಗೊಂಡಂತೆ 35 ನಿಮಿಷಗಳಲ್ಲಿ 2 ಪ್ರಶ್ನೆಗಳು ಇರುತ್ತವೆ (HackerRank). ತಮ್ಮದೇ HackerRank ಪರೀಕ್ಷೆಗಳನ್ನು ರಚಿಸುವ ಉದ್ಯೋಗದಾತರು ಡೇಟಾಬೇಸ್ ಕುರಿತ ಪ್ರಶ್ನೆಗಳನ್ನು ಸೇರಿಸಬಹುದು ಮತ್ತು ಅಭ್ಯರ್ಥಿಗಳು ಯಾವ ಡೇಟಾಬೇಸ್‌ಗಳನ್ನು ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು (HackerRank support).
• Query ಬರೆಯುವ ಕಾರ್ಯ. TestGorilla ತನ್ನ SQLite coding ಪರೀಕ್ಷೆಯು 30 ನಿಮಿಷಗಳದ್ದು ಎಂದು ವಿವರಿಸುತ್ತದೆ. ಮಧ್ಯಮ ಸಂಕೀರ್ಣತೆಯ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ವಾಸ್ತವಿಕ ಸನ್ನಿವೇಶಕ್ಕೆ query ಬರೆಯುವುದು ಇದರ ಭಾಗವಾಗಿದೆ. ಇದರಲ್ಲಿ joins ಮತ್ತು filtering, ಸರಳ ಲೆಕ್ಕಾಚಾರಗಳು, sorting, rounding ಮತ್ತು ಅನಗತ್ಯ ದಾಖಲೆಗಳನ್ನು ಹೊರತುಪಡಿಸುವುದು ಸೇರಿವೆ (TestGorilla).
• ಸಂಕ್ಷಿಪ್ತ ಜ್ಞಾನ ಪರೀಕ್ಷೆ. TestGorilla ತನ್ನ MySQL ಪರೀಕ್ಷೆಯಲ್ಲಿ 101 ಪ್ರಶ್ನೆಗಳ ಸಂಗ್ರಹದಿಂದ ಆಯ್ದ 10 ನಿಮಿಷಗಳಲ್ಲಿ 15 ಪ್ರಶ್ನೆಗಳು ಇರುತ್ತವೆ ಎಂದು ಪಟ್ಟಿ ಮಾಡಿದೆ (TestGorilla).

SQL ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ವರದಿಯಾಗುವ ವಿಷಯಗಳು:

• Filtering ಮತ್ತು sorting: SELECT, WHERE, ORDER BY ಹಾಗೂ AND, OR, IN ಮತ್ತು BETWEEN ಬಳಸಿ ಷರತ್ತುಗಳನ್ನು ನೀಡುವುದು.
• Joins: inner ಮತ್ತು left joins, ಹಾಗೆಯೇ ಹೊಂದಾಣಿಕೆ ಇಲ್ಲದ rows‌ಗೆ ಏನಾಗುತ್ತದೆ ಎಂಬುದು.
• Grouping: COUNT, SUM, AVG, MIN ಮತ್ತು MAX ಜೊತೆಗೆ GROUP BY, ಮತ್ತು ಗುಂಪುಗಳನ್ನು filter ಮಾಡಲು HAVING.
• NULLಗಳು: ಹೋಲಿಕೆಗಳು, ಎಣಿಕೆಗಳು ಮತ್ತು ಸರಾಸರಿಗಳಲ್ಲಿ ಕಾಣೆಯಾದ ಮೌಲ್ಯಗಳು ಹೇಗೆ ವರ್ತಿಸುತ್ತವೆ ಎಂಬುದು.
• Subqueries: IN, EXISTS ಅಥವಾ ಒಂದೇ ಮೌಲ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು, ಮತ್ತೊಂದು query ಒಳಗೆ ಇರುವ query.
• ಸರಳ ಭಾಷೆಯ ವಿನಂತಿಯಿಂದ query ಬರೆಯುವುದು, ಸಾಮಾನ್ಯವಾಗಿ ನಿರೀಕ್ಷಿತ rows‌ಗಳನ್ನೇ ಅದು ಹಿಂದಿರುಗಿಸುತ್ತದೆಯೇ ಎಂಬುದರ ಆಧಾರದ ಮೇಲೆ ಅಂಕ ನೀಡಲಾಗುತ್ತದೆ.

ನಮ್ಮ ಅಭ್ಯಾಸ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಏನಿದೆ. ಪ್ರತಿ ಪೂರ್ಣ ಅಭ್ಯಾಸ ಪರೀಕ್ಷೆಯಲ್ಲಿ ನಾಲ್ಕು ವಿಭಾಗಗಳಲ್ಲಿ 45 ನಿಮಿಷಗಳಲ್ಲಿ 18 ಪ್ರಶ್ನೆಗಳು ಇರುತ್ತವೆ: SQL ಪರಿಕಲ್ಪನೆಗಳು (5), query ಏನನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ (6), query ಸರಿಪಡಿಸುವುದು (4) ಮತ್ತು ಸರಿಯಾದ query ಆಯ್ಕೆ ಮಾಡುವುದು (3). ನೀವು ಹಿಂದಿನ ಪ್ರಶ್ನೆಗಳಿಗೆ ಹಿಂತಿರುಗಿ ಅವುಗಳನ್ನು ಗುರುತಿಸಬಹುದು. ನಾವು ವಿವಿಧ ಡೇಟಾಬೇಸ್‌ಗಳಲ್ಲಿ ಬಳಸಬಹುದಾದ ಪ್ರಮಾಣಿತ SQL ಬಳಸುತ್ತೇವೆ. ಆದ್ದರಿಂದ PostgreSQL, MySQL, SQL Server, SQLite ಮತ್ತು ಇತರ ಬಹುತೇಕ ಡೇಟಾಬೇಸ್‌ಗಳಲ್ಲಿ queries ಒಂದೇ ಅರ್ಥ ನೀಡುತ್ತವೆ. ನಮ್ಮ ಅಭ್ಯಾಸ ಪರೀಕ್ಷೆಗಳು queries ಓದುವುದು, ಅವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಹಂತ ಹಂತವಾಗಿ ತಿಳಿಯುವುದು ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಆಯ್ಕೆ ಮಾಡುವುದನ್ನು ಅಭ್ಯಾಸ ಮಾಡಿಸುತ್ತವೆ; ನೀವು ಬರೆಯುವ queries‌ಗಳನ್ನು ಅವು ರನ್ ಮಾಡುವುದಿಲ್ಲ. ಅನೇಕ ನೈಜ SQL ಪರೀಕ್ಷೆಗಳಲ್ಲಿ, ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ ಹೋಲಿಸಿ ಪರಿಶೀಲಿಸುವ query ಬರೆಯಬೇಕಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ, ಅದಕ್ಕೆ ಬೇಕಾದ ಓದುವ ಮತ್ತು ಹಂತ ಹಂತವಾಗಿ ವಿಶ್ಲೇಷಿಸುವ ಕೌಶಲ್ಯ ಬೆಳೆಸಲು ನಮ್ಮ ಅಭ್ಯಾಸ ಪರೀಕ್ಷೆಗಳನ್ನು ಬಳಸಿ. ಜೊತೆಗೆ SQLite ನಂತಹ ಉಚಿತ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ನೀವೇ queries ಬರೆಯುವುದನ್ನೂ ಅಭ್ಯಾಸ ಮಾಡಿ.

ಪರಿಹಾರ ಸಹಿತ ಉದಾಹರಣೆಗಳಿರುವ ಪ್ರಶ್ನೆಗಳ ವಿಧಗಳು

ಪ್ರತಿ ವಿಭಾಗಕ್ಕೂ ಒಂದು ಬಿಡಿಸಿ ತೋರಿಸಿದ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ. ಹೆಚ್ಚಿನವರು ಮಾಡುವ ತಪ್ಪನ್ನೂ ಗಮನಿಸಿ.

1. SQL ಪರಿಕಲ್ಪನೆಗಳು. COUNT() ಮತ್ತು COUNT(email) ನಡುವಿನ ವ್ಯತ್ಯಾಸವೇನು? COUNT() ಪ್ರತಿಯೊಂದು ಸಾಲನ್ನೂ ಎಣಿಸುತ್ತದೆ; COUNT(email) ನಲ್ಲಿ email NULL ಆಗಿರದ ಸಾಲುಗಳನ್ನು ಮಾತ್ರ ಎಣಿಸಲಾಗುತ್ತದೆ. ಸಾಮಾನ್ಯ ತಪ್ಪು: ಪ್ರತಿಯೊಂದು count ನಲ್ಲೂ ಎಲ್ಲಾ ಸಾಲುಗಳು ಸೇರುತ್ತವೆ ಎಂದು ಭಾವಿಸುವುದು. ಹೆಚ್ಚಿನ aggregate functions NULL ಮೌಲ್ಯಗಳನ್ನು ಕಡೆಗಣಿಸುತ್ತವೆ.

2. query ಏನನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. scores ಎಂಬ table ನಲ್ಲಿ 8, 5, NULL ಮತ್ತು 8 ಮೌಲ್ಯಗಳಿವೆ. SELECT COUNT(DISTINCT score) ಏನನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ? ಪುನರಾವರ್ತನೆಯಿಲ್ಲದ, NULL ಅಲ್ಲದ ಮೌಲ್ಯಗಳು 8 ಮತ್ತು 5. ಆದ್ದರಿಂದ ಉತ್ತರ 2. ಸಾಮಾನ್ಯ ತಪ್ಪು: NULL ಅನ್ನು ಮೌಲ್ಯವೆಂದು ಎಣಿಸುವುದು ಅಥವಾ ಎರಡು ಬಾರಿ ಬಂದ 8 ಅನ್ನು ಎರಡು ಬಾರಿ ಎಣಿಸುವುದು. table ಅನ್ನು ಬರೆದು, query ಮಾಡುವಂತೆ ಸಾಲುಗಳನ್ನು ಒಂದೊಂದಾಗಿ ತೆಗೆದುಹಾಕಿ.

3. query ಸರಿಪಡಿಸುವುದು. ಒಂದು query ಯಲ್ಲಿ WHERE city = 'Austin' OR city = 'Dallas' AND active = 1 ಇದೆ. ಇದು active ಅಲ್ಲದ Austin ಗ್ರಾಹಕರನ್ನೂ ಹಿಂತಿರುಗಿಸುತ್ತದೆ. OR ಗಿಂತ ಮೊದಲು AND ಮೌಲ್ಯಮಾಪನವಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ ಈ condition ನ ನಿಜವಾದ ಅರ್ಥ Austin ಗ್ರಾಹಕರು ಅಥವಾ active Dallas ಗ್ರಾಹಕರು. ಇದನ್ನು brackets ಬಳಸಿ ಸರಿಪಡಿಸಿ: WHERE (city = 'Austin' OR city = 'Dallas') AND active = 1. ಸಾಮಾನ್ಯ ತಪ್ಪು: condition ಅನ್ನು ಎಡದಿಂದ ಬಲಕ್ಕೆ ಓದುವುದು.

4. ಸರಿಯಾದ query ಆಯ್ಕೆಮಾಡುವುದು. ಇತ್ತೀಚಿನ ಐದು orders ಬೇಕಿವೆ. ಇವುಗಳಲ್ಲಿ ಯಾವುದು ಸರಿ: ORDER BY order_date DESC ಜೊತೆಗೆ limit 5, ಅಥವಾ ORDER BY order_date ಜೊತೆಗೆ limit 5? ಮೊದಲನೆಯದು. DESC ಇಲ್ಲದಿದ್ದರೆ ಹಳೆಯವು ಮೊದಲು ಬರುತ್ತವೆ. ಹೀಗಾಗಿ ಐದು ಹಳೆಯ orders ಸಿಗುತ್ತವೆ. ಸಾಮಾನ್ಯ ತಪ್ಪು: sort ದಿಕ್ಕನ್ನು ಪರಿಶೀಲಿಸದೆ ಸರಿಯೆಂದು ಕಾಣುವ query ಆರಿಸುವುದು. (LIMIT 5 ಅಥವಾ FETCH FIRST 5 ROWS ONLY ನಂತಹ ವಿಭಿನ್ನ ರೂಪಗಳಲ್ಲಿ databases limit ಅನ್ನು ಬರೆಯುತ್ತವೆ. ಆದ್ದರಿಂದ ನಿಮ್ಮ test ಯಾವ ರೂಪ ಬಳಸುತ್ತದೆ ಎಂದು ಪರಿಶೀಲಿಸಿ.)

5. conditions ಇರುವ joins. left join ನಂತರ ಬಲಭಾಗದ table ನ column ಮೇಲೆ WHERE ಪರೀಕ್ಷೆ ಮಾಡಿದರೆ, ಅದು ಗಮನಕ್ಕೆ ಬಾರದೆ inner join ಆಗುತ್ತದೆ. ಹೊಂದಿಕೆಯಾಗದ ಸಾಲುಗಳಲ್ಲಿ ಆ column NULL ಆಗಿರುತ್ತದೆ ಮತ್ತು ಪರೀಕ್ಷೆಯು ಆ ಸಾಲುಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ. ಸಾಮಾನ್ಯ ತಪ್ಪು: ಯಾವ ಸಾಲುಗಳು ಕಣ್ಮರೆಯಾಗುತ್ತವೆ ಎಂಬುದನ್ನು ಗಮನಿಸದಿರುವುದು. "ಹೊಂದಾಣಿಕೆ ಇಲ್ಲದ ಸಾಲಿಗೆ ಏನಾಗುತ್ತದೆ?" ಎಂದು ಕೇಳಿ.

ತಯಾರಿ ಮಾಡುವುದು ಹೇಗೆ

1. ಮೊದಲು ನಿಮ್ಮ ಆಹ್ವಾನವನ್ನು ಓದಿ. ನೀವು ಯಾವ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಬಳಸುತ್ತೀರಿ, ನಿಮಗೆ ಎಷ್ಟು ಸಮಯವಿದೆ, ನೀವು queries ಬರೆಯಬೇಕೇ ಅಥವಾ multiple choice ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಬೇಕೇ, ಮತ್ತು ಅದು ಯಾವ database ಬಳಸುತ್ತದೆ ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳಿ. ಪರೀಕ್ಷೆಯ ಸ್ವರೂಪಗಳು ತುಂಬಾ ವಿಭಿನ್ನವಾಗಿರುವುದರಿಂದ ಊಹಿಸಬೇಡಿ.
2. Query ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಕ್ರಮ ತಿಳಿದುಕೊಳ್ಳಿ. ಮೊದಲು FROM ಮತ್ತು JOIN, ನಂತರ WHERE, GROUP BY, HAVING, SELECT ಮತ್ತು ORDER BY. ಯಾವ ಹಂತದಲ್ಲಿ ಯಾವ data ಲಭ್ಯವಾಗುತ್ತದೆ ಎಂಬುದು ತಿಳಿದಾಗ, "ಇದು ಏಕೆ ತಪ್ಪಾಗಿದೆ?" ಎಂಬ ಹೆಚ್ಚಿನ ಪ್ರಶ್ನೆಗಳು ಅರ್ಥವಾಗುತ್ತವೆ.
3. ಸಣ್ಣ tables ಅನ್ನು ಕೈಯಿಂದ ಪರಿಶೀಲಿಸಿ. ಮೂರು ಅಥವಾ ನಾಲ್ಕು rows ಬರೆದು, ಪ್ರತಿ clause ಅನ್ನು ಕ್ರಮವಾಗಿ ಅನ್ವಯಿಸಿ. ನಿಮ್ಮ ಉತ್ತರವನ್ನು ಪರಿಶೀಲಿಸಲು ಇದು ಅತ್ಯಂತ ವೇಗದ ಮಾರ್ಗ. NULL ಮತ್ತು duplicate ಸಂಬಂಧಿತ ಸೂಕ್ಷ್ಮ ತಪ್ಪುಗಳನ್ನೂ ಇದು ಪತ್ತೆಹಚ್ಚುತ್ತದೆ.
4. NULL ಅನ್ನು ಪ್ರತ್ಯೇಕ ವಿಷಯವಾಗಿ ತಿಳಿಯಿರಿ. IS NULL, COUNT(column) ಮತ್ತು COUNT(*) ನಡುವಿನ ವ್ಯತ್ಯಾಸ, AVG ನಲ್ಲಿ NULL ಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುವುದು, ಪಟ್ಟಿಯಲ್ಲಿ NULL ಇದ್ದಾಗ NOT IN ಹೇಗೆ ವರ್ತಿಸುತ್ತದೆ, ಮತ್ತು ಹೊಂದಿಕೆಯಾಗದ columns ನಲ್ಲಿ left join ಏನು ತೋರಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅಭ್ಯಾಸ ಮಾಡಿ.
5. ನೈಜ queries ಕೂಡ ಬರೆಯಿರಿ. ನಮ್ಮ mock tests ಓದುವ ಮತ್ತು ಕ್ರಮವಾಗಿ ಪರಿಶೀಲಿಸುವ ಕೌಶಲ್ಯ ಬೆಳೆಸುತ್ತವೆ. ಸಮಯದ ಒತ್ತಡದಲ್ಲಿ query ಟೈಪ್ ಮಾಡುವುದು ಸಹಜವೆನಿಸುವಂತೆ SQLite ನಂತಹ ಉಚಿತ database ನಲ್ಲಿ queries ಬರೆಯುವುದನ್ನೂ ಅಭ್ಯಾಸ ಮಾಡಿ. ಕೆಲವು tests ನಿಮ್ಮ query ಅನ್ನು ಅನೇಕ cases ನಲ್ಲಿ ಪರಿಶೀಲಿಸುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ತನ್ನ SQLite test ಗಾಗಿ 10 ಕ್ಕೂ ಹೆಚ್ಚು test cases ಇರುವುದಾಗಿ TestGorilla ತಿಳಿಸುತ್ತದೆ (TestGorilla).
6. Syntax ಮಾತ್ರವಲ್ಲ, ಫಲಿತಾಂಶವನ್ನೂ ಪರಿಶೀಲಿಸಿ. ಕಾರ್ಯಗತವಾಗುವ query ಕೂಡ ತಪ್ಪಾದ rows ನೀಡಬಹುದು. Submit ಮಾಡುವ ಮೊದಲು, ಹೊಂದಾಣಿಕೆಗಳು ಸಿಗದಿದ್ದರೆ, duplicates ಇದ್ದರೆ ಮತ್ತು NULL ಗಳು ಇದ್ದರೆ ಏನಾಗುತ್ತದೆ ಎಂದು ಯೋಚಿಸಿ.
7. ನೈಜ ವೇಗದಲ್ಲಿ ಅಭ್ಯಾಸ ಮಾಡಿ. TestGorilla ಯ MySQL test ನಂತೆ ಒಂದು ಚಿಕ್ಕ ಜ್ಞಾನ ಪರೀಕ್ಷೆಯಲ್ಲಿ 10 ನಿಮಿಷಗಳಲ್ಲಿ 15 ಪ್ರಶ್ನೆಗಳಿದ್ದರೆ, ಪ್ರತಿ ಪ್ರಶ್ನೆಗೆ ಒಂದು ನಿಮಿಷಕ್ಕಿಂತಲೂ ಕಡಿಮೆ ಸಮಯ ಸಿಗುತ್ತದೆ (TestGorilla). ಪರೀಕ್ಷೆಯ ದಿನ ವೇಗ ಸಹಜವೆನಿಸುವಂತೆ ಪೂರ್ಣ timed mock tests ತೆಗೆದುಕೊಳ್ಳಿ.

ಸಾಮಾನ್ಯವಾಗಿ ಅಂಕಗಳನ್ನು ಹೇಗೆ ನೀಡಲಾಗುತ್ತದೆ

ಅಂಕ ನೀಡುವುದು ಉದ್ಯೋಗದಾತ ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ. SQLಗೆ ಯಾವುದೇ ಪ್ರಮಾಣಿತ ಅಂಕವಿಲ್ಲ ಮತ್ತು ಎಲ್ಲರಿಗೂ ಅನ್ವಯಿಸುವ ಉತ್ತೀರ್ಣತಾ ಮಿತಿಯೂ ಇಲ್ಲ. ಉತ್ತಮ ಫಲಿತಾಂಶ ಯಾವುದು ಎಂಬುದನ್ನು ಪ್ರತಿಯೊಬ್ಬ ಉದ್ಯೋಗದಾತರೂ ನಿರ್ಧರಿಸುತ್ತಾರೆ. Query ಪ್ರಶ್ನೆಗಳನ್ನು ಹೇಗೆ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ ಎಂಬುದಕ್ಕೆ ಸಾರ್ವಜನಿಕವಾಗಿ ಲಭ್ಯವಿರುವ ಎರಡು ಉದಾಹರಣೆಗಳು:

• HackerRank ಡೇಟಾಬೇಸ್ ಪ್ರಶ್ನೆಗಳು: ನಿಮ್ಮ queryಯ ಫಲಿತಾಂಶವನ್ನು ನಿರೀಕ್ಷಿತ outputನೊಂದಿಗೆ ಹೋಲಿಸಿ ಇವುಗಳಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಂಕ ನೀಡಲಾಗುತ್ತದೆ ಎಂದು HackerRank ಹೇಳುತ್ತದೆ. ಫಲಿತಾಂಶ ಹೊಂದಿಕೆಯಾದರೆ ಪೂರ್ಣ ಅಂಕ ಸಿಗುತ್ತದೆ; ಬೇರೆ ಯಾವುದೇ ಫಲಿತಾಂಶಕ್ಕೆ ಶೂನ್ಯ ಅಂಕ ಸಿಗುತ್ತದೆ. ಆದರೆ ಉದ್ಯೋಗದಾತರು ಕೈಯಾರೆ ಪರಿಶೀಲಿಸಿ ಭಾಗಶಃ ಅಂಕ ನೀಡಬಹುದು. ಸಾಲುಗಳ ಕ್ರಮವನ್ನು ಪರಿಗಣಿಸದಿರಲು ಉದ್ಯೋಗದಾತರು ಆಯ್ಕೆ ಮಾಡಬಹುದು (HackerRank support).
• TestGorillaಯ SQLite ಪರೀಕ್ಷೆ: ಪರಿಹಾರದ ಅಂಚಿನ ಸಂದರ್ಭಗಳನ್ನು ಪರಿಶೀಲಿಸುವ 10ಕ್ಕಿಂತ ಹೆಚ್ಚು test cases ಬಳಸಿ ಅಭ್ಯರ್ಥಿಗಳಿಗೆ ಶ್ರೇಯಾಂಕ ನೀಡಲಾಗುತ್ತದೆ ಎಂದು TestGorilla ಹೇಳುತ್ತದೆ (TestGorilla).

ಫಲಿತಾಂಶಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸಾಲು ಸಾಲಾಗಿ ಪರಿಶೀಲಿಸುವುದರಿಂದ, ಬಹುತೇಕ ಸರಿಯಾಗಿರುವ query ಕೂಡ, ಉದಾಹರಣೆಗೆ ಯಾವುದೇ order ಇಲ್ಲದ ಗ್ರಾಹಕರನ್ನು ಬಿಟ್ಟುಬಿಡುವ query, ಉತ್ತರವೇ ನೀಡದಿದ್ದಂತೆ ಅಂಕ ಪಡೆಯಬಹುದು.

ನಮ್ಮ ಅಭ್ಯಾಸದ ಅಂಕ ಎಂದರೆ ನಮ್ಮದೇ ಪ್ರಶ್ನೆಗಳಲ್ಲಿ ನೀವು ಸರಿಯಾಗಿ ಉತ್ತರಿಸಿದ ಪ್ರಶ್ನೆಗಳ ಸಂಖ್ಯೆ. ವಿಭಾಗವಾರು ವಿವರದಿಂದ ಎಲ್ಲಿ ಗಮನಹರಿಸಬೇಕು ಎಂಬುದನ್ನು ತಿಳಿಯಬಹುದು. ಇದು ಅಭ್ಯಾಸದ ಅಂಕ ಮಾತ್ರ. ಯಾವುದೇ ಉದ್ಯೋಗದಾತರ ಅಥವಾ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನ ಪರೀಕ್ಷೆಯ ಅಂಕವಲ್ಲ ಮತ್ತು ನೀವು ಉತ್ತೀರ್ಣರಾಗುತ್ತೀರಾ ಎಂದು ಮುನ್ಸೂಚಿಸುವುದಿಲ್ಲ.

ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು

• = ಬಳಸಿ NULL ಜೊತೆ ಹೋಲಿಸುವುದು. IS NULL ಮತ್ತು IS NOT NULL ಬಳಸಿ. = NULL ಎಂಬ ಯಾವುದೇ ಹೋಲಿಕೆಯ ಫಲಿತಾಂಶ ತಿಳಿಯದಂತಿರುತ್ತದೆ, ಆದ್ದರಿಂದ ಆ row ಫಿಲ್ಟರ್ ಆಗಿ ಹೊರಹೋಗುತ್ತದೆ.
• WHERE ನಲ್ಲಿ left join ಅನ್ನು ಫಿಲ್ಟರ್ ಮಾಡುವುದು. ಬಲಭಾಗದ table ನ ಕಾಲಮ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಿದರೆ ಹೊಂದಿಕೆಯಾಗದ rows ತೆಗೆದುಹಾಕಲ್ಪಡುತ್ತವೆ. ಅವುಗಳನ್ನು ಉಳಿಸಬೇಕಾದರೆ ಆ ಪರೀಕ್ಷೆಯನ್ನು ON clause ನಲ್ಲಿ ಇರಿಸಿ.
• ಒಟ್ಟು ಮೊತ್ತಕ್ಕೆ WHERE ಬಳಸುವುದು. Aggregate ಗಳು GROUP BY ನಂತರದ HAVING ನಲ್ಲಿ ಇರಬೇಕು.
• Group ಮಾಡದ ಕಾಲಮ್ ಆಯ್ಕೆ ಮಾಡುವುದು. Standard SQL ನಲ್ಲಿ ಆಯ್ಕೆ ಮಾಡಿದ ಪ್ರತಿಯೊಂದು ಕಾಲಮ್ ಅನ್ನು group ಮಾಡಿರಬೇಕು ಅಥವಾ aggregate ಮಾಡಿರಬೇಕು. ಕೆಲವು databases query ಚಲಾಯಿಸಿ ನಿಮಗಾಗಿ ಒಂದು ಮೌಲ್ಯ ಆಯ್ಕೆ ಮಾಡುತ್ತವೆ; ಇದರಿಂದ ತಪ್ಪು ಮರೆಮಾಚುತ್ತದೆ.
• ನಕಲಿ ಮೌಲ್ಯಗಳನ್ನು ಮರೆತರೆ. Join ಮಾಡಿದಾಗ rows ಪುನರಾವರ್ತನೆಯಾಗಬಹುದು; ಇದರಿಂದ SUM ಮತ್ತು COUNT ಹೆಚ್ಚಾಗುತ್ತದೆ. ಒಂದು ಬದಿಯ ಪ್ರತಿಯೊಂದು row ಮತ್ತೊಂದು ಬದಿಯ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು rows ಗೆ ಹೊಂದಿಕೆಯಾಗಬಹುದೇ ಎಂದು ಪರಿಶೀಲಿಸಿ.
• ಒಂದು database ನ ಶಾರ್ಟ್‌ಕಟ್‌ಗಳನ್ನೇ ಅವಲಂಬಿಸುವುದು. ಕೆಲವು functions ಮತ್ತು limit syntax databases ಗಳ ನಡುವೆ ಬದಲಾಗುತ್ತವೆ. Standard ರೂಪವನ್ನು ಕಲಿಯಿರಿ ಮತ್ತು ನಿಮ್ಮ test ಯಾವ database ಬಳಸುತ್ತದೆ ಎಂದು ಪರಿಶೀಲಿಸಿ.