SQL ਟੈਸਟ ਦੀ ਤਿਆਰੀ

ਅਸਲ ਟੈਸਟ ਆਮ ਤੌਰ 'ਤੇ ਕਿਹੋ ਜਿਹਾ ਹੁੰਦਾ ਹੈ

ਕੋਈ ਇੱਕੋ ਜਿਹਾ SQL ਟੈਸਟ ਨਹੀਂ ਹੁੰਦਾ। ਹਰ ਨਿਯੋਗਕਰਤਾ ਟੈਸਟਿੰਗ ਪਲੇਟਫਾਰਮ ਚੁਣਦਾ ਹੈ ਜਾਂ ਆਪਣਾ ਟੈਸਟ ਤਿਆਰ ਕਰਦਾ ਹੈ, ਅਤੇ ਫ਼ੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਕਿੰਨੇ ਸਵਾਲ ਹੋਣਗੇ, ਕਿੰਨਾ ਸਮਾਂ ਮਿਲੇਗਾ ਅਤੇ ਕਿਹੜਾ ਡੇਟਾਬੇਸ ਵਰਤਿਆ ਜਾਵੇਗਾ। ਨੌਕਰੀ ਦਾ ਇਸ਼ਤਿਹਾਰ ਜਾਂ ਟੈਸਟ ਦਾ ਸੱਦਾ ਤੁਹਾਡੇ ਟੈਸਟ ਬਾਰੇ ਜਾਣਨ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਮਾਰਗਦਰਸ਼ਨ ਹੈ। ਜਨਤਕ ਤੌਰ 'ਤੇ ਉਪਲਬਧ ਉਦਾਹਰਨਾਂ ਵਿੱਚ ਕਾਫ਼ੀ ਫ਼ਰਕ ਮਿਲਦਾ ਹੈ:

• HackerRank ਦੇ SQL ਹੁਨਰ ਟੈਸਟ। HackerRank ਆਪਣੇ SQL (Basic) ਹੁਨਰ ਟੈਸਟ ਵਿੱਚ 30 ਮਿੰਟਾਂ ਵਿੱਚ 2 ਸਵਾਲ ਦੱਸਦਾ ਹੈ। ਇਸ ਵਿੱਚ ਸਧਾਰਨ ਕਵੇਰੀਆਂ ਵਰਗੇ ਵਿਸ਼ੇ ਸ਼ਾਮਲ ਹਨ (HackerRank), ਅਤੇ ਇਸਦੇ SQL (Intermediate) ਟੈਸਟ ਵਿੱਚ 35 ਮਿੰਟਾਂ ਵਿੱਚ 2 ਸਵਾਲ ਹਨ। ਇਸ ਵਿੱਚ ਜਟਿਲ ਜੋਇਨ ਵਰਗੇ ਵਿਸ਼ੇ ਸ਼ਾਮਲ ਹਨ (HackerRank)। ਜਿਹੜੇ ਨਿਯੋਗਕਰਤਾ HackerRank 'ਤੇ ਆਪਣੇ ਟੈਸਟ ਬਣਾਉਂਦੇ ਹਨ, ਉਹ ਡੇਟਾਬੇਸ ਬਾਰੇ ਸਵਾਲ ਜੋੜ ਸਕਦੇ ਹਨ ਅਤੇ ਇਹ ਚੁਣ ਸਕਦੇ ਹਨ ਕਿ ਉਮੀਦਵਾਰ ਕਿਹੜੇ ਡੇਟਾਬੇਸ ਵਰਤ ਸਕਦੇ ਹਨ (HackerRank support)।
• ਕਵੇਰੀ ਲਿਖਣ ਦਾ ਕੰਮ। TestGorilla ਆਪਣੇ SQLite ਕੋਡਿੰਗ ਟੈਸਟ ਨੂੰ 30 ਮਿੰਟਾਂ ਦਾ ਕੰਮ ਦੱਸਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਦਰਮਿਆਨੀ ਜਟਿਲਤਾ ਵਾਲੇ ਡੇਟਾਬੇਸ ਦੇ ਆਧਾਰ 'ਤੇ ਇੱਕ ਵਾਸਤਵਿਕ ਸਥਿਤੀ ਲਈ ਕਵੇਰੀ ਲਿਖਣੀ ਹੁੰਦੀ ਹੈ। ਇਸ ਵਿੱਚ ਜੋਇਨ ਕਰਨਾ ਅਤੇ ਫਿਲਟਰ ਲਗਾਉਣਾ, ਸਧਾਰਨ ਗਣਨਾਵਾਂ, ਛਾਂਟਣਾ, ਰਾਊਂਡ ਕਰਨਾ ਅਤੇ ਗੈਰ-ਸੰਬੰਧਿਤ ਐਂਟਰੀਆਂ ਨੂੰ ਹਟਾਉਣਾ ਸ਼ਾਮਲ ਹੈ (TestGorilla)।
• ਥੋੜ੍ਹੇ ਸਮੇਂ ਦਾ ਗਿਆਨ ਟੈਸਟ। TestGorilla ਆਪਣੇ MySQL ਟੈਸਟ ਵਿੱਚ 101 ਸਵਾਲਾਂ ਦੇ ਭੰਡਾਰ ਵਿੱਚੋਂ ਚੁਣੇ ਗਏ 10 ਮਿੰਟਾਂ ਵਿੱਚ 15 ਸਵਾਲ ਦੱਸਦਾ ਹੈ (TestGorilla)।

