{
  "assessmentTests": {
    "sql_test": {
      "name": "SQL ટેસ્ટ",
      "desc": "ફિલ્ટરિંગ, જોઇન્સ, એગ્રિગેશન, સબક્વેરીઝ અને વિન્ડો ફંક્શન્સ પર 30 પરિદ્રશ્ય પ્રશ્નો — જાણો કે શું તમારું SQL નોકરીની જાહેરાતમાં SQL પ્રાવીણ્યના અર્થ સાથે મેળ ખાય છે.",
      "recommendation": "તમારી SQL કૌશલ્ય પ્રોફાઇલ",
      "results": {
        "beginner": {
          "name": "પ્રારંભિક",
          "desc": "તમે એક કાર્યરત SELECT સ્ટેટમેન્ટ લખી શકો છો અને થોડી શરતો પર ફિલ્ટર કરી શકો છો, પરંતુ તમે જે પ્રશ્નો ચૂકી ગયા તે સિન્ટેક્સને બદલે NULL હેન્ડલિંગ અને જોઇન મિકેનિક્સની આસપાસના છે — NULL સાથે કૉલમની સરખામણી કરવા માટે =, LEFT JOIN ખરેખર શું સાચવે છે, BETWEEN ની સીમાઓ કેવી રીતે કાર્ય કરે છે. આમાંથી કંઈપણ ડેટાબેઝમાં ખરાબ હોવા વિશે નથી; આ તે ચોક્કસ નિયમો છે જે લોકો SQL ને ધોરણસર શીખવાને બદલે અજમાયશ અને ભૂલથી શીખ્યા હોય તેમને મુશ્કેલીમાં મૂકે છે. તે કામ પર મહત્વપૂર્ણ છે કારણ કે દરેક એક એવી જગ્યા છે જ્યાં ક્વેરી સંભવિત દેખાતી પરંતુ ખોટી રો કાઉન્ટ પરત કરે છે.",
          "recommendation": "આ ક્રમમાં ત્રણ બાબતોથી શરૂઆત કરો: શા માટે WHERE col = NULL ક્યારેય કંઈપણ સાથે મેળ ખાતું નથી (અને તેના બદલે IS NULL જરૂરી છે), કેવી રીતે INNER JOIN મેળ ન ખાતી રો ને કાઢી નાખે છે જ્યારે LEFT JOIN તેમને રાખે છે, અને BETWEEN માં સમાવિષ્ટ ચોક્કસ સીમાઓ. Mode Analytics નું SQL ટ્યુટોરિયલ અને PostgreSQL દસ્તાવેજીકરણ બંને ચલાવી શકાય તેવા ઉદાહરણો સાથે આ ત્રણેયને આવરી લે છે."
        },
        "intermediate": {
          "name": "મધ્યમ",
          "desc": "તમે રોજિંદા રિપોર્ટિંગ ક્વેરીઝ — જોઇન્સ, GROUP BY, સીધું ફિલ્ટરિંગ — આરામથી સંભાળી શકો છો અને નિયમિત ડેશબોર્ડ અથવા એડ-હોક વિશ્લેષણ કાર્યથી ધીમા નહીં પડો. અહીં અને એડવાન્સ્ડ વચ્ચેનું અંતર મોટે ભાગે એ છે કે જ્યારે ક્લોઝ એકબીજા સાથે ક્રિયાપ્રતિક્રિયા કરે છે ત્યારે શું થાય છે: જોડાયેલા ટેબલ પર એક WHERE ક્લોઝ શાંતિથી LEFT JOIN ને INNER JOIN માં ફેરવી દે છે, એક જોઇન જે એગ્રિગેટ લાગુ થાય તે પહેલાં રો કાઉન્ટને વિસ્તારે છે, એક NOT IN જે શાંતિથી કંઈપણ પરત કરતું નથી કારણ કે એક NULL સબક્વેરીમાં સરકી ગયું છે. આ એવા પ્રકારના બગ્સ છે જે ઝડપી નજરથી પસાર થઈ જાય છે અને ત્યારે જ દેખાય છે જ્યારે કોઈ કુલને બીજા રિપોર્ટ સાથે સરખાવે છે.",
          "recommendation": "દરેક ક્લોઝ એકલા શું કરે છે તેના પર ધ્યાન કેન્દ્રિત કરવાને બદલે ક્લોઝ કેવી રીતે ક્રિયાપ્રતિક્રિયા કરે છે તેના પર ધ્યાન કેન્દ્રિત કરો: LEFT JOIN ના જમણી બાજુના કૉલમ્સ પર WHERE ફિલ્ટરિંગ, એગ્રિગેટ કરતા પહેલા વન-ટુ-મેની જોઇન્સમાંથી રો મલ્ટિપ્લિકેશન, અને NULL ની હાજરીમાં NOT IN શા માટે તૂટી જાય છે (EXISTS સામાન્ય રીતે નથી તૂટતું). પછી HAVING વિરુદ્ધ WHERE, કારણ કે આ વિભાજન એવા લોકોને પણ મુશ્કેલીમાં મૂકે છે જેઓ બંને ક્લોઝને વ્યક્તિગત રીતે જાણે છે."
        },
        "advanced": {
          "name": "એડવાન્સ્ડ",
          "desc": "આ તે સ્તર છે જેનો અર્થ મોટાભાગની નોકરીની જાહેરાતોમાં “મજબૂત SQL” થાય છે. તમે મલ્ટિ-જોઇન ક્વેરી વાંચો છો અને તેને ચલાવતા પહેલા તેના રો કાઉન્ટની આગાહી કરી શકો છો, તમે જાણો છો કે પરિણામ સેટ શા માટે બદલાયો છે, ફક્ત તે બદલાયો છે તેટલું જ નહીં, અને જ્યારે તે સ્પષ્ટ સાધન હોય ત્યારે તમે નેસ્ટેડ સબક્વેરીને બદલે CTE અથવા વિન્ડો ફંક્શનનો ઉપયોગ કરો છો. આ બેન્ડને ટોચથી જે અલગ પાડે છે તે કામની રક્ષણાત્મક બાજુ છે: જ્યારે ટાઈ મહત્વની હોય ત્યારે કયું રેન્કિંગ ફંક્શન વાપરવું તે જાણવું, ટ્રાન્ઝેક્શન સમવર્તી સત્રથી શું અલગ પાડે છે, અને ડેટાબેઝ સ્તરે ખૂટતો ON DELETE નિયમ ખરેખર શું કરે છે.",
          "recommendation": "એવા ભાગોમાં આગળ વધો જે અન્ય લોકો દ્વારા સ્પર્શાયેલા ડેટાનું રક્ષણ કરે છે: ટાઈ હેઠળ RANK, DENSE_RANK અને ROW_NUMBER વચ્ચેનો તફાવત, COMMIT ખરેખર શું દૃશ્યમાન બનાવે છે અને કોને, અને DELETE પર ફોરેન કીનું વર્તન. બંને માટે આગલા સ્ટોપ તરીકે વિન્ડો ફંક્શન્સ અને ટ્રાન્ઝેક્શન આઇસોલેશન પર Use The Index ન્યૂઝલેટરના અથવા SQL for Devs ના ઊંડાણપૂર્વકના લેખોનો ઉપયોગ કરો."
        },
        "expert": {
          "name": "નિષ્ણાત",
          "desc": "તમે દરેક વિભાગમાં ટોચનો સ્કોર કર્યો છે — ફિલ્ટરિંગ અને NULL સિમેન્ટિક્સ, જોઇન્સ અને સેટ ઓપરેશન્સ, એગ્રિગેશન અને સબક્વેરીઝ, અને વિન્ડો ફંક્શન્સ, CTEs અને કન્સ્ટ્રેઇન્ટ્સ. વ્યવહારિક રીતે, તેનો અર્થ એ છે કે તમને કોઈ અજાણ્યા વ્યક્તિની મલ્ટિ-જોઇન રિપોર્ટ ક્વેરી આપી શકાય છે અને તમે સમજાવી શકો છો કે તે શા માટે તે રો કાઉન્ટ પરત કરે છે, ફક્ત સિન્ટેક્સ શું કહે છે તે નહીં, જે વધુ મુશ્કેલ અને વધુ મૂલ્યવાન કૌશલ્ય છે. આ સ્તરે ક્વેરી ભાષા ભાગ્યે જ મર્યાદિત પરિબળ હોય છે; મર્યાદા સામાન્ય રીતે સ્કીમા ડિઝાઇન અથવા તેની નીચેના ડેટાનું કદ હોય છે.",
          "recommendation": "હવે વળતર એક્ઝેક્યુશન પ્લાન્સ અને ડિઝાઇનમાં છે: ક્વેરી ધીમી છે એમ માની લેતા પહેલા EXPLAIN આઉટપુટ વાંચવું, લખવાના ખર્ચ સામે ટ્રેડઓફ તરીકે ઇન્ડેક્સિંગ વ્યૂહરચના, મફત જીત તરીકે નહીં, અને નોર્મલાઇઝેશનના નિર્ણયો જે સ્કીમા વધે તેમ ટકી રહે છે. જો તમને કોઈ ભૂમિકા માટે સ્ક્રીન કરવામાં આવી રહ્યા હોય, તો SQL ફીચર્સના નામ લેવાને બદલે પ્રોડક્શનમાં તમને મળેલા જોઇન ફેન-આઉટ અથવા NOT IN/NULL ટ્રેપ જેવા ક્વેરી બગનું વર્ણન કરો — તે ફક્ત શબ્દભંડોળ જ નહીં, તર્ક દર્શાવે છે."
        }
      },
      "questions": [
        {
          "question": "એક ટેબલમાં નલેબલ કૉલમ age છે. તમે SELECT * FROM users WHERE age = NULL ચલાવો છો. આ કેટલી રો પરત કરશે, ભલે ઘણી રોમાં age NULL પર સેટ હોય?",
          "options": [
            {
              "icon": "",
              "label": "દરેક રો જ્યાં age NULL છે"
            },
            {
              "icon": "",
              "label": "શૂન્ય રો"
            },
            {
              "icon": "",
              "label": "એક એરર"
            },
            {
              "icon": "",
              "label": "બધી રો"
            }
          ]
        },
        {
          "question": "તમે SELECT DISTINCT department, role FROM employees ચલાવો છો. DISTINCT શેની ડુપ્લિકેટ્સ દૂર કરે છે?",
          "options": [
            {
              "icon": "",
              "label": "department અને role ના દરેક સંયોજનની"
            },
            {
              "icon": "",
              "label": "ફક્ત ડુપ્લિકેટ department વેલ્યુઝની"
            },
            {
              "icon": "",
              "label": "ફક્ત ડુપ્લિકેટ role વેલ્યુઝની"
            },
            {
              "icon": "",
              "label": "કંઈ નહીં; DISTINCT ફક્ત એક જ કૉલમ પર કામ કરે છે"
            }
          ]
        },
        {
          "question": "એક કૉલમ નામ WHERE name LIKE 'A_' સાથે ફિલ્ટર કરવામાં આવ્યું છે. આમાંથી કઈ વેલ્યુ મેળ ખાય છે: 'A', 'Al', 'Ana', 'Ally'?",
          "options": [
            {
              "icon": "",
              "label": "'A'"
            },
            {
              "icon": "",
              "label": "'Al'"
            },
            {
              "icon": "",
              "label": "'Ana' અને 'Ally'"
            },
            {
              "icon": "",
              "label": "બધી ચાર વેલ્યુઝ"
            }
          ]
        },
        {
          "question": "એક પ્રાઇસ કૉલમને WHERE price BETWEEN 10 AND 20 વડે ફિલ્ટર કરવામાં આવે છે. શું બરાબર 10 અથવા બરાબર 20 કિંમતવાળી પંક્તિઓ શામેલ થશે?",
          "options": [
            {
              "icon": "",
              "label": "ના, બંનેને બાકાત રાખવામાં આવશે"
            },
            {
              "icon": "",
              "label": "હા, બંનેનો સમાવેશ કરવામાં આવશે"
            },
            {
              "icon": "",
              "label": "માત્ર price = 10"
            },
            {
              "icon": "",
              "label": "માત્ર price = 20"
            }
          ]
        },
        {
          "question": "એક ટેબલ orders માં 10 પંક્તિઓ છે, અને તેમાંથી 3 માં NULL shipped_date છે. SELECT COUNT(*) FROM orders શું પરત કરશે, અને SELECT COUNT(shipped_date) FROM orders શું પરત કરશે?",
          "options": [
            {
              "icon": "",
              "label": "10, પછી 10"
            },
            {
              "icon": "",
              "label": "7, પછી 7"
            },
            {
              "icon": "",
              "label": "10, પછી 7"
            },
            {
              "icon": "",
              "label": "10, પછી 3"
            }
          ]
        },
        {
          "question": "તમે SELECT name, salary FROM employees ORDER BY 2 DESC ચલાવો છો. અહીં 2 શું દર્શાવે છે?",
          "options": [
            {
              "icon": "",
              "label": "એક સિન્ટેક્સ એરર"
            },
            {
              "icon": "",
              "label": "પરિણામની બીજી પંક્તિ"
            },
            {
              "icon": "",
              "label": "2 નું શાબ્દિક મૂલ્ય, જેનો ઉપયોગ ટાઈબ્રેકર તરીકે થાય છે"
            },
            {
              "icon": "",
              "label": "SELECT લિસ્ટમાં બીજો કૉલમ, salary"
            }
          ]
        },
        {
          "question": "સ્ટાન્ડર્ડ SQL માં, 'Ana' || ' ' || 'Lee' નું મૂલ્યાંકન શું થશે?",
          "options": [
            {
              "icon": "",
              "label": "એક સિન્ટેક્સ એરર"
            },
            {
              "icon": "",
              "label": "TRUE"
            },
            {
              "icon": "",
              "label": "'AnaLee'"
            },
            {
              "icon": "",
              "label": "'Ana Lee'"
            }
          ]
        },
        {
          "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": "No"
            },
            {
              "icon": "",
              "label": "હા, orders માં દરેક કૉલમ દીઠ એકવાર ડુપ્લિકેટ થયેલ"
            }
          ]
        },
        {
          "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": "ના, તે INNER JOIN ની જેમ વર્તે છે"
            },
            {
              "icon": "",
              "label": "હા, LEFT JOIN દરેક ગ્રાહકને રાખે છે"
            },
            {
              "icon": "",
              "label": "હા, જેમાં o.total ને 0 તરીકે દર્શાવવામાં આવે છે"
            },
            {
              "icon": "",
              "label": "ના, તે RIGHT JOIN ની જેમ વર્તે છે"
            }
          ]
        },
        {
          "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": "એક ક્રોસ જોઇન"
            },
            {
              "icon": "",
              "label": "એક રિકર્સિવ જોઇન"
            },
            {
              "icon": "",
              "label": "એક સેલ્ફ-જોઇન"
            },
            {
              "icon": "",
              "label": "એક અમાન્ય ક્વેરી"
            }
          ]
        },
        {
          "question": "સમાન કૉલમવાળી બે SELECT ક્વેરીને UNION સાથે જોડવામાં આવે છે. જો બંને ક્વેરી એક સરખી પંક્તિ પરત કરે, તો અંતિમ પરિણામમાં તે પંક્તિની કેટલી નકલો દેખાશે?",
          "options": [
            {
              "icon": "",
              "label": "એક નકલ"
            },
            {
              "icon": "",
              "label": "બે નકલો"
            },
            {
              "icon": "",
              "label": "શૂન્ય નકલો"
            },
            {
              "icon": "",
              "label": "તે તેના પર નિર્ભર કરે છે કે કઈ ક્વેરી તેને પહેલા સૂચિબદ્ધ કરે છે"
            }
          ]
        },
        {
          "question": "ટેબલ sizes માં 3 પંક્તિઓ છે અને colors માં 4 પંક્તિઓ છે. SELECT * FROM sizes CROSS JOIN colors કેટલી પંક્તિઓ પરત કરશે?",
          "options": [
            {
              "icon": "",
              "label": "7"
            },
            {
              "icon": "",
              "label": "12"
            },
            {
              "icon": "",
              "label": "3"
            },
            {
              "icon": "",
              "label": "0"
            }
          ]
        },
        {
          "question": "orders માં ઓર્ડર #100 માટે 1 પંક્તિ છે, અને order_items માં ઓર્ડર #100 માટે 3 પંક્તિઓ છે (દરેક લાઇન આઇટમ માટે એક). તમે SELECT o.id, o.total FROM orders o JOIN order_items i ON o.id = i.order_id WHERE o.id = 100 ચલાવો છો. ઓર્ડર #100 માટે કેટલી પંક્તિઓ પાછી આવશે?",
          "options": [
            {
              "icon": "",
              "label": "3"
            },
            {
              "icon": "",
              "label": "1"
            },
            {
              "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"
            },
            {
              "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": "હા, department દ્વારા ગ્રુપિંગ કરવું પૂરતું છે"
            },
            {
              "icon": "",
              "label": "ના, name ને એગ્રીગેટ કરવું જોઈએ અથવા GROUP BY માં હોવું જોઈએ"
            },
            {
              "icon": "",
              "label": "હા, SQL દરેક department દીઠ એક name પસંદ કરે છે"
            },
            {
              "icon": "",
              "label": "ના, AVG() નો ઉપયોગ GROUP BY સાથે કરી શકાતો નથી"
            }
          ]
        },
        {
          "question": "તમારે એવા વિભાગો જોઈએ છે જેમનો સરેરાશ પગાર 80000 થી વધુ હોય. ગ્રુપિંગ પછી AVG(salary) જેવા એગ્રીગેટેડ મૂલ્ય પર કયો ક્લોઝ ફિલ્ટર કરે છે — WHERE કે HAVING?",
          "options": [
            {
              "icon": "",
              "label": "WHERE"
            },
            {
              "icon": "",
              "label": "કોઈપણ એક"
            },
            {
              "icon": "",
              "label": "એક પણ નહીં; તેને સબક્વેરીની જરૂર છે"
            },
            {
              "icon": "",
              "label": "HAVING"
            }
          ]
        },
        {
          "question": "તમે SELECT salary * 1.1 AS new_salary FROM employees WHERE new_salary > 50000 લખો છો. શું આ ચાલશે?",
          "options": [
            {
              "icon": "",
              "label": "હા, WHERE SELECT એલિયાસનો ઉપયોગ કરી શકે છે"
            },
            {
              "icon": "",
              "label": "હા, પરંતુ માત્ર ન્યુમેરિક એલિયાસ માટે"
            },
            {
              "icon": "",
              "label": "ના, ફિલ્ટર કરેલી ક્વેરીમાં AS ની મંજૂરી નથી"
            },
            {
              "icon": "",
              "label": "ના, એલિયાસ અસ્તિત્વમાં આવે તે પહેલાં WHERE ચાલે છે"
            }
          ]
        },
        {
          "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 વાસ્તવિક id ની સાથે કેટલાક NULL મૂલ્યો પરત કરે છે. તમે SELECT name FROM employees WHERE id NOT IN (SELECT manager_id FROM employees) ચલાવો છો. શું થાય છે?",
          "options": [
            {
              "icon": "",
              "label": "તે NULL ને અવગણીને દરેક નોન-મેનેજરને પરત કરે છે"
            },
            {
              "icon": "",
              "label": "તે શૂન્ય પંક્તિઓ પરત કરે છે"
            },
            {
              "icon": "",
              "label": "તે એક એરર ઉભી કરે છે"
            },
            {
              "icon": "",
              "label": "તે દરેક કર્મચારીને પરત કરે છે"
            }
          ]
        },
        {
          "question": "SELECT name FROM customers c WHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id). આ શું પરત કરે છે?",
          "options": [
            {
              "icon": "",
              "label": "ઓછામાં ઓછો એક ઓર્ડર ધરાવતા દરેક ગ્રાહક"
            },
            {
              "icon": "",
              "label": "દરેક ગ્રાહક"
            },
            {
              "icon": "",
              "label": "એક એરર"
            },
            {
              "icon": "",
              "label": "માત્ર બરાબર એક ઓર્ડર ધરાવતા ગ્રાહકો"
            }
          ]
        },
        {
          "question": "તમે SELECT name, (SELECT order_id FROM orders WHERE customer_id = c.id) AS last_order FROM customers c લખો છો, અને આપેલ ગ્રાહક પાસે orders માં 3 પંક્તિઓ છે. જ્યારે આ ક્વેરી ચાલે છે ત્યારે શું થાય છે?",
          "options": [
            {
              "icon": "",
              "label": "તે ફક્ત પ્રથમ પરત કરે છે"
            },
            {
              "icon": "",
              "label": "તે ત્રણેયની અલ્પવિરામ-વિભાજિત સૂચિ પરત કરે છે"
            },
            {
              "icon": "",
              "label": "તે 3 પંક્તિઓ પરત કરે છે"
            },
            {
              "icon": "",
              "label": "તે રનટાઇમ પર એરર ઉભી કરે છે"
            }
          ]
        },
        {
          "question": "સૌથી વધુ સ્કોર માટે ચાર પંક્તિઓ ટાઈ થાય છે. RANK() ORDER BY score DESC નો ઉપયોગ કરીને, ચારેયને રેન્ક 1 મળે છે. તે પછીની પંક્તિને કયો રેન્ક મળે છે?",
          "options": [
            {
              "icon": "",
              "label": "5"
            },
            {
              "icon": "",
              "label": "2"
            },
            {
              "icon": "",
              "label": "1"
            },
            {
              "icon": "",
              "label": "4"
            }
          ]
        },
        {
          "question": "સૌથી વધુ સ્કોર માટે ચાર પંક્તિઓ ટાઈ થાય છે. DENSE_RANK() ORDER BY score DESC નો ઉપયોગ કરીને, ચારેયને રેન્ક 1 મળે છે. તે પછીની પંક્તિને કયો રેન્ક મળે છે?",
          "options": [
            {
              "icon": "",
              "label": "5"
            },
            {
              "icon": "",
              "label": "1"
            },
            {
              "icon": "",
              "label": "2"
            },
            {
              "icon": "",
              "label": "3"
            }
          ]
        },
        {
          "question": "SUM(amount) OVER (PARTITION BY region ORDER BY amount) ને ક્વેરીમાં ઉમેરવામાં આવે છે. અહીં PARTITION BY region શું કરે છે?",
          "options": [
            {
              "icon": "",
              "label": "તે દરેક પ્રદેશ માટે ચાલતા સરવાળાને ફરીથી શરૂ કરે છે"
            },
            {
              "icon": "",
              "label": "તે પરિણામોને એક જ પ્રદેશમાં ફિલ્ટર કરે છે"
            },
            {
              "icon": "",
              "label": "તે પંક્તિઓને દરેક પ્રદેશ દીઠ એકમાં સંકુચિત કરે છે"
            },
            {
              "icon": "",
              "label": "તે પ્રદેશોને મૂળાક્ષરોના ક્રમમાં ગોઠવે છે"
            }
          ]
        },
        {
          "question": "ROW_NUMBER() OVER (ORDER BY score DESC) પાંચ પંક્તિઓ પર લાગુ કરવામાં આવે છે, જેમાંથી બે સ્કોરમાં બરાબર ટાઈ થયેલ છે. શું બે પંક્તિઓ ક્યારેય સમાન પંક્તિ નંબર મેળવી શકે છે?",
          "options": [
            {
              "icon": "",
              "label": "હા"
            },
            {
              "icon": "",
              "label": "જો PARTITION BY નો પણ ઉપયોગ કરવામાં આવ્યો હોય તો જ"
            },
            {
              "icon": "",
              "label": "તે ટાઈ ક્યાં પડે છે તેના પર નિર્ભર કરે છે"
            },
            {
              "icon": "",
              "label": "No"
            }
          ]
        },
        {
          "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": "એક કોમન ટેબલ એક્સપ્રેશન (CTE)"
            },
            {
              "icon": "",
              "label": "ડેટાબેઝમાં એક કાયમી ટેબલ"
            },
            {
              "icon": "",
              "label": "એક વ્યૂ જે ક્વેરી પછી પણ રહે છે"
            },
            {
              "icon": "",
              "label": "એક સ્ટોર્ડ પ્રોસિજર"
            }
          ]
        },
        {
          "question": "એક કૉલમને PRIMARY KEY તરીકે જાહેર કરવામાં આવે છે. શું તમે એવી પંક્તિ દાખલ કરી શકો છો જ્યાં તે કૉલમ NULL હોય?",
          "options": [
            {
              "icon": "",
              "label": "હા"
            },
            {
              "icon": "",
              "label": "હા, પરંતુ માત્ર એક NULL પંક્તિ"
            },
            {
              "icon": "",
              "label": "No"
            },
            {
              "icon": "",
              "label": "તે કૉલમના ડિફૉલ્ટ મૂલ્ય પર આધાર રાખે છે"
            }
          ]
        },
        {
          "question": "એક ઓપન ટ્રાન્ઝેક્શનની અંદર, તમે UPDATE ચલાવો છો પરંતુ હજુ સુધી COMMIT ચલાવ્યું નથી. ડેટાબેઝ સાથેના બીજા, અલગ કનેક્શનથી, શું તે અપડેટ દેખાય છે?",
          "options": [
            {
              "icon": "",
              "label": "હા, તરત જ"
            },
            {
              "icon": "",
              "label": "ફક્ત જો બીજું કનેક્શન ટ્રાન્ઝેક્શન ખોલે તો જ"
            },
            {
              "icon": "",
              "label": "તે કયું ટેબલ અપડેટ થયું હતું તેના પર આધાર રાખે છે"
            },
            {
              "icon": "",
              "label": "ના, જ્યાં સુધી તે કમિટ ન થાય ત્યાં સુધી નહીં"
            }
          ]
        },
        {
          "question": "products.category_id માં categories.id ને સંદર્ભિત કરતું FOREIGN KEY કન્સ્ટ્રેન્ટ છે. તમે categories માંથી એક રો DELETE કરવાનો પ્રયાસ કરો છો જેમાં હજુ પણ products તેની તરફ નિર્દેશ કરે છે, અને કોઈ ON DELETE નિયમ ઉલ્લેખિત નથી. શું થશે?",
          "options": [
            {
              "icon": "",
              "label": "products ની category_id ને NULL પર સેટ કરવામાં આવે છે"
            },
            {
              "icon": "",
              "label": "સંદર્ભિત products પણ ડિલીટ થઈ જાય છે"
            },
            {
              "icon": "",
              "label": "DELETE ને નકારી કાઢવામાં આવે છે"
            },
            {
              "icon": "",
              "label": "DELETE સફળ થાય છે, અને અધૂરા સંદર્ભો રહી જાય છે"
            }
          ]
        }
      ],
      "optionOrderVersion": "f9e1314f9ea2bea2"
    }
  },
  "testNames": {
    "sql-test": "SQL ટેસ્ટ"
  }
}