{
  "assessmentTests": {
    "sql_test": {
      "name": "SQL ਟੈਸਟ",
      "desc": "ਫਿਲਟਰਿੰਗ, ਜੋਇਨ, ਐਗਰੀਗੇਸ਼ਨ, ਸਬਕਵੇਰੀਆਂ ਅਤੇ ਵਿੰਡੋ ਫੰਕਸ਼ਨਾਂ 'ਤੇ 30 ਦ੍ਰਿਸ਼-ਆਧਾਰਿਤ ਸਵਾਲ — ਪਤਾ ਲਗਾਓ ਕਿ ਕੀ ਤੁਹਾਡੀ SQL ਓਨੀ ਹੀ ਮਜ਼ਬੂਤ ਹੈ ਜਿੰਨੀ ਕਿਸੇ ਨੌਕਰੀ ਦੀ ਪੋਸਟਿੰਗ ਦਾ ਮਤਲਬ SQL ਮੁਹਾਰਤ ਤੋਂ ਹੁੰਦਾ ਹੈ।",
      "recommendation": "ਤੁਹਾਡੀ SQL ਦੇ ਹੁਨਰ ਦਾ ਪ੍ਰੋਫਾਈਲ",
      "results": {
        "beginner": {
          "name": "ਸ਼ੁਰੂਆਤੀ",
          "desc": "ਤੁਸੀਂ ਕੰਮ ਕਰਨ ਵਾਲਾ SELECT ਸਟੇਟਮੈਂਟ ਲਿਖ ਸਕਦੇ ਹੋ ਅਤੇ ਕੁਝ ਸ਼ਰਤਾਂ 'ਤੇ ਫਿਲਟਰ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਜੋ ਸਵਾਲ ਤੁਸੀਂ ਖੁੰਝ ਗਏ ਉਹ ਸੰਟੈਕਸ ਦੀ ਬਜਾਏ NULL ਹੈਂਡਲਿੰਗ ਅਤੇ ਜੋਇਨ ਦੀ ਮਕੈਨਿਕਸ ਦੁਆਲੇ ਕੇਂਦਰਿਤ ਹਨ — ਕਿਸੇ ਕਾਲਮ ਦੀ = ਨਾਲ NULL ਨਾਲ ਤੁਲਨਾ ਕਰਨਾ, LEFT JOIN ਅਸਲ ਵਿੱਚ ਕੀ ਬਚਾਉਂਦਾ ਹੈ, BETWEEN ਦੀਆਂ ਸੀਮਾਵਾਂ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ। ਇਸ ਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਕਿ ਤੁਸੀਂ ਡਾਟਾਬੇਸ ਵਿੱਚ ਕਮਜ਼ੋਰ ਹੋ; ਇਹ ਉਹ ਖਾਸ ਨਿਯਮ ਹਨ ਜੋ ਉਹਨਾਂ ਲੋਕਾਂ ਨੂੰ ਉਲਝਾਉਂਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਨੇ SQL ਮਿਆਰ (standard) ਤੋਂ ਸਿੱਖਣ ਦੀ ਬਜਾਏ ਅਜ਼ਮਾਇਸ਼ ਅਤੇ ਗਲਤੀ ਰਾਹੀਂ ਸਿੱਖੀ। ਇਹ ਕੰਮ 'ਤੇ ਇਸ ਲਈ ਮਾਇਨੇ ਰੱਖਦੇ ਹਨ ਕਿਉਂਕਿ ਹਰ ਇੱਕ ਅਜਿਹੀ ਥਾਂ ਹੈ ਜਿੱਥੇ ਇੱਕ ਕਵੇਰੀ ਦੇਖਣ ਵਿੱਚ ਸਹੀ ਲੱਗਣ ਵਾਲੀ ਪਰ ਗਲਤ ਰੋ-ਕਾਊਂਟ ਮੋੜਦੀ ਹੈ।",
          "recommendation": "ਇਸ ਕ੍ਰਮ ਵਿੱਚ ਤਿੰਨ ਚੀਜ਼ਾਂ ਤੋਂ ਸ਼ੁਰੂ ਕਰੋ: WHERE col = NULL ਕਦੇ ਵੀ ਕੁਝ ਕਿਉਂ ਨਹੀਂ ਮੇਲ ਖਾਂਦਾ (ਅਤੇ ਇਸਦੀ ਬਜਾਏ IS NULL ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ), INNER JOIN ਬੇਮੇਲ ਰੋਅ ਕਿਵੇਂ ਹਟਾਉਂਦਾ ਹੈ ਜਦਕਿ LEFT JOIN ਉਹਨਾਂ ਨੂੰ ਰੱਖਦਾ ਹੈ, ਅਤੇ BETWEEN ਦੀਆਂ ਸਹੀ ਸੀਮਾਵਾਂ ਕੀ ਸ਼ਾਮਲ ਕਰਦੀਆਂ ਹਨ। Mode Analytics ਦਾ SQL ਟਿਊਟੋਰਿਅਲ ਅਤੇ PostgreSQL ਦੀ ਦਸਤਾਵੇਜ਼ੀਕਰਨ ਦੋਵੇਂ ਇਹ ਤਿੰਨੇ ਚਲਾਉਣਯੋਗ ਉਦਾਹਰਣਾਂ ਨਾਲ ਕਵਰ ਕਰਦੇ ਹਨ।"
        },
        "intermediate": {
          "name": "ਵਿਚਕਾਰਲਾ",
          "desc": "ਤੁਸੀਂ ਰੋਜ਼ਾਨਾ ਦੀਆਂ ਰਿਪੋਰਟਿੰਗ ਕਵੇਰੀਆਂ ਨੂੰ ਆਰਾਮ ਨਾਲ ਸੰਭਾਲਦੇ ਹੋ — ਜੋਇਨ, GROUP BY, ਸਿੱਧਾ-ਸਾਦਾ ਫਿਲਟਰਿੰਗ — ਅਤੇ ਰੁਟੀਨ ਡੈਸ਼ਬੋਰਡ ਜਾਂ ਐਡ-ਹਾਕ ਵਿਸ਼ਲੇਸ਼ਣ ਦਾ ਕੰਮ ਤੁਹਾਨੂੰ ਹੌਲੀ ਨਹੀਂ ਕਰੇਗਾ। ਇੱਥੋਂ Advanced ਤੱਕ ਦਾ ਫ਼ਰਕ ਜ਼ਿਆਦਾਤਰ ਉਦੋਂ ਸਾਹਮਣੇ ਆਉਂਦਾ ਹੈ ਜਦੋਂ ਕਲਾਜ਼ ਇੱਕ ਦੂਜੇ ਨਾਲ ਟਕਰਾਉਂਦੇ ਹਨ: ਜੋਇਨ ਕੀਤੇ ਟੇਬਲ 'ਤੇ ਇੱਕ WHERE ਕਲਾਜ਼ ਚੁੱਪਚਾਪ LEFT JOIN ਨੂੰ ਵਾਪਸ INNER JOIN ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ, ਇੱਕ ਜੋਇਨ ਜੋ ਐਗਰੀਗੇਟ ਲਾਗੂ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਰੋ-ਕਾਊਂਟ ਵਧਾ ਦਿੰਦਾ ਹੈ, ਇੱਕ NOT IN ਜੋ ਇੱਕ NULL ਸਬਕਵੇਰੀ ਵਿੱਚ ਆ ਜਾਣ ਕਾਰਨ ਚੁੱਪਚਾਪ ਕੁਝ ਨਹੀਂ ਮੋੜਦਾ। ਇਹ ਉਸ ਕਿਸਮ ਦੇ ਬੱਗ ਹਨ ਜੋ ਇੱਕ ਤੇਜ਼ ਨਜ਼ਰ ਮਾਰਨ ਵਿੱਚੋਂ ਲੰਘ ਜਾਂਦੇ ਹਨ ਅਤੇ ਸਿਰਫ਼ ਉਦੋਂ ਸਾਹਮਣੇ ਆਉਂਦੇ ਹਨ ਜਦੋਂ ਕੋਈ ਕੁੱਲ ਜੋੜ ਦੀ ਤੁਲਨਾ ਕਿਸੇ ਹੋਰ ਰਿਪੋਰਟ ਨਾਲ ਕਰਦਾ ਹੈ।",
          "recommendation": "ਇਸ 'ਤੇ ਧਿਆਨ ਦਿਓ ਕਿ ਕਲਾਜ਼ ਇਕੱਲੇ-ਇਕੱਲੇ ਕੀ ਕਰਦੇ ਹਨ ਇਸ ਦੀ ਬਜਾਏ ਇੱਕ ਦੂਜੇ ਨਾਲ ਕਿਵੇਂ ਟਕਰਾਉਂਦੇ ਹਨ: LEFT JOIN ਦੇ ਸੱਜੇ-ਪਾਸੇ ਦੇ ਕਾਲਮਾਂ 'ਤੇ WHERE ਫਿਲਟਰਿੰਗ, ਐਗਰੀਗੇਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ-ਤੋਂ-ਕਈ ਜੋਇਨਾਂ ਤੋਂ ਰੋਅ ਦਾ ਗੁਣਾ, ਅਤੇ NOT IN NULL ਦੀ ਮੌਜੂਦਗੀ ਵਿੱਚ ਕਿਉਂ ਟੁੱਟ ਜਾਂਦਾ ਹੈ (EXISTS ਆਮ ਤੌਰ 'ਤੇ ਨਹੀਂ ਟੁੱਟਦਾ)। ਫਿਰ HAVING ਬਨਾਮ WHERE, ਕਿਉਂਕਿ ਇਹ ਫ਼ਰਕ ਉਹਨਾਂ ਲੋਕਾਂ ਨੂੰ ਉਲਝਾਉਂਦਾ ਹੈ ਜੋ ਦੋਵੇਂ ਕਲਾਜ਼ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਪਹਿਲਾਂ ਹੀ ਜਾਣਦੇ ਹਨ।"
        },
        "advanced": {
          "name": "ਐਡਵਾਂਸਡ",
          "desc": "ਇਹ ਉਹ ਪੱਧਰ ਹੈ ਜਿਸਦਾ ਮਤਲਬ ਜ਼ਿਆਦਾਤਰ ਨੌਕਰੀ ਦੀਆਂ ਪੋਸਟਿੰਗਾਂ \"strong SQL\" ਤੋਂ ਲੈਂਦੀਆਂ ਹਨ। ਤੁਸੀਂ ਇੱਕ ਮਲਟੀ-ਜੋਇਨ ਕਵੇਰੀ ਪੜ੍ਹ ਕੇ ਇਸਨੂੰ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਇਸਦਾ ਰੋ-ਕਾਊਂਟ ਦੱਸ ਸਕਦੇ ਹੋ, ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਇੱਕ ਰਿਜ਼ਲਟ ਸੈੱਟ ਕਿਉਂ ਬਦਲਿਆ, ਨਾ ਕਿ ਸਿਰਫ਼ ਇਹ ਕਿ ਇਹ ਬਦਲਿਆ, ਅਤੇ ਜਦੋਂ ਇਹ ਸਪਸ਼ਟ ਟੂਲ ਹੋਵੇ ਤਾਂ ਤੁਸੀਂ ਨੈਸਟਡ ਸਬਕਵੇਰੀ ਦੀ ਬਜਾਏ CTE ਜਾਂ ਵਿੰਡੋ ਫੰਕਸ਼ਨ ਵੱਲ ਜਾਂਦੇ ਹੋ। ਇਸ ਪੱਧਰ ਨੂੰ ਸਭ ਤੋਂ ਉੱਪਰਲੇ ਪੱਧਰ ਤੋਂ ਜੋ ਚੀਜ਼ ਵੱਖ ਕਰਦੀ ਹੈ ਉਹ ਹੈ ਕੰਮ ਦਾ ਬਚਾਅ-ਮੁਖੀ ਪੱਖ: ਇਹ ਜਾਣਨਾ ਕਿ ਜਦੋਂ ਟਾਈ ਮਾਇਨੇ ਰੱਖਦੀ ਹੈ ਤਾਂ ਕਿਹੜਾ ਰੈਂਕਿੰਗ ਫੰਕਸ਼ਨ ਵਰਤਣਾ ਹੈ, ਇੱਕ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਕਿਸੇ ਸਮਵਰਤੀ (concurrent) ਸੈਸ਼ਨ ਤੋਂ ਕੀ ਆਈਸੋਲੇਟ ਕਰਦਾ ਹੈ, ਅਤੇ ਗੁੰਮ ON DELETE ਨਿਯਮ ਡਾਟਾਬੇਸ ਪੱਧਰ 'ਤੇ ਅਸਲ ਵਿੱਚ ਕੀ ਕਰਦਾ ਹੈ।",
          "recommendation": "ਉਹਨਾਂ ਹਿੱਸਿਆਂ ਵਿੱਚ ਡੂੰਘਾਈ ਨਾਲ ਜਾਓ ਜੋ ਉਸ ਡਾਟੇ ਦੀ ਰਾਖੀ ਕਰਦੇ ਹਨ ਜਿਸਨੂੰ ਹੋਰ ਲੋਕ ਵੀ ਛੂੰਹਦੇ ਹਨ: ਟਾਈ ਹੋਣ 'ਤੇ RANK, DENSE_RANK ਅਤੇ ROW_NUMBER ਵਿਚਕਾਰ ਫ਼ਰਕ, COMMIT ਅਸਲ ਵਿੱਚ ਕੀ ਅਤੇ ਕਿਸ ਨੂੰ ਦਿਖਣਯੋਗ ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ DELETE 'ਤੇ ਫਾਰਨ ਕੀ (foreign key) ਦਾ ਵਿਵਹਾਰ। ਵਿੰਡੋ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਆਈਸੋਲੇਸ਼ਨ 'ਤੇ The Index ਨਿਊਜ਼ਲੈਟਰ ਜਾਂ SQL for Devs ਦੀ ਡੂੰਘੀ ਜਾਣਕਾਰੀ ਦੋਵਾਂ ਲਈ ਅਗਲਾ ਪੜਾਅ ਵਜੋਂ ਵਰਤੋ।"
        },
        "expert": {
          "name": "ਮਾਹਿਰ",
          "desc": "ਤੁਸੀਂ ਹਰ ਸੈਕਸ਼ਨ ਵਿੱਚ ਸਭ ਤੋਂ ਵਧੀਆ ਸਕੋਰ ਕੀਤਾ — ਫਿਲਟਰਿੰਗ ਅਤੇ NULL ਸਿਮੈਂਟਿਕਸ; ਜੋਇਨ ਅਤੇ ਸੈੱਟ ਓਪਰੇਸ਼ਨ; ਐਗਰੀਗੇਸ਼ਨ ਅਤੇ ਸਬਕਵੇਰੀਆਂ; ਅਤੇ ਵਿੰਡੋ ਫੰਕਸ਼ਨ, CTE ਅਤੇ ਕੰਸਟ੍ਰੇਂਟ। ਵਿਹਾਰਕ ਤੌਰ 'ਤੇ, ਇਸ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਕਿਸੇ ਅਣਜਾਣ ਵਿਅਕਤੀ ਦੀ ਮਲਟੀ-ਜੋਇਨ ਰਿਪੋਰਟ ਕਵੇਰੀ ਦਿੱਤੀ ਜਾ ਸਕਦੀ ਹੈ ਅਤੇ ਤੁਸੀਂ ਸਮਝਾ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਜੋ ਰੋ-ਕਾਊਂਟ ਮੋੜਦੀ ਹੈ ਉਹ ਕਿਉਂ ਮੋੜਦੀ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ਼ ਇਹ ਕਿ ਸੰਟੈਕਸ ਦੇ ਹਿਸਾਬ ਨਾਲ ਇਸਨੂੰ ਕੀ ਮੋੜਨਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਕਿ ਔਖਾ ਅਤੇ ਜ਼ਿਆਦਾ ਕੀਮਤੀ ਹੁਨਰ ਹੈ। ਇਸ ਪੱਧਰ 'ਤੇ ਕਵੇਰੀ ਭਾਸ਼ਾ ਖੁਦ ਘੱਟ ਹੀ ਸੀਮਾ ਬਣਦੀ ਹੈ; ਸੀਮਾ ਆਮ ਤੌਰ 'ਤੇ ਸਕੀਮਾ ਡਿਜ਼ਾਈਨ ਜਾਂ ਉਸ ਦੇ ਹੇਠਾਂ ਡਾਟੇ ਦਾ ਆਕਾਰ ਹੁੰਦੀ ਹੈ।",
          "recommendation": "ਹੁਣ ਫਾਇਦਾ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਪਲਾਨ ਅਤੇ ਡਿਜ਼ਾਈਨ ਵਿੱਚ ਹੈ: ਕਵੇਰੀ ਹੌਲੀ ਹੈ ਇਹ ਮੰਨਣ ਤੋਂ ਪਹਿਲਾਂ EXPLAIN ਆਉਟਪੁੱਟ ਪੜ੍ਹਨਾ, ਇੰਡੈਕਸਿੰਗ ਰਣਨੀਤੀ ਨੂੰ ਇੱਕ ਮੁਫ਼ਤ ਫਾਇਦੇ ਦੀ ਬਜਾਏ ਲਿਖਣ ਦੀ ਲਾਗਤ ਦੇ ਖ਼ਿਲਾਫ਼ ਇੱਕ ਸਮਝੌਤੇ ਵਜੋਂ ਦੇਖਣਾ, ਅਤੇ ਨਾਰਮਲਾਈਜ਼ੇਸ਼ਨ ਫੈਸਲੇ ਜੋ ਸਕੀਮਾ ਵਧਣ ਦੇ ਨਾਲ ਕਾਇਮ ਰਹਿਣ। ਜੇ ਤੁਹਾਡੀ ਕਿਸੇ ਭੂਮਿਕਾ ਲਈ ਸਕ੍ਰੀਨਿੰਗ ਹੋ ਰਹੀ ਹੈ, ਤਾਂ SQL ਫੀਚਰਾਂ ਦੇ ਨਾਂ ਲੈਣ ਦੀ ਬਜਾਏ ਪ੍ਰੋਡਕਸ਼ਨ ਵਿੱਚ ਮਿਲੀ ਜੋਇਨ ਫੈਨ-ਆਊਟ ਜਾਂ NOT IN/NULL ਟ੍ਰੈਪ ਵਰਗੀ ਕਵੇਰੀ ਬੱਗ ਦਾ ਵਰਣਨ ਕਰੋ; ਇਹ ਤਰਕ ਦਿਖਾਉਂਦਾ ਹੈ, ਸਿਰਫ਼ ਸ਼ਬਦਾਵਲੀ ਨਹੀਂ।"
        }
      },
      "questions": [
        {
          "question": "ਇੱਕ ਟੇਬਲ ਵਿੱਚ ਇੱਕ nullable ਕਾਲਮ age ਹੈ। ਤੁਸੀਂ SELECT * FROM users WHERE age = NULL ਚਲਾਓ। ਇਹ ਕਿੰਨੀਆਂ ਪੰਕਤੀਆਂ ਮੁੜ ਕਰਦਾ ਹੈ, ਭਾਵੇਂ ਕਿ ਕਈ ਪੰਕਤੀਆਂ age NULL ਨੂੰ ਸੈਟ ਕੀਤਾ ਹੋਵੇ?",
          "options": [
            {
              "icon": "",
              "label": "ਹਰ ਪੰਕਤੀ ਜਿੱਥੇ age NULL ਹੈ, ਕਿਉਂਕਿ = NULL ਨੂੰ ਕਿਸੇ ਹੋਰ ਮੁੱਲ ਦੀ ਤਰ੍ਹਾਂ ਮੇਲ ਖਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਜ਼ੀਰੋ — = ਨਾਲ NULL ਨੂੰ ਤੁਲਨਾ UNKNOWN ਪੈਦਾ ਕਰਦੀ ਹੈ, ਕਦੇ TRUE ਨਹੀਂ, ਇਸ ਲਈ ਕੋਈ ਪੰਕਤੀ ਮੇਲ ਨਹੀਂ ਖਾ ਸਕਦੀ; IS NULL ਜ਼ਰੂਰੀ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ ਸਿਂਟੈਕਸ ਤ੍ਰੁਟੀ — NULL = ਦੇ ਸੱਜੇ ਪਾਸੇ ਨਹੀਂ ਆ ਸਕਦਾ"
            },
            {
              "icon": "",
              "label": "ਟੇਬਲ ਵਿੱਚ ਹਰ ਪੰਕਤੀ, ਕਿਉਂਕਿ NULL ਤੁਲਨਾ ਡਿਫਾਲਟ TRUE ਕਰਦੀਆਂ ਹਨ"
            }
          ]
        },
        {
          "question": "ਤੁਸੀਂ SELECT DISTINCT department, role FROM employees ਚਲਾਓ। DISTINCT ਕੀ ਨਕਲਾਂ ਹਟਾਉਂਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਵਿਭਾਗ ਅਤੇ ਭੂਮਿਕਾ ਦਾ ਸੁਮੇਲ — ਇੱਕ ਪੰਕਤੀ ਸਿਰਫ ਹਟਾਈ ਜਾਂਦੀ ਹੈ ਜੇ ਦੋਵਾਂ ਕਾਲਮ ਬਿਲਕੁਲ ਹੋਰ ਪੰਕਤੀ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹੋਣ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ ਡਪਲਿਕੇਟ ਵਿਭਾਗ ਮੁੱਲ, ਹਰ ਭੂਮਿਕਾ ਨੂੰ ਰੱਖਦੇ ਹੋਏ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ ਡਪਲਿਕੇਟ ਭੂਮਿਕਾ ਮੁੱਲ, ਹਰ ਵਿਭਾਗ ਨੂੰ ਰੱਖਦੇ ਹੋਏ"
            },
            {
              "icon": "",
              "label": "ਕੁਝ ਨਹੀਂ — DISTINCT ਸਿਰਫ ਇੱਕ ਕਾਲਮ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "ਇੱਕ ਕਾਲਮ ਨਾਮ WHERE name LIKE 'A_' ਨਾਲ ਫਿਲਟਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਮੁੱਲ ਮੇਲ ਖਾਂਦੇ ਹਨ: 'A', 'Al', 'Ana', 'Ally'?",
          "options": [
            {
              "icon": "",
              "label": "'A' — ਅੰਡਰਸਕੋਰ ਵਿਕਲਪਿਕ ਹੈ ਅਤੇ ਜ਼ੀਰੋ ਜਾਂ ਵਧੀ ਅੱਖਰਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "'Al' — ਅੰਡਰਸਕੋਰ ਬਿਲਕੁਲ ਇੱਕ ਅੱਖਰ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਇਸ ਲਈ LIKE 'A_' A ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੀ ਕੋਈ ਦੋ-ਅੱਖਰ ਸਟਰਿੰਗ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "'Ana' ਅਤੇ 'Ally' — ਅੰਡਰਸਕੋਰ ਕਿਸੇ ਵੀ ਸੰਖਿਆ ਦੀ ਟ੍ਰੇਲਿੰਗ ਅੱਖਰਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਸਾਰੇ ਚਾਰ ਮੁੱਲ ਮੇਲ ਖਾਂਦੇ ਹਨ, ਕਿਉਂਕਿ LIKE ਲੰਬਾਈ ਨਜ਼ਰ ਅੰਦਾਜ਼ ਕਰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "ਇੱਕ ਕੀਮਤ ਕਾਲਮ WHERE price BETWEEN 10 AND 20 ਨਾਲ ਫਿਲਟਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਕੀ ਕੀਮਤ ਬਿਲਕੁਲ 10 ਜਾਂ ਬਿਲਕੁਲ 20 ਵਾਲੀਆਂ ਪੰਕਤੀਆਂ ਸ਼ਾਮਲ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ?",
          "options": [
            {
              "icon": "",
              "label": "ਨਹੀਂ — BETWEEN ਦੋਵਾਂ ਅੰਤ ਬਿੰਦੂਆਂ ਨੂੰ ਬਾਹਰ ਰੱਖਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਹਾਂ — BETWEEN ਦੋਵਾਂ ਸਿਰਿਆਂ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ, price >= 10 AND price <= 20 ਦੇ ਬਰਾਬਰ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ price = 10 ਸ਼ਾਮਲ ਹੈ; ਉੱਪਰਲੀ ਹੱਦ ਵਿਸ਼ੇਸ਼ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ price = 20 ਸ਼ਾਮਲ ਹੈ; ਹੇਠਲੀ ਹੱਦ ਵਿਸ਼ੇਸ਼ ਹੈ"
            }
          ]
        },
        {
          "question": "ਇੱਕ ਟੇਬਲ orders ਵਿੱਚ 10 ਪੰਕਤੀਆਂ ਹਨ, ਅਤੇ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ 3 ਦਾ shipped_date NULL ਹੈ। SELECT COUNT(*) FROM orders ਕੀ ਮੁੜ ਕਰਦਾ ਹੈ, ਅਤੇ SELECT COUNT(shipped_date) FROM orders ਕੀ ਮੁੜ ਕਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "10, ਫਿਰ 10 — COUNT ਹਮੇਸ਼ਾ ਪੰਕਤੀਆਂ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ NULL ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾ"
            },
            {
              "icon": "",
              "label": "7, ਫਿਰ 7 — ਦੋਵਾਂ ਫਾਰਮ NULL ਪੰਕਤੀਆਂ ਨੂੰ ਛੱਡ ਦਿੰਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "10, ਫਿਰ 7 — COUNT(*) ਹਰ ਪੰਕਤੀ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ, COUNT(column) ਸਿਰਫ ਪੰਕਤੀਆਂ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਉਹ ਕਾਲਮ NULL ਨਹੀਂ ਹੈ"
            },
            {
              "icon": "",
              "label": "10, ਫਿਰ 3 — COUNT(column) ਸਿਰਫ NULL ਮੁੱਲਾਂ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "ਤੁਸੀਂ SELECT name, salary FROM employees ORDER BY 2 DESC ਚਲਾਓ। 2 ਕੀ ਵਿਆਪਕ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਇੱਕ ਸਿੰਟੈਕਸ ਤ੍ਰੁਟੀ — ORDER BY ਸਿਰਫ ਕਾਲਮ ਨਾਮ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, ਸੰਖਿਆਵਾਂ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "ਨਤੀਜੇ ਦੀ ਦੂਸਰੀ ਪੰਕਤੀ"
            },
            {
              "icon": "",
              "label": "2 ਦਾ ਇੱਕ ਲਫਜ਼ੀ ਮੁੱਲ, ਟਾਈ-ਬ੍ਰੇਕਰ ਵਜੋਂ ਵਰਤਿਆ"
            },
            {
              "icon": "",
              "label": "SELECT ਸੂਚੀ ਵਿੱਚ ਦੂਸਰਾ ਕਾਲਮ, salary — ORDER BY ਕਾਲਮ ਦੀ ਸਥਿਤੀ ਸੰਖਿਆ ਨੂੰ ਸ਼ਾਰਟਹੈਂਡ ਦੇ ਤੌਰ ਤੇ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "ਮਾਨ SQL ਵਿੱਚ, 'Ana' || ' ' || 'Lee' ਕੀ ਮੁਲਾਂਕਨ ਕਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਇੱਕ ਸਿੰਟੈਕਸ ਤ੍ਰੁਟੀ — SQL ਕੋਲ ਕੋਈ ਸੰਯੋਜਨ ਓਪਰੇਟਰ ਨਹੀਂ ਹੈ"
            },
            {
              "icon": "",
              "label": "3 — || ਨੂੰ ਇੱਕ ਬੂਲੀਅਨ OR ਵਜੋਂ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇੱਕ ਗਣਨਾ ਮੁੜ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "'AnaLee' — || ਖਾਲੀ ਥਾਵਾਂ ਨੂੰ ਸੁਰੱਖਿਤ ਕੀਤੇ ਬਿਨਾ ਜੋੜਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "'Ana Lee' — || ਮਾਨ SQL ਸਟ੍ਰਿੰਗ ਸੰਯੋਜਨ ਓਪਰੇਟਰ ਹੈ"
            }
          ]
        },
        {
          "question": "ਇਨ੍ਹਾਂ ਵਿੱਚੋਂ ਕਿਹੜਾ ਬਿਲਕੁਲ WHERE status IN ('open', 'pending', 'review') ਦੇ ਬਰਾਬਰ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "WHERE status = 'open' AND status = 'pending' AND status = 'review'"
            },
            {
              "icon": "",
              "label": "WHERE status != 'open' OR status != 'pending' OR status != 'review'"
            },
            {
              "icon": "",
              "label": "WHERE status = 'open' OR status = 'pending' OR status = 'review'"
            },
            {
              "icon": "",
              "label": "WHERE status LIKE 'open,pending,review'"
            }
          ]
        },
        {
          "question": "customers ਵਿੱਚ 100 ਪੰਕਤੀਆਂ ਹਨ; ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ 20 ਨੇ ਕਦੇ ਆਰਡਰ ਨਹੀਂ ਲਗਾਇਆ। ਤੁਸੀਂ SELECT c.id FROM customers c INNER JOIN orders o ON c.id = o.customer_id ਚਲਾਓ। ਕੀ ਆਰਡਰ ਨਹੀਂ ਕਰਨ ਵਾਲੇ 20 ਗ੍ਰਾਹਕ ਨਤੀਜੇ ਵਿੱਚ ਹਨ?",
          "options": [
            {
              "icon": "",
              "label": "ਹਾਂ, ਹਰੇਕ ਇੱਕ ਵਾਰ, o.id ਨੂੰ NULL ਦੇ ਤੌਰ ਤੇ ਦਿਖਾਇਆ"
            },
            {
              "icon": "",
              "label": "ਹਾਂ, ਪਰ ਸਿਰਫ ਜਿਸ ਵਿੱਚ ਉਹ WHERE ਖੰਡ ਵਿੱਚ ਵੀ ਪ੍ਰਗਟ ਹੋਣ"
            },
            {
              "icon": "",
              "label": "ਨਹੀਂ — INNER JOIN ਸਿਰਫ ਉਹ ਪੰਕਤੀਆਂ ਮੁੜ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਦਾ ਦੋਨਾਂ ਟੇਬਲਾਂ ਵਿੱਚ ਮੇਲ ਹੈ, ਇਸ ਲਈ ਜ਼ੀਰੋ ਆਰਡਰ ਵਾਲੇ ਗ੍ਰਾਹਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਛੱਡੇ ਜਾਂਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "ਹਾਂ, ਹਰ ਕਾਲਮ ਲਈ ਇੱਕ ਵਾਰ ਡਰਿਬ ਕੀਤਾ"
            }
          ]
        },
        {
          "question": "ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਹਰ ਗ੍ਰਾਹਕ ਭਾਵੇਂ ਉਨ੍ਹਾਂ ਕੋਲ ਆਰਡਰ ਹੋਣ ਜਾ ਨਾ, ਇਸ ਲਈ ਤੁਸੀਂ SELECT c.id, o.total FROM customers c LEFT JOIN orders o ON c.id = o.customer_id WHERE o.total > 100 ਲਿਖਦੇ ਹੋ। ਕੀ ਇਹ ਅਜੇ ਜ਼ੀਰੋ ਆਰਡਰ ਵਾਲੇ ਗ੍ਰਾਹਕ ਮੁੜ ਕਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਨਹੀਂ — WHERE ਖੰਡ ਵਿੱਚ o.total ਉੱਤੇ ਫਿਲਟਰ NULL ਪੰਕਤੀਆਂ ਛੱਡ ਦਿੰਦਾ ਹੈ ਜੋ LEFT JOIN ਨੇ ਹਨ ਕਰੇ ਗ੍ਰਾਹਕਾਂ ਲਈ ਬਣਾਈਆਂ, ਇਸ ਲਈ ਇਹ INNER JOIN ਵਾਂਗ ਵਿਹਾਰ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਹਾਂ — LEFT JOIN ਹਮੇਸ਼ਾ customers ਤੋਂ ਹਰ ਪੰਕਤੀ ਸੁਰੱਖਿਤ ਰੱਖਦਾ ਹੈ ਕੁਝ ਵੀ ਬਾਅਦ ਵਿੱਚ ਆਵੇ"
            },
            {
              "icon": "",
              "label": "ਹਾਂ, o.total ਨੂੰ ਆਰਡਰ ਨਾ ਕਰਨ ਵਾਲੇ ਗ੍ਰਾਹਕਾਂ ਲਈ 0 ਦੇ ਤੌਰ ਤੇ ਦਿਖਾਇਆ"
            },
            {
              "icon": "",
              "label": "ਨਹੀਂ — LEFT JOIN ਖੁਦ ਨੂੰ RIGHT JOIN ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ ਜਦੋਂ WHERE ਖੰਡ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "ਇੱਕ employees ਟੇਬਲ ਵਿੱਚ id ਕਾਲਮ ਅਤੇ manager_id ਕਾਲਮ ਹੈ ਜੋ ਹੋਰ ਪੰਕਤੀ ਦੀ id ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦਾ ਹੈ। ਹਰ ਕਰਮਚਾਰੀ ਨੂੰ ਉਨ੍ਹਾਂ ਦੇ ਮਨੈਜਰ ਦੇ ਨਾਮ ਦੇ ਨਾਲ ਲਿਸਟ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਟੇਬਲ ਨੂੰ ਆਪਣੇ ਆਪ ਨਾਲ ਜੋੜਦੇ ਹੋ: SELECT e.name, m.name FROM employees e JOIN employees m ON e.manager_id = m.id। ਇਸ ਪੈਟਰਨ ਨੂੰ ਕੀ ਕਹਿੰਦੇ ਹਨ?",
          "options": [
            {
              "icon": "",
              "label": "ਇੱਕ cross join — ਹਰ ਕਰਮਚਾਰੀ ਹਰ ਮਨੈਜਰ ਨਾਲ ਮੇਲ ਖਾਇਆ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ recursive join — ਇਹ ਪੂਰੀ ਪ੍ਰਬੰਧਕ ਚੇਨ ਲਿਆਉਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ self-join — ਉਹੀ ਟੇਬਲ ਦੋ ਵੱਖ-ਵੱਖ aliases ਦੀ ਵਰਤੋਂ ਨਾਲ ਆਪਣੇ ਆਪ ਜੁੜਿਆ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਅਮਾਨ SQL ਹੈ — ਇੱਕ ਟੇਬਲ ਆਪਣੇ ਆਪ ਨਾਲ ਨਹੀਂ ਜੋੜੀ ਜਾ ਸਕਦੀ"
            }
          ]
        },
        {
          "question": "ਦੋ SELECT ਪ੍ਰਸ਼ਨ ਉਸੇ ਕਾਲਮ ਨਾਲ UNION ਨਾਲ ਮਿਲਾਏ ਜਾਂਦੇ ਹਨ। ਜੇ ਦੋਵੇਂ ਇੱਕੋ ਪੰਕਤੀ ਮੁੜ ਕਰਦੇ ਹਨ, ਤਾਂ ਆਖਰੀ ਨਤੀਜੇ ਵਿੱਚ ਉਸ ਪੰਕਤੀ ਦੀਆਂ ਕਿੰਨੀਆਂ ਕਾਪੀਆਂ ਹਨ?",
          "options": [
            {
              "icon": "",
              "label": "ਇੱਕ — UNION ਮਿਲਾਏ ਗਏ ਨਤੀਜੇ ਤੋਂ ਡਬਲ ਪੰਕਤੀਆਂ ਹਟਾ ਦਿੰਦਾ ਹੈ; UNION ALL ਦੋਵਾਂ ਕਾਪੀਆਂ ਰੱਖਦਾ ਤੁਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਦੋ — UNION ਦੋਵਾਂ ਪ੍ਰਸ਼ਨਾਂ ਤੋਂ ਹਰ ਪੰਕਤੀ ਰੱਖਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਜ਼ੀਰੋ — UNION ਕਿਸੇ ਵੀ ਪੰਕਤੀ ਹਟਾ ਦਿੰਦਾ ਹੈ ਜੋ ਦੋਵਾਂ ਪ੍ਰਸ਼ਨਾਂ ਵਿੱਚ ਆਉਂਦੀ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜਾ ਪ੍ਰਸ਼ਨ ਪੰਕਤੀ ਪਹਿਲਾ ਲਿਸਟ ਕਰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "ਟੇਬਲ sizes ਵਿੱਚ 3 ਪੰਕਤੀਆਂ ਅਤੇ colors ਵਿੱਚ 4 ਪੰਕਤੀਆਂ ਹਨ। SELECT * FROM sizes CROSS JOIN colors ਕਿੰਨੀਆਂ ਪੰਕਤੀਆਂ ਮੁੜ ਕਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "7 — CROSS JOIN ਪੰਕਤੀ ਮਾਤਰਾਵਾਂ ਨੂੰ ਇਕੱਠਾ ਜੋੜ ਦਿੰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "12 — ਇੱਕ CROSS JOIN ਦੋਵਾਂ ਟੇਬਲਾਂ ਤੋਂ ਪੰਕਤੀਆਂ ਦਾ ਹਰ ਸੰਭਵ ਸੁਮੇਲ ਮੁੜ ਕਰਦਾ ਹੈ (3 x 4)"
            },
            {
              "icon": "",
              "label": "3 — CROSS JOIN ਪਹਿਲੀ ਟੇਬਲ ਵਿੱਚ ਹਰ ਪੰਕਤੀ ਲਈ ਇੱਕ ਪੰਕਤੀ ਮੁੜ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "0 — CROSS JOIN ਨੂੰ ਇੱਕ ON ਸ਼ਰਤ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਜਾ ਇਹ ਕੁਝ ਨਹੀਂ ਮੁੜ ਕਰਦਾ"
            }
          ]
        },
        {
          "question": "orders ਵਿੱਚ order #100 ਲਈ 1 ਪੰਕਤੀ ਹੈ, ਅਤੇ order_items ਵਿੱਚ order #100 ਲਈ 3 ਪੰਕਤੀਆਂ ਹਨ (ਹਰ ਲਾਈਨ ਆਈਟਮ ਲਈ ਇੱਕ)। ਤੁਸੀਂ SELECT o.id, o.total FROM orders o JOIN order_items i ON o.id = i.order_id WHERE o.id = 100 ਚਲਾਓ। order #100 ਲਈ ਕਿੰਨੀਆਂ ਪੰਕਤੀਆਂ ਵਾਪਸ ਆਉਂਦੀਆਂ ਹਨ?",
          "options": [
            {
              "icon": "",
              "label": "3 — join ਹਰ ਮੇਲ ਖਾਣ ਵਾਲੀ order_items ਪੰਕਤੀ ਲਈ ਇੱਕ ਆਉਟਪੁਟ ਪੰਕਤੀ ਬਣਾਉਂਦੀ ਹੈ, ਇਸ ਲਈ order #100 ਦੀ ਇੱਕਲੌਤੀ ਪੰਕਤੀ ਹਰ ਲਾਈਨ ਆਈਟਮ ਲਈ ਇੱਕ ਵਾਰ ਦੁਹਰਾਈ ਜਾਂਦੀ ਹੈ"
            },
            {
              "icon": "",
              "label": "1 — orders ਵਿੱਚ order #100 ਲਈ ਸਿਰਫ ਇੱਕ ਪੰਕਤੀ ਹੈ, ਇਸ ਲਈ join ਵਧੀ ਪੈਦਾ ਨਹੀਂ ਕਰ ਸਕਦਾ"
            },
            {
              "icon": "",
              "label": "4 — ਆਰਡਰ ਲਈ ਇੱਕ ਪੰਕਤੀ ਜਮ੍ਹਾ ਹਰ ਲਾਈਨ ਆਈਟਮ ਲਈ ਇੱਕ"
            },
            {
              "icon": "",
              "label": "0 — ਇੱਕ-ਪੰਕਤੀ ਟੇਬਲ ਨੂੰ ਗੈਰ-ਅਨੌਖੇ ਚਾਬੀ 'ਤੇ ਤਿੰਨ-ਪੰਕਤੀ ਟੇਬਲ ਨਾਲ ਜੋੜਨਾ ਅਸਫਲ ਹੁੰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "SELECT c.name, o.id FROM customers c RIGHT JOIN orders o ON c.id = o.customer_id ਇਨ੍ਹਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਦੇ ਜਿੰਨੀਆਂ ਪੰਕਤੀਆਂ ਮੁੜ ਕਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "SELECT c.name, o.id FROM customers c INNER JOIN orders o ON c.id = o.customer_id"
            },
            {
              "icon": "",
              "label": "SELECT c.name, o.id FROM orders o LEFT JOIN customers c ON c.id = o.customer_id — ਟੇਬਲ ਕ੍ਰਮ ਸਵੈਪ ਕਰਨਾ ਅਤੇ RIGHT JOIN ਦੀ ਜਗ੍ਹਾ LEFT JOIN ਵਰਤਨਾ ਬਰਾਬਰ ਹੈ"
            },
            {
              "icon": "",
              "label": "SELECT c.name, o.id FROM customers c LEFT JOIN orders o ON c.id = o.customer_id"
            },
            {
              "icon": "",
              "label": "SELECT c.name, o.id FROM orders o CROSS JOIN customers c"
            }
          ]
        },
        {
          "question": "ਮਾਨ SQL ਵਿੱਚ, ਤੁਸੀਂ SELECT department, name, AVG(salary) FROM employees GROUP BY department ਚਲਾਓ। ਕੀ ਇਹ ਇੱਕ ਮਾਨ ਪ੍ਰਸ਼ਨ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਹਾਂ — GROUP BY ਨੂੰ ਸਿਰਫ ਵਿਭਾਗ ਸ਼ਾਮਲ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿਉਂਕਿ ਇਹ ਪਹਿਲਾ ਸੂਚੀਬੱਧ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਨਹੀਂ — ਨਾਮ ਚੁਨਿਆ ਜਾਂਦਾ ਹੈ ਪਰ ਨਾ ਤੋ ਸਮਰੱਥਾ ਅਤੇ ਨਾ ਹੀ GROUP BY ਵਿੱਚ ਸੂਚੀਬੱਧ, ਅਤੇ ਮਾਨ SQL ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਹਰ ਗੈਰ-ਸਮਰੱਥਾ ਚੁਨੀ ਹੋਈ ਕਾਲਮ GROUP BY ਖੰਡ ਵਿੱਚ ਵਿਖਾਈ ਦੇਵੇ"
            },
            {
              "icon": "",
              "label": "ਹਾਂ — SQL ਆਪ ਆਪ ਹਰ ਵਿਭਾਗ ਲਈ ਇੱਕ ਆਪਹੁੰਦੀ ਨਾਮ ਚੁਣਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਨਹੀਂ — AVG() ਨੂੰ ਇੱਕੋ ਪ੍ਰਸ਼ਨ ਵਿੱਚ GROUP BY ਨਾਲ ਸੰਯੁਕਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ"
            }
          ]
        },
        {
          "question": "ਤੁਸੀਂ ਉਹ ਵਿਭਾਗ ਚਾਹੁੰਦੇ ਹੋ ਜਿਨ੍ਹਾਂ ਦੀ ਔਸਤ ਤਨਖ਼ਾਹ 80000 ਤੋਂ ਵੱਧ ਹੋ। ਕਿਹੜਾ ਖੰਡ ਸਮਰੱਥਾ AVG(salary) ਜਿਵੇਂ ਮੁੱਲ 'ਤੇ ਗਰੁਪਿੰਗ ਬਾਅਦ ਫਿਲਟਰ ਕਰਦਾ ਹੈ — WHERE ਜਾ HAVING?",
          "options": [
            {
              "icon": "",
              "label": "WHERE — HAVING ਸਿਰਫ UNION ਪ੍ਰਸ਼ਨਾਂ ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਕੋਈ ਵੀ ਸਮਰੱਥ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਇਕਸਾਰ ਕੰਮ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਕੋਈ ਨਹੀਂ — ਸਮਰੱਥ ਫਿਲਟਰਿੰਗ ਨੂੰ ਇੱਕ ਉਪ-ਪ੍ਰਸ਼ਨ ਜ਼ਰੂਰੀ ਹੈ"
            },
            {
              "icon": "",
              "label": "HAVING — WHERE ਗਰੁਪਿੰਗ ਤੋਂ ਪਹਿਲਾਂ ਵੱਖਰੀ ਪੰਕਤੀਆਂ ਫਿਲਟਰ ਕਰਦਾ ਹੈ, HAVING ਸਮਰੱਥਾ ਬਾਅਦ ਸਮੂਹਾਂ ਫਿਲਟਰ ਕਰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "ਤੁਸੀਂ SELECT salary * 1.1 AS new_salary FROM employees WHERE new_salary > 50000 ਲਿਖਦੇ ਹੋ। ਕੀ ਇਹ ਚਲਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਹਾਂ — SELECT ਵਿੱਚ ਪ੍ਰਭਾਸ਼ਿਤ aliases ਹਮੇਸ਼ਾ ਇੱਕੋ ਪ੍ਰਸ਼ਨ ਵਿੱਚ WHERE ਲਈ ਉਪਲਬਧ ਹੁੰਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "ਹਾਂ, ਪਰ ਸਿਰਫ ਸੰਖਿਆਤਮਕ aliases ਲਈ"
            },
            {
              "icon": "",
              "label": "ਨਹੀਂ — AS ਨੂੰ ਇੱਕ WHERE-ਫਿਲਟਰ ਕੀਤੇ ਪ੍ਰਸ਼ਨ ਵਿੱਚ ਆਗਿਆ ਨਹੀਂ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਨਹੀਂ — WHERE ਨੂੰ ਮੁਲਾਂਕਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਪਹਿਲਾਂ SELECT ਨਾਮ alias new_salary ਨੂੰ ਜਿਆਈ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ alias ਉਸ ਸਮੇ ਤੇ ਅਜੇ ਮੌਜੂਦ ਨਹੀਂ ਹੈ"
            }
          ]
        },
        {
          "question": "SELECT name FROM employees e WHERE salary > (SELECT AVG(salary) FROM employees WHERE department = e.department)। ਇਹ ਇੱਕ ਸਹਿ-ਸੰਬੰਧਿਤ ਪ੍ਰਸ਼ਨ ਕਿਉਂ ਕਹਿੰਦੇ ਹਨ?",
          "options": [
            {
              "icon": "",
              "label": "ਕਿਉਂਕਿ ਇਹ WHERE ਖੰਡ ਦੀ ਜਗ੍ਹਾ ਇੱਕ JOIN ਵਰਤਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਅਂਦਰਲਾ ਪ੍ਰਸ਼ਨ ਬਾਹਰਲੇ ਤੋਂ e.department ਦਾ ਹਵਾਲਾ ਦਿੰਦਾ ਹੈ, ਇਸ ਲਈ ਇਸ ਨੂੰ ਬਾਹਰਲੇ ਦੁਆਰਾ ਵਿਚਾਰੀ ਹਰ ਪੰਕਤੀ ਲਈ ਮੁੜ-ਮੁਲਾਂਕਨ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਤੋਂ ਵੱਧ ਕਾਲਮ ਮੁੜ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਕਿਉਂਕਿ ਇਹ ਬਿਲਕੁਲ ਇੱਕ ਵਾਰ ਬਾਹਰਲੇ ਸ਼ੁਰੂ ਤੋਂ ਪਹਿਲਾਂ ਚਲਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "ਇੱਕ ਪ੍ਰਸ਼ਨ SELECT manager_id FROM employees ਕੁਝ NULL ਮੁੱਲ ਜਮ੍ਹਾ ਸਚੇ ids ਮੁੜ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ SELECT name FROM employees WHERE id NOT IN (SELECT manager_id FROM employees) ਚਲਾਓ। ਕੀ ਹੁੰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਇਹ ਹਰ ਕਰਮਚਾਰੀ ਮੁੜ ਕਰਦਾ ਹੈ ਜੋ ਪ੍ਰਬੰਧਕ ਨਹੀਂ, NULL ਅਲਮਸ ਕਰਦੇ ਹੋਏ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਜ਼ੀਰੋ ਪੰਕਤੀਆਂ ਮੁੜ ਕਰਦਾ ਹੈ — NOT IN ਸੂਚੀ ਵਿੱਚ ਇੱਕ ਸਿੰਗਲ NULL ਹਰ ਤੁਲਨਾ ਨੂੰ UNKNOWN ਬਣਾ ਦਿੰਦਾ ਹੈ, ਇਸ ਲਈ ਕੋਈ ਪੰਕਤੀ ਸ਼ਰਤ ਪੂਰੀ ਨਹੀਂ ਕਰ ਸਕਦੀ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਇੱਕ ਗਲਤੀ ਬਾਲਦਾ ਹੈ ਕਿਉਂਕਿ NOT IN ਨੂੰ ਪ੍ਰਸ਼ਨਾਂ ਨਾਲ ਵਰਤਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਹਰ ਕਰਮਚਾਰੀ ਮੁੜ ਕਰਦਾ ਹੈ, ਕਿਉਂਕਿ NULL ਨੂੰ ਵਾਇਲਡਕਾਰਡ ਦੇ ਤੌਰ ਤੇ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "SELECT name FROM customers c WHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id)। ਇਹ ਕੀ ਮੁੜ ਕਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਹਰ ਗ੍ਰਾਹਕ ਜਿਸ ਕੋਲ orders ਵਿੱਚ ਘੱਟੋ ਘੱਟ ਇੱਕ ਪੰਕਤੀ ਹੈ — EXISTS ਸਿਰਫ ਦੇਖਦਾ ਹੈ ਕੀ ਪ੍ਰਸ਼ਨ ਕਿਸੇ ਪੰਕਤੀ ਮੁੜ ਕਰਦਾ ਹੈ, ਉਸ ਵਿੱਚ ਮੁੱਲ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "ਹਰ ਗ੍ਰਾਹਕ, ਕਿਉਂਕਿ SELECT 1 ਹਮੇਸ਼ਾ ਸਚ ਮੁੜ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ ਗਲਤੀ, ਕਿਉਂਕਿ ਸਬਕਿਊਰੀ ਇੱਕ ਕਾਲਮ ਨਾਮ ਦੀ ਬਜਾਏ ਇੱਕ ਸੰਖਿਆ ਚੁਣਦੀ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ਼ ਉਹ ਗ੍ਰਾਹਕ ਜਿਨ੍ਹਾਂ ਕੋਲ ਬਿਲਕੁਲ ਇੱਕ order ਹੈ"
            }
          ]
        },
        {
          "question": "ਤੁਸੀਂ SELECT name, (SELECT order_id FROM orders WHERE customer_id = c.id) AS last_order FROM customers c ਲਿਖਦੇ ਹੋ, ਅਤੇ ਇੱਕ ਦਿੱਤਾ ਗਿਆ ਗ੍ਰਾਹਕ orders ਵਿੱਚ 3 ਕਤਾਰਾਂ ਰਖਦਾ ਹੈ। ਜਦੋਂ ਇਹ ਕਿਊਰੀ ਚੱਲਦੀ ਹੈ ਤਾਂ ਕੀ ਵਾਪਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਇਹ ਪਹਿਲੀ ਮਿਲਦੀ order_id ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ ਅਤੇ ਬਾਕੀ ਦੋ ਨੂੰ ਚੁੱਪ ਚਾਪ ਅਲੋਪ ਕਰ ਦਿੰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਤਿੰਨੋਂ order_ids ਦੀ ਕਾਮਾ-ਵੱਖਰੀ ਕੀਮਤ ਵਾਪਸ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਉਸ ਗ੍ਰਾਹਕ ਲਈ 3 ਕਤਾਰਾਂ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਹਰੇਕ order ਲਈ ਇੱਕ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਰਨਟਾਈਮ 'ਤੇ ਇੱਕ ਗਲਤੀ ਜਾਰੀ ਕਰਦਾ ਹੈ — SELECT ਲਿਸਟ ਵਿੱਚ ਇੱਕ scalar subquery ਵੱਧ ਤੋਂ ਵੱਧ ਇੱਕ ਕਤਾਰ ਵਾਪਸ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਇਹ ਤਿੰਨ ਵਾਪਸ ਕਰਦੀ ਹੈ"
            }
          ]
        },
        {
          "question": "ਚਾਰ ਕਤਾਰਾਂ ਸਭ ਸਮਾਨ ਹਨ ਸਭ ਤੋਂ ਉੱਚੇ ਸਕੋਰ ਲਈ। RANK() ORDER BY score DESC ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਸਾਰੀਆਂ ਚਾਰ ਨੂੰ rank 1 ਮਿਲਦਾ ਹੈ। ਅਗਲੀ ਕਤਾਰ ਖੰਡ ਨੂੰ ਕਿਹੜਾ rank ਮਿਲਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "5 — RANK() ਬੰਨ੍ਹੀ ਹੋਈ ਕਤਾਰਾਂ ਦੀ ਸੰਖਿਆ ਦੇ ਬਰਾਬਰ ਇੱਕ ਖਾਲੀ ਥਾਂ ਛੱਡ ਕੇ ਜਾਰੀ ਰਖਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "2 — RANK() ਹਮੇਸ਼ਾ ਕਿਸੇ ਬੀ ਬੰਨ੍ਹੇ ਤੋਂ ਬਾਅਦ ਬਿਲਕੁਲ ਇੱਕ ਸ ਵਧਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "1 — ਹਰ ਅਗਲੀ ਕਤਾਰ ਨੂੰ ਵੀ rank 1 ਮਿਲਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "4 — RANK() ਬੀਸ ਦੀ ਸੰਖਿਆ ਤੋਂ ਮੁੜ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "ਚਾਰ ਕਤਾਰਾਂ ਸਭ ਸਮਾਨ ਹਨ ਸਭ ਤੋਂ ਉੱਚੇ ਸਕੋਰ ਲਈ। DENSE_RANK() ORDER BY score DESC ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਸਾਰੀਆਂ ਚਾਰ ਨੂੰ rank 1 ਮਿਲਦਾ ਹੈ। ਅਗਲੀ ਕਤਾਰ ਖੰਡ ਨੂੰ ਕਿਹੜਾ rank ਮਿਲਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "5 — DENSE_RANK() ਬਿਲਕੁਲ RANK() ਵਰਗਾ ਕੰਮ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "1 — DENSE_RANK() ਹਰ ਬਾਕੀ ਕਤਾਰ ਨੂੰ ਇਹੀ rank ਤਫ਼ਾ ਦਿੰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "2 — DENSE_RANK() ਕਦੇ ਖਾਲੀ ਥਾਂ ਨਹੀਂ ਛੱਡਦਾ, ਇਸ ਲਈ ਅਗਲੀ ਵਿਲੱਖਣ ਮੁੱਲ ਹਮੇਸ਼ਾ ਅਗਲਾ ਲਗਾਤਾਰ rank ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ"
            },
            {
              "icon": "",
              "label": "3 — DENSE_RANK() ਹਰ ਟਾਈ ਗਰੁੱਪ ਲਈ ਇੱਕ rank ਛੱਡ ਦਿੰਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "SUM(amount) OVER (PARTITION BY region ORDER BY amount) ਇੱਕ ਕਿਊਰੀ ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ। PARTITION BY region ਇੱਥੇ ਕੀ ਕਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਇਹ ਚਲਦੀ ਜੋੜ ਨੂੰ ਹਰ region ਲਈ ਵੱਖ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਪੂਰੇ ਨਤੀਜੇ ਸੈੱਟ ਤੋਂ ਇਕੱਠਾ ਜਮ੍ਹਾ ਕਰਨ ਦੀ ਬਜਾਏ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਨਤਾਇਜ ਨੂੰ ਇੱਕ ਤੋਂ ਫਿਲ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਕਤਾਰਾਂ ਨੂੰ GROUP BY ਵਰਗੀ ਹਰ region ਨੂੰ ਇੱਕ ਵਿੱਚ ਗਰੁੱਪ ਅਤੇ ਸਮੀਪ ਕਰਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਜਮ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ regions ਨੂੰ ਵਰਣ-ਬਾਂਕ ਅਨੁਸਾਰ ਛਾਂਟਦਾ ਹੈ"
            }
          ]
        },
        {
          "question": "ROW_NUMBER() OVER (ORDER BY score DESC) ਪੰਜ ਕਤਾਰਾਂ ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਦੋ ਬਿਲਕੁਲ score ਵਿੱਚ ਬੰਨ੍ਹੇ ਹੋਏ ਹਨ। ਕੀ ਦੋ ਕਤਾਰਾਂ ਕਦੇ ਇੱਕੋ row number ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੀਆਂ ਹਨ?",
          "options": [
            {
              "icon": "",
              "label": "ਜੀ — ਬੰਨ੍ਹੀ ਹੋਈ ਕਤਾਰਾਂ ਹਮੇਸ਼ਾ ਇੱਕੋ row number ਸ਼ੇਅਰ ਕਰਦੀਆਂ ਹਨ"
            },
            {
              "icon": "",
              "label": "ਸਿਰਫ਼ ਜੇ PARTITION BY ਵੀ ਵਰਤਿਆ ਜਾਵੇ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਟਾਈ ਪਹਿਲੀ ਜਾਂ ਆਖਰੀ ਸਥਾਨ ਵਿੱਚ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਨਹੀਂ — ROW_NUMBER() ਹਮੇਸ਼ਾ ਹਰ ਕਤਾਰ ਨੂੰ ਇੱਕ ਵਿਲੱਖਣ, ਸਖਤੀ ਨਾਲ ਵਧਦਾ ਹੋਇਆ ਪੂਰਨ ਅੰਕ ਤਫ਼ਾ ਕਰਦਾ ਹੈ, ਭਾਵੇਂ ਮੁੱਲ ਬੰਨ੍ਹੇ ਹੋਏ ਹਨ"
            }
          ]
        },
        {
          "question": "WITH high_earners AS (SELECT * FROM employees WHERE salary > 100000) SELECT department, COUNT(*) FROM high_earners GROUP BY department। high_earners ਕੀ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਇੱਕ common table expression (CTE) — ਇੱਕ ਨਾਮ ਵਾਲਾ, ਅਸਥਾਈ ਨਤੀਜਾ ਸੈਟ ਜਿਸ ਨੂੰ ਬਾਕੀ ਕਿਊਰੀ ਇੱਕ ਟੇਬਲ ਵਾਂਗ ਹਵਾਲਾ ਦੇ ਸਕਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਡਾਟਾਬੇਸ ਵਿੱਚ ਬਣਾਈ ਗਈ ਇੱਕ ਸਥਾਈ ਟੇਬਲ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ view ਜੋ ਕਿ ਕਿਊਰੀ ਖ਼ਤਮ ਹੋਣ ਤੋਂ ਬਾਅਦ ਬਚਿ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇੱਕ stored procedure ਜਿਸ ਨੂੰ ਵੱਖ ਕਾਲ ਕਰਨਾ ਲਾਜ਼ਮੀ ਹੈ"
            }
          ]
        },
        {
          "question": "ਇੱਕ ਕਾਲਮ PRIMARY KEY ਦੇ ਤੌਰ 'ਤੇ ਘੋਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਕੀ ਤੁਸੀਂ ਜਿਥੇ ਉਹ ਕਾਲਮ NULL ਹੈ ਇੱਕ ਕਤਾਰ ਸੰਮਿਲਿਤ ਕਰ ਸਕਦੇ ਹੋ?",
          "options": [
            {
              "icon": "",
              "label": "ਜੀ — PRIMARY KEY ਸਿਰਫ਼ ਵਿਲੱਖਣਤਾ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ, NULL-ਨੱਸ ਨਹੀਂ"
            },
            {
              "icon": "",
              "label": "ਜੀ, ਪਰ ਸਿਰਫ਼ ਇੱਕ NULL ਕਤਾਰ ਨੂੰ ਮਨਜ਼ੂਰੀ ਹੈ, ਇੱਕ UNIQUE constraint ਵਾਂਗ"
            },
            {
              "icon": "",
              "label": "ਨਹੀਂ — ਇੱਕ PRIMARY KEY ਕਾਲਮ ਨਿਸ਼ਚਤ NULL ਹੈ, ਇਸ ਲਈ ਇਸ ਵਿੱਚ NULL ਸੰਮਿਲਿਤ ਕਰਨਾ ਰੱਦ ਕੀਤਾ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਾਲਮ ਕੋਲ ਇੱਕ ਮੂਲ ਮੁੱਲ ਵੀ ਹੈ"
            }
          ]
        },
        {
          "question": "ਇੱਕ ਖੁੱਲੀ transaction ਦੇ ਅੰਦਰ, ਤੁਸੀਂ ਇੱਕ UPDATE ਚਲਾਅ ਦੇ ਹੋ ਪਰ ਅਜ਼ ਤੱਕ COMMIT ਨਹੀਂ ਚਲਾਇਆ ਹੈ। ਡਾਟਾਬੇਸ ਦੇ ਲਈ ਇੱਕ ਦੂਸਰੀ, ਵੱਖ connection ਤੋਂ, ਕੀ ਉਸ ਅਪਡੇਟ ਨੂੰ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "ਜੀ — ਸਾਰੀ connections ਹਰ ਲਿਖਣ ਨੂੰ ਤੁਰੰਤ ਦੇਖਦੀਆਂ ਹਨ ਜਦੋਂ ਇਹ ਚਲਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "ਜੀ, ਪਰ ਸਿਰਫ਼ ਜੇ ਦੂਸਰੀ connection ਵੀ ਇੱਕ transaction ਖੋਲੇ"
            },
            {
              "icon": "",
              "label": "ਇਹ ਸਿਰਫ਼ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਟੇਬਲ ਅਪਡੇਟ ਕੀਤੀ ਗਈ ਸੀ"
            },
            {
              "icon": "",
              "label": "ਨਹੀਂ — ਇੱਕ uncommitted ਤਬਦੀਲੀ ਸਿਰਫ਼ ਉਸ transaction ਦੇ ਅੰਦਰ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ ਜਿਸ ਨੇ ਇਸ ਨੂੰ ਬਣਾਇਆ ਹੈ, ਜਦ ਤੱਕ COMMIT ਇਸ ਨੂੰ ਟਿਕਾਊ ਨਹੀਂ ਬਣਾ ਦਿੰਦਾ ਅਤੇ ਦੂਸਰਿਆਂ ਲਈ ਦਿਸਣ ਯੋਗ ਨਹੀਂ ਬਣਾ ਦਿੰਦਾ"
            }
          ]
        },
        {
          "question": "products.category_id ਦੇ ਕੋਲ ਇੱਕ FOREIGN KEY constraint ਹੈ ਜੋ categories.id ਨੂੰ ਹਵਾਲਾ ਦਿੰਦਾ ਹੈ। ਤੁਸੀਂ categories ਤੋਂ ਇੱਕ ਅਜਿਹੀ ਕਤਾਰ DELETE ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹੋ ਜਿਸ ਵੱਲ ਅਜੇ ਵੀ products ਇਸ਼ਾਰਾ ਕਰ ਰਹੇ ਹਨ, ਅਤੇ ਕੋਈ ON DELETE ਨਿਯਮ ਨਿਰਧਾਰਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ। ਕੀ ਵਾਪਰਦਾ ਹੈ?",
          "options": [
            {
              "icon": "",
              "label": "category ਕਤਾਰ ਨੂੰ ਹਟਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ matching products.category_id ਮੁੱਲ ਆਪਣੇ-ਆਪ NULL ਵਿੱਚ ਸੈਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ"
            },
            {
              "icon": "",
              "label": "category ਕਤਾਰ ਨੂੰ ਹਟਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਹਰ product ਜਿਸ ਨੇ ਇਸ ਨੂੰ ਹਵਾਲਾ ਦਿੱਤਾ ਸੀ ਵੀ ਹਟਾਇਆ ਜਾਂਦਾ ਹੈ"
            },
            {
              "icon": "",
              "label": "DELETE ਨੂੰ ਰੱਦ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ — ਡਿਫਾਲਟ foreign key ਵਿਵਹਾਰ ਕਿਸੇ ਹਵਾਲਾ ਦਿੱਤੀ ਗਈ ਕਤਾਰ ਨੂੰ ਹਟਾਉਣ ਤੋਂ ਰੋਕਦਾ ਹੈ ਜਦੋਂ ਤੱਕ dependent ਕਤਾਰਾਂ ਅਜੇ ਵੀ ਇਸ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰ ਰਹੀਆਂ ਹਨ"
            },
            {
              "icon": "",
              "label": "DELETE ਚੁੱਪ-ਚਾਪ ਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਅਤੇ products ਦੇ category_id ਇੱਕ ਅਜਿਹੇ category ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੇ ਰਹਿ ਜਾਂਦੇ ਹਨ ਜੋ ਹੁਣ ਮੌਜੂਦ ਨਹੀਂ ਹੈ"
            }
          ]
        }
      ],
      "optionOrderVersion": "e0466e547cfd8a45"
    }
  },
  "testNames": {
    "sql-test": "SQL ਟੈਸਟ"
  }
}