SQL ਟੈਸਟਾਂ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਦੱਸੇ ਜਾਣ ਵਾਲੇ ਵਿਸ਼ੇ:

• ਫਿਲਟਰ ਲਗਾਉਣਾ ਅਤੇ ਛਾਂਟਣਾ: SELECT, WHERE, ORDER BY ਅਤੇ AND, OR, IN ਤੇ BETWEEN ਵਾਲੀਆਂ ਸ਼ਰਤਾਂ।
• ਜੋਇਨ: ਇਨਰ ਅਤੇ ਲੈਫਟ ਜੋਇਨ, ਅਤੇ ਬਿਨਾਂ ਮੇਲ ਵਾਲੀਆਂ ਕਤਾਰਾਂ ਨਾਲ ਕੀ ਹੁੰਦਾ ਹੈ।
• ਗਰੁੱਪ ਬਣਾਉਣਾ: COUNT, SUM, AVG, MIN ਅਤੇ MAX ਨਾਲ GROUP BY, ਅਤੇ ਗਰੁੱਪਾਂ ਨੂੰ ਫਿਲਟਰ ਕਰਨ ਲਈ HAVING।
• NULL ਮੁੱਲ: ਤੁਲਨਾਵਾਂ, ਗਿਣਤੀਆਂ ਅਤੇ ਔਸਤ ਵਿੱਚ ਗੁੰਮ ਮੁੱਲਾਂ ਦਾ ਵਿਹਾਰ।
• ਸਬਕਵੇਰੀਆਂ: ਇੱਕ ਕਵੇਰੀ ਦੇ ਅੰਦਰ ਦੂਜੀ ਕਵੇਰੀ, ਜਿਸ ਵਿੱਚ IN, EXISTS ਜਾਂ ਇੱਕੋ ਮੁੱਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
• ਸਧਾਰਨ ਬੇਨਤੀ ਤੋਂ ਕਵੇਰੀ ਲਿਖਣਾ, ਜਿਸਦਾ ਮੁਲਾਂਕਣ ਅਕਸਰ ਇਸ ਆਧਾਰ 'ਤੇ ਹੁੰਦਾ ਹੈ ਕਿ ਕੀ ਇਹ ਬਿਲਕੁਲ ਉਮੀਦ ਕੀਤੀਆਂ ਕਤਾਰਾਂ ਵਾਪਸ ਕਰਦੀ ਹੈ।

ਸਾਡੇ ਮੌਕ ਟੈਸਟਾਂ ਵਿੱਚ ਕੀ ਸ਼ਾਮਲ ਹੈ। ਹਰ ਪੂਰੇ ਮੌਕ ਟੈਸਟ ਵਿੱਚ ਚਾਰ ਭਾਗਾਂ ਵਿੱਚ 45 ਮਿੰਟਾਂ ਵਿੱਚ 18 ਸਵਾਲ ਹੁੰਦੇ ਹਨ: SQL ਸੰਕਲਪ (5), ਕਵੇਰੀ ਕੀ ਨਤੀਜਾ ਦਿੰਦੀ ਹੈ (6), ਕਵੇਰੀ ਠੀਕ ਕਰਨਾ (4) ਅਤੇ ਸਹੀ ਕਵੇਰੀ ਚੁਣਨਾ (3)। ਤੁਸੀਂ ਪਿੱਛੇ ਜਾ ਸਕਦੇ ਹੋ ਅਤੇ ਸਵਾਲਾਂ 'ਤੇ ਨਿਸ਼ਾਨ ਲਗਾ ਸਕਦੇ ਹੋ। ਅਸੀਂ ਵੱਖ-ਵੱਖ ਡੇਟਾਬੇਸਾਂ ਵਿੱਚ ਵਰਤੀ ਜਾ ਸਕਣ ਵਾਲੀ ਮਿਆਰੀ SQL ਵਰਤਦੇ ਹਾਂ, ਇਸ ਲਈ ਕਵੇਰੀਆਂ ਦਾ ਅਰਥ PostgreSQL, MySQL, SQL Server, SQLite ਅਤੇ ਜ਼ਿਆਦਾਤਰ ਹੋਰ ਡੇਟਾਬੇਸਾਂ ਵਿੱਚ ਇੱਕੋ ਜਿਹਾ ਹੁੰਦਾ ਹੈ। ਸਾਡੇ ਮੌਕ ਟੈਸਟ ਕਵੇਰੀਆਂ ਨੂੰ ਪੜ੍ਹਨ, ਉਨ੍ਹਾਂ ਦੇ ਕਦਮਾਂ ਨੂੰ ਸਮਝਣ ਅਤੇ ਕਵੇਰੀਆਂ ਚੁਣਨ ਦੀ ਪ੍ਰੈਕਟਿਸ ਕਰਵਾਉਂਦੇ ਹਨ; ਇਹ ਤੁਹਾਡੇ ਵੱਲੋਂ ਲਿਖੀਆਂ ਕਵੇਰੀਆਂ ਨੂੰ ਚਲਾਉਂਦੇ ਨਹੀਂ ਹਨ। ਕਈ ਅਸਲ SQL ਟੈਸਟਾਂ ਵਿੱਚ ਤੁਹਾਨੂੰ ਅਜਿਹੀ ਕਵੇਰੀ ਲਿਖਣੀ ਪੈਂਦੀ ਹੈ ਜਿਸਦੀ ਜਾਂਚ ਉਮੀਦ ਕੀਤੇ ਨਤੀਜਿਆਂ ਨਾਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਲਈ ਸਾਡੇ ਮੌਕ ਟੈਸਟਾਂ ਰਾਹੀਂ ਪੜ੍ਹਨ ਅਤੇ ਕਵੇਰੀ ਦੇ ਕਦਮ ਸਮਝਣ ਦਾ ਹੁਨਰ ਵਿਕਸਿਤ ਕਰੋ, ਅਤੇ SQLite ਵਰਗੇ ਮੁਫ਼ਤ ਡੇਟਾਬੇਸ ਵਿੱਚ ਖ਼ੁਦ ਵੀ ਕਵੇਰੀਆਂ ਲਿਖੋ।

ਹੱਲ ਸਮੇਤ ਉਦਾਹਰਨਾਂ ਵਾਲੇ ਸਵਾਲਾਂ ਦੀਆਂ ਕਿਸਮਾਂ

ਹਰ ਭਾਗ ਲਈ ਇੱਕ ਹੱਲ ਸਮੇਤ ਉਦਾਹਰਨ, ਨਾਲ ਹੀ ਉਹ ਆਮ ਗਲਤੀ ਜਿਸ ਵਿੱਚ ਜ਼ਿਆਦਾਤਰ ਲੋਕ ਫਸ ਜਾਂਦੇ ਹਨ।

1. SQL ਦੇ ਸੰਕਲਪ। COUNT() ਅਤੇ COUNT(email) ਵਿੱਚ ਕੀ ਫ਼ਰਕ ਹੈ? COUNT() ਹਰ ਕਤਾਰ ਗਿਣਦਾ ਹੈ; COUNT(email) ਸਿਰਫ਼ ਉਹ ਕਤਾਰਾਂ ਗਿਣਦਾ ਹੈ ਜਿੱਥੇ email, NULL ਨਹੀਂ ਹੈ। ਆਮ ਗਲਤੀ: ਇਹ ਮੰਨ ਲੈਣਾ ਕਿ ਹਰ ਗਿਣਤੀ ਵਿੱਚ ਸਾਰੀਆਂ ਕਤਾਰਾਂ ਸ਼ਾਮਲ ਹੁੰਦੀਆਂ ਹਨ। ਜ਼ਿਆਦਾਤਰ aggregate ਫੰਕਸ਼ਨ NULL ਮੁੱਲਾਂ ਨੂੰ ਛੱਡ ਦਿੰਦੇ ਹਨ।

2. ਕਵੇਰੀ ਕੀ ਨਤੀਜਾ ਦਿੰਦੀ ਹੈ। scores ਟੇਬਲ ਵਿੱਚ 8, 5, NULL ਅਤੇ 8 ਮੁੱਲ ਹਨ। SELECT COUNT(DISTINCT score) ਦਾ ਨਤੀਜਾ ਕੀ ਹੋਵੇਗਾ? ਵੱਖਰੇ, ਗੈਰ-NULL ਮੁੱਲ 8 ਅਤੇ 5 ਹਨ, ਇਸ ਲਈ ਜਵਾਬ 2 ਹੈ। ਆਮ ਗਲਤੀ: NULL ਨੂੰ ਇੱਕ ਮੁੱਲ ਵਜੋਂ ਗਿਣਨਾ ਜਾਂ ਦੁਹਰਾਏ ਹੋਏ 8 ਨੂੰ ਦੋ ਵਾਰ ਗਿਣਨਾ। ਟੇਬਲ ਲਿਖੋ ਅਤੇ ਕਵੇਰੀ ਵਾਂਗ ਕਤਾਰਾਂ ਨੂੰ ਇੱਕ-ਇੱਕ ਕਰਕੇ ਕੱਟੋ।

3. ਕਵੇਰੀ ਠੀਕ ਕਰਨਾ। ਇੱਕ ਕਵੇਰੀ ਵਿੱਚ WHERE city = 'Austin' OR city = 'Dallas' AND active = 1 ਹੈ ਅਤੇ ਇਹ inactive Austin ਗਾਹਕ ਵੀ ਦਿੰਦੀ ਹੈ। AND ਦਾ ਮੁਲਾਂਕਣ OR ਤੋਂ ਪਹਿਲਾਂ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਸ਼ਰਤ ਦਾ ਅਸਲ ਮਤਲਬ ਹੈ Austin ਜਾਂ active Dallas। ਇਸ ਦਾ ਹੱਲ ਬ੍ਰੈਕਟਾਂ ਹਨ: WHERE (city = 'Austin' OR city = 'Dallas') AND active = 1। ਆਮ ਗਲਤੀ: ਸ਼ਰਤ ਨੂੰ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਪੜ੍ਹਨਾ।

4. ਸਹੀ ਕਵੇਰੀ ਚੁਣਨਾ। ਤੁਹਾਨੂੰ ਸਭ ਤੋਂ ਨਵੇਂ ਪੰਜ ਆਰਡਰ ਚਾਹੀਦੇ ਹਨ। ਕਿਹੜਾ ਸਹੀ ਹੈ: 5 ਦੀ ਸੀਮਾ ਨਾਲ ORDER BY order_date DESC, ਜਾਂ 5 ਦੀ ਸੀਮਾ ਨਾਲ ORDER BY order_date? ਪਹਿਲਾ। DESC ਤੋਂ ਬਿਨਾਂ ਕ੍ਰਮ ਸਭ ਤੋਂ ਪੁਰਾਣੇ ਪਹਿਲਾਂ ਹੋਵੇਗਾ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਸਭ ਤੋਂ ਪੁਰਾਣੇ ਪੰਜ ਆਰਡਰ ਮਿਲਣਗੇ। ਆਮ ਗਲਤੀ: ਕ੍ਰਮ ਦੀ ਦਿਸ਼ਾ ਜਾਂਚੇ ਬਿਨਾਂ ਉਹ ਕਵੇਰੀ ਚੁਣਨਾ ਜੋ ਸਹੀ ਲੱਗਦੀ ਹੈ। (ਡਾਟਾਬੇਸ ਸੀਮਾ ਲਿਖਣ ਦੇ ਵੱਖਰੇ ਤਰੀਕੇ ਵਰਤਦੇ ਹਨ, ਜਿਵੇਂ LIMIT 5 ਜਾਂ FETCH FIRST 5 ROWS ONLY, ਇਸ ਲਈ ਜਾਂਚੋ ਕਿ ਤੁਹਾਡਾ ਟੈਸਟ ਕਿਹੜਾ ਤਰੀਕਾ ਵਰਤਦਾ ਹੈ।)

5. ਸ਼ਰਤਾਂ ਵਾਲੇ joins। ਖੱਬੇ ਪਾਸੇ ਵਾਲੇ ਟੇਬਲ ਦੇ join ਤੋਂ ਬਾਅਦ ਸੱਜੇ ਟੇਬਲ ਦੇ ਕਾਲਮ 'ਤੇ WHERE ਜਾਂਚ ਲਗਾਉਣ ਨਾਲ ਇਹ ਚੁੱਪਚਾਪ inner join ਬਣ ਜਾਂਦਾ ਹੈ, ਕਿਉਂਕਿ ਬਿਨਾਂ ਮੇਲ ਵਾਲੀਆਂ ਕਤਾਰਾਂ ਵਿੱਚ ਉੱਥੇ NULL ਹੁੰਦਾ ਹੈ ਅਤੇ ਜਾਂਚ ਉਹਨਾਂ ਨੂੰ ਹਟਾ ਦਿੰਦੀ ਹੈ। ਆਮ ਗਲਤੀ: ਇਹ ਨਾ ਵੇਖਣਾ ਕਿ ਕਿਹੜੀਆਂ ਕਤਾਰਾਂ ਗਾਇਬ ਹੋ ਜਾਂਦੀਆਂ ਹਨ। ਪੁੱਛੋ, "ਜਿਸ ਕਤਾਰ ਦਾ ਕੋਈ ਮੇਲ ਨਹੀਂ, ਉਸ ਨਾਲ ਕੀ ਹੁੰਦਾ ਹੈ?"

ਤਿਆਰੀ ਕਿਵੇਂ ਕਰੀਏ

1. ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਆਪਣਾ ਸੱਦਾ ਪੜ੍ਹੋ। ਪਤਾ ਕਰੋ ਕਿ ਤੁਸੀਂ ਕਿਹੜਾ ਪਲੇਟਫਾਰਮ ਵਰਤੋਗੇ, ਤੁਹਾਡੇ ਕੋਲ ਕਿੰਨਾ ਸਮਾਂ ਹੋਵੇਗਾ, ਤੁਹਾਨੂੰ queries ਲਿਖਣੀਆਂ ਹੋਣਗੀਆਂ ਜਾਂ ਬਹੁ-ਵਿਕਲਪੀ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਦੇਣੇ ਹੋਣਗੇ, ਅਤੇ ਇਹ ਕਿਹੜੇ ਡੇਟਾਬੇਸ 'ਤੇ ਚੱਲਦਾ ਹੈ। ਫਾਰਮੈਟਾਂ ਵਿੱਚ ਇੰਨਾ ਫ਼ਰਕ ਹੁੰਦਾ ਹੈ ਕਿ ਪਹਿਲਾਂ ਤੋਂ ਅੰਦਾਜ਼ਾ ਨਹੀਂ ਲਗਾਇਆ ਜਾ ਸਕਦਾ।
2. ਸਮਝੋ ਕਿ query ਕਿਹੜੇ ਕ੍ਰਮ ਵਿੱਚ ਚੱਲਦੀ ਹੈ। ਪਹਿਲਾਂ FROM ਅਤੇ JOIN, ਫਿਰ WHERE, GROUP BY, HAVING, SELECT ਅਤੇ ORDER BY। ਜ਼ਿਆਦਾਤਰ "ਇਹ ਗਲਤ ਕਿਉਂ ਹੈ?" ਵਾਲੇ ਸਵਾਲ ਉਦੋਂ ਸਮਝ ਆ ਜਾਂਦੇ ਹਨ ਜਦੋਂ ਤੁਹਾਨੂੰ ਪਤਾ ਹੋਵੇ ਕਿ ਹਰ ਪੜਾਅ ਵਿੱਚ ਕਿਹੜਾ ਡੇਟਾ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
3. ਛੋਟੀਆਂ ਟੇਬਲਾਂ ਨੂੰ ਹੱਥ ਨਾਲ ਵੇਖੋ। ਤਿੰਨ ਜਾਂ ਚਾਰ ਕਤਾਰਾਂ ਲਿਖੋ, ਫਿਰ ਹਰ clause ਨੂੰ ਕ੍ਰਮਵਾਰ ਲਾਗੂ ਕਰੋ। ਇਹ ਆਪਣੇ ਜਵਾਬ ਦੀ ਜਾਂਚ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਤੇਜ਼ ਤਰੀਕਾ ਹੈ ਅਤੇ NULL ਤੇ ਡੁਪਲੀਕੇਟਾਂ ਵਾਲੀਆਂ ਗੁੰਝਲਾਂ ਫੜਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।
4. NULL ਨੂੰ ਵੱਖਰੇ ਵਿਸ਼ੇ ਵਜੋਂ ਸਿੱਖੋ। IS NULL, COUNT(column) ਅਤੇ COUNT(*) ਦਾ ਫ਼ਰਕ, AVG ਵੱਲੋਂ NULLs ਨੂੰ ਛੱਡਣਾ, ਸੂਚੀ ਵਿੱਚ NULL ਹੋਣ 'ਤੇ NOT IN ਦਾ ਵਿਹਾਰ, ਅਤੇ unmatched columns ਵਿੱਚ left join ਕੀ ਰੱਖਦਾ ਹੈ - ਇਨ੍ਹਾਂ ਦਾ ਅਭਿਆਸ ਕਰੋ।
5. ਅਸਲ queries ਵੀ ਲਿਖੋ। ਸਾਡੇ mock tests ਪੜ੍ਹਨ ਅਤੇ query ਦਾ ਪਤਾ ਲਗਾਉਣ ਦੇ ਹੁਨਰ ਬਣਾਉਂਦੇ ਹਨ; ਨਾਲ ਹੀ SQLite ਵਰਗੇ ਮੁਫ਼ਤ ਡੇਟਾਬੇਸ ਵਿੱਚ queries ਲਿਖੋ, ਤਾਂ ਜੋ ਸਮੇਂ ਦੀ ਪਾਬੰਦੀ ਹੇਠ ਟਾਈਪ ਕਰਨਾ ਆਮ ਲੱਗੇ। ਕੁਝ ਟੈਸਟ ਤੁਹਾਡੀ query ਨੂੰ ਕਈ ਮਾਮਲਿਆਂ 'ਤੇ ਜਾਂਚਦੇ ਹਨ, ਜਿਵੇਂ TestGorilla ਆਪਣੇ SQLite ਟੈਸਟ ਲਈ 10 ਤੋਂ ਵੱਧ test cases ਦਾ ਜ਼ਿਕਰ ਕਰਦਾ ਹੈ (TestGorilla).
6. ਸਿਰਫ਼ syntax ਨਹੀਂ, ਨਤੀਜਾ ਵੀ ਜਾਂਚੋ। Query ਚੱਲਣ ਦੇ ਬਾਵਜੂਦ ਗਲਤ ਕਤਾਰਾਂ ਦਿਖਾ ਸਕਦੀ ਹੈ। ਜਵਾਬ ਜਮ੍ਹਾਂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸੋਚੋ ਕਿ ਕੋਈ ਮੇਲ ਨਾ ਮਿਲਣ, ਡੁਪਲੀਕੇਟ ਹੋਣ ਅਤੇ NULLs ਹੋਣ 'ਤੇ ਕੀ ਹੋਵੇਗਾ।
7. ਅਸਲ ਰਫ਼ਤਾਰ ਨਾਲ ਅਭਿਆਸ ਕਰੋ। TestGorilla ਦੇ MySQL ਟੈਸਟ ਵਰਗੇ ਛੋਟੇ ਗਿਆਨ ਟੈਸਟ ਵਿੱਚ 10 ਮਿੰਟਾਂ ਵਿੱਚ 15 ਸਵਾਲ ਹੁੰਦੇ ਹਨ, ਇਸ ਲਈ ਹਰ ਸਵਾਲ ਲਈ ਇੱਕ ਮਿੰਟ ਤੋਂ ਵੀ ਕਾਫ਼ੀ ਘੱਟ ਸਮਾਂ ਮਿਲਦਾ ਹੈ (TestGorilla). ਪੂਰੇ ਸਮੇਂ-ਬੱਧ mock tests ਦਿਓ, ਤਾਂ ਜੋ ਟੈਸਟ ਵਾਲੇ ਦਿਨ ਇਹ ਰਫ਼ਤਾਰ ਆਮ ਲੱਗੇ।

ਅੰਕ ਦੇਣ ਦਾ ਤਰੀਕਾ ਆਮ ਤੌਰ 'ਤੇ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ

ਸਕੋਰਿੰਗ ਨਿਯੋਗਤਾ ਅਤੇ ਪਲੇਟਫਾਰਮ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ। SQL ਲਈ ਕੋਈ ਮਿਆਰੀ ਸਕੋਰ ਜਾਂ ਸਭ ਲਈ ਇੱਕੋ ਪਾਸ ਅੰਕ ਨਹੀਂ ਹਨ। ਹਰ ਨਿਯੋਗਤਾ ਇਹ ਫ਼ੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜਾ ਨਤੀਜਾ ਚੰਗਾ ਮੰਨਿਆ ਜਾਵੇਗਾ। ਕੁਐਰੀ ਵਾਲੇ ਸਵਾਲਾਂ ਦੀ ਜਾਂਚ ਕਿਵੇਂ ਹੁੰਦੀ ਹੈ, ਇਸ ਦੀਆਂ ਦੋ ਜਨਤਕ ਉਦਾਹਰਨਾਂ:

• HackerRank ਡੇਟਾਬੇਸ ਸਵਾਲ: HackerRank ਦੱਸਦਾ ਹੈ ਕਿ ਇਹ ਤੁਹਾਡੀ ਕੁਐਰੀ ਦੇ ਨਤੀਜੇ ਦੀ ਉਮੀਦ ਕੀਤੇ ਆਉਟਪੁੱਟ ਨਾਲ ਤੁਲਨਾ ਕਰਕੇ ਆਪਣੇ ਆਪ ਸਕੋਰ ਕਰਦਾ ਹੈ। ਜੇ ਦੋਵੇਂ ਮੇਲ ਖਾਂਦੇ ਹਨ ਤਾਂ ਪੂਰਾ ਸਕੋਰ ਮਿਲਦਾ ਹੈ, ਨਹੀਂ ਤਾਂ ਜ਼ੀਰੋ, ਜਦ ਤੱਕ ਨਿਯੋਗਤਾ ਹੱਥੀਂ ਜਾਂਚ ਕਰਕੇ ਕੁਝ ਅੰਕ ਨਾ ਦੇਵੇ। ਨਿਯੋਗਤਾ ਕਤਾਰਾਂ ਦੇ ਕ੍ਰਮ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨ ਦਾ ਵਿਕਲਪ ਵੀ ਚੁਣ ਸਕਦਾ ਹੈ (HackerRank ਸਹਾਇਤਾ).
• TestGorilla ਦਾ SQLite ਟੈਸਟ: TestGorilla ਦੱਸਦਾ ਹੈ ਕਿ ਉਮੀਦਵਾਰਾਂ ਦੀ ਦਰਜਾਬੰਦੀ 10 ਤੋਂ ਵੱਧ ਟੈਸਟ ਕੇਸਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜੋ ਹੱਲ ਦੇ ਖ਼ਾਸ ਅਤੇ ਸੀਮਾਵਰਤੀ ਮਾਮਲਿਆਂ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਨ (TestGorilla).

ਕਿਉਂਕਿ ਨਤੀਜਿਆਂ ਦੀ ਅਕਸਰ ਕਤਾਰ-ਦਰ-ਕਤਾਰ ਜਾਂਚ ਹੁੰਦੀ ਹੈ, ਇਸ ਲਈ ਲਗਭਗ ਸਹੀ ਕੁਐਰੀ, ਜਿਵੇਂ ਕੋਈ ਅਜਿਹੀ ਕੁਐਰੀ ਜੋ ਬਿਨਾਂ ਆਰਡਰ ਵਾਲੇ ਗਾਹਕ ਨੂੰ ਛੱਡ ਦੇਵੇ, ਨੂੰ ਵੀ ਬਿਲਕੁਲ ਜਵਾਬ ਨਾ ਦੇਣ ਜਿੰਨਾ ਹੀ ਸਕੋਰ ਮਿਲ ਸਕਦਾ ਹੈ।

ਸਾਡਾ ਅਭਿਆਸ ਸਕੋਰ ਦੱਸਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਸਾਡੇ ਕਿੰਨੇ ਸਵਾਲਾਂ ਦੇ ਸਹੀ ਜਵਾਬ ਦਿੱਤੇ ਹਨ। ਇਸ ਵਿੱਚ ਭਾਗ ਅਨੁਸਾਰ ਵੇਰਵਾ ਵੀ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਦੇਖ ਸਕੋ ਕਿ ਕਿੱਥੇ ਧਿਆਨ ਦੇਣਾ ਹੈ। ਇਹ ਸਿਰਫ਼ ਅਭਿਆਸ ਸਕੋਰ ਹੈ: ਇਹ ਕਿਸੇ ਨਿਯੋਗਤਾ ਜਾਂ ਪਲੇਟਫਾਰਮ ਦੇ ਟੈਸਟ ਦਾ ਸਕੋਰ ਨਹੀਂ ਹੈ ਅਤੇ ਇਹ ਨਹੀਂ ਦੱਸਦਾ ਕਿ ਤੁਸੀਂ ਪਾਸ ਹੋਵੋਗੇ ਜਾਂ ਨਹੀਂ।

ਆਮ ਗਲਤੀਆਂ

• = ਨਾਲ NULL ਦੀ ਤੁਲਨਾ ਕਰਨਾ। IS NULL ਅਤੇ IS NOT NULL ਵਰਤੋ। = NULL ਨਾਲ ਕੀਤੀ ਕੋਈ ਵੀ ਤੁਲਨਾ ਅਣਜਾਣ ਹੁੰਦੀ ਹੈ, ਇਸ ਲਈ ਉਹ row ਫਿਲਟਰ ਹੋ ਜਾਂਦੀ ਹੈ।
• WHERE ਵਿੱਚ left join ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ। ਸੱਜੇ ਪਾਸੇ ਵਾਲੀ table ਦੇ columns 'ਤੇ ਜਾਂਚ ਕਰਨ ਨਾਲ ਬਿਨਾਂ ਮੇਲ ਵਾਲੀਆਂ rows ਹਟ ਜਾਂਦੀਆਂ ਹਨ। ਜੇ ਉਹਨਾਂ ਨੂੰ ਰੱਖਣਾ ਹੈ, ਤਾਂ ਜਾਂਚ ON clause ਵਿੱਚ ਪਾਓ।
• ਕੁੱਲ ਲਈ WHERE ਵਰਤਣਾ। Aggregate ਨਤੀਜਿਆਂ ਲਈ GROUP BY ਤੋਂ ਬਾਅਦ HAVING ਵਰਤੋ।
• ਉਹ column ਚੁਣਨਾ ਜਿਸ ਨੂੰ group ਨਹੀਂ ਕੀਤਾ। Standard SQL ਵਿੱਚ ਚੁਣਿਆ ਹਰ column ਜਾਂ ਤਾਂ group ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜਾਂ aggregate ਕੀਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਕੁਝ databases ਇਸਨੂੰ ਚਲਣ ਦਿੰਦੇ ਹਨ ਅਤੇ ਤੁਹਾਡੇ ਲਈ ਕੋਈ ਮੁੱਲ ਚੁਣ ਲੈਂਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਗਲਤੀ ਲੁਕੀ ਰਹਿੰਦੀ ਹੈ।
• ਦੁਹਰਾਏ ਹੋਏ ਨਤੀਜੇ ਭੁੱਲ ਜਾਣਾ। Join ਨਾਲ rows ਦੁਹਰਾਈਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ, ਜਿਸ ਨਾਲ SUM ਅਤੇ COUNT ਵੱਧ ਜਾਂਦੇ ਹਨ। ਜਾਂਚੋ ਕਿ ਕੀ ਇੱਕ ਪਾਸੇ ਦੀ ਹਰ row ਦੂਜੇ ਪਾਸੇ ਦੀ ਇੱਕ ਤੋਂ ਵੱਧ row ਨਾਲ ਮੇਲ ਖਾ ਸਕਦੀ ਹੈ।
• ਕਿਸੇ ਇੱਕ database ਦੇ ਛੋਟੇ ਰਾਹਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਨਾ। ਕੁਝ functions ਅਤੇ limit ਲਿਖਣ ਦੇ ਤਰੀਕੇ databases ਵਿਚ ਵੱਖਰੇ ਹੁੰਦੇ ਹਨ। Standard ਤਰੀਕਾ ਸਿੱਖੋ ਅਤੇ ਜਾਂਚੋ ਕਿ ਤੁਹਾਡਾ ਟੈਸਟ ਕਿਹੜਾ database ਵਰਤਦਾ ਹੈ।