{
  "assessmentTests": {
    "sql_test": {
      "name": "SQL-test",
      "desc": "30 scenariofrågor om filtrering, joins, aggregering, subqueries och fönsterfunktioner — ta reda på om din SQL överensstämmer med vad en jobbannonering menar med SQL-kompetens.",
      "recommendation": "Din SQL-kompetensprofil",
      "results": {
        "beginner": {
          "name": "Nybörjare",
          "desc": "Du kan skriva en fungerande SELECT-sats och filtrera på några villkor, men de frågor du missade handlar om NULL-hantering och join-mekanik snarare än syntax — jämför en kolumn med NULL med =, vad LEFT JOIN faktiskt bevarar, hur gränserna för BETWEEN fungerar. Inget av detta handlar om att vara dålig på databaser; dessa är de specifika regler som stoppar människor som lärde sig SQL genom trial-and-error snarare än från standarden. De är viktiga på jobbet eftersom var och en av dem är där en fråga returnerar ett rimligt utseende men felaktigt radantal.",
          "recommendation": "Börja med tre saker, i denna ordning: varför WHERE col = NULL aldrig matchar något (och IS NULL krävs istället), hur INNER JOIN släpper omatchade rader medan LEFT JOIN behåller dem, och de exakta gränserna som BETWEEN inkluderar. Mode Analytics SQL-handledning och PostgreSQL-dokumentationen täcker allt med körbara exempel."
        },
        "intermediate": {
          "name": "Medelnivå",
          "desc": "Du hanterar dagliga rapportfrågor bekvämt — joins, GROUP BY, enkel filtrering — och skulle inte bromsas ned av rutinmässig instrumentpanel eller ad-hoc-analysarbete. Gapet mellan här och Avancerad handlar mestadels om vad som händer när klausuler interagerar: en WHERE-klausul på den kopplade tabellen som tyst gör ett LEFT JOIN tillbaka till ett INNER JOIN, en join som multiplicerar radantalet innan en aggregatfunktion tillämpas på dem, ett NOT IN som tyst returnerar ingenting eftersom en NULL smugit sig in i subqueryn. Dessa är de slag av buggar som passerar en snabb ögonblicksbild och bara visas upp när någon jämför summan med en annan rapport.",
          "recommendation": "Fokusera på hur klausuler interagerar snarare än vad var och en gör ensam: WHERE-filtrering på en LEFT JOINs höger kolumner, radmultiplikation från en-till-många-joins innan du aggregerar, och varför NOT IN bryter i närvaro av NULLs. Sedan HAVING vs WHERE, eftersom den splittringen stoppar människor som redan kan båda klausulerna individuellt."
        },
        "advanced": {
          "name": "Avancerad",
          "desc": "Detta är nivån som de flesta jobbannonseringar menar med \"stark SQL.\" Du läser en multi-join-fråga och kan förutsäga dess radantal innan du kör det, du vet varför en resultatuppsättning ändrades snarare än bara att det gjorde det, och du når för en CTE eller en fönsterfunktion istället för en kapslad subquery när det är det klarare verktyget. Vad skiljer detta band från toppen är försvarets sida av arbetet: att veta vilken rankingfunktion som ska användas när oavgjort spelar roll, vad en transaktion isolerar från en samtidig session, och vad en saknad ON DELETE-regel faktiskt gör på databasnivå.",
          "recommendation": "Pusha in i de delar som skyddar data som andra människor också rör: skillnaden mellan RANK, DENSE_RANK och ROW_NUMBER under oavgjort, vad COMMIT faktiskt gör synligt och för vem, och beteende för främmande nyckel vid DELETE. Använd The Index-nyhetsbrevet eller SQL for Devs djupgående dykningar på fönsterfunktioner och transaktionsisolering som nästa stopp för båda."
        },
        "expert": {
          "name": "Expert",
          "desc": "Du fick toppresultat i varje sektion — filtrering och NULL-semantik, joins och set-operationer, aggregering och subqueries, och fönsterfunktioner, CTEs och begränsningar. Praktiskt sett betyder det att du kan få en främlings multi-join-rapportfråga och förklara varför den returnerar det radantal som den gör, inte bara vad syntaxen säger att den borde göra, vilket är den svårare och mer värdefulla färdigheten. På denna nivå är frågespråket sällan den begränsande faktorn; gränsen är vanligtvis schemadesign eller storleken på data under den.",
          "recommendation": "Avkastningen är nu i körningsplaner och design: läsning av EXPLAIN-utmatning innan man antar att en fråga är långsam, indexstrategi som en kompromiss mot skrivkostnad snarare än en gratis vinst, och normalisationsbeslut som håller upp när ett schema växer. Om du screenas för en roll, beskrivning av ett frågebuggar som join-fan-out eller NOT IN/NULL-fällan som du hittade i produktion snarare än namngivning av SQL-funktioner — det visar resonemanget, inte bara vokabulären."
        }
      },
      "questions": [
        {
          "question": "En tabell har en kolumn age som kan innehålla NULL. Du kör SELECT * FROM users WHERE age = NULL. Hur många rader returnerar detta, även om flera rader har age inställt på NULL?",
          "options": [
            {
              "icon": "",
              "label": "Alla rader där age är NULL, eftersom = matchar NULL som något annat värde"
            },
            {
              "icon": "",
              "label": "Noll — jämförelse av något med NULL med = producerar UNKNOWN, aldrig TRUE, så inga rader matchar; IS NULL krävs istället"
            },
            {
              "icon": "",
              "label": "Ett syntaxfel — NULL kan inte förekomma på höger sida av ="
            },
            {
              "icon": "",
              "label": "Alla rader i tabellen, eftersom NULL-jämförelser standardvärderas till TRUE"
            }
          ]
        },
        {
          "question": "Du kör SELECT DISTINCT department, role FROM employees. Vad tar DISTINCT bort dubbletter av?",
          "options": [
            {
              "icon": "",
              "label": "Kombinationen av department och role tillsammans — en rad tas bara bort om båda kolumnerna matchar en annan rad exakt"
            },
            {
              "icon": "",
              "label": "Endast department-värden som dupliceras, och behåller varje role"
            },
            {
              "icon": "",
              "label": "Endast role-värden som dupliceras, och behåller varje department"
            },
            {
              "icon": "",
              "label": "Inget — DISTINCT fungerar bara med en enda kolumn"
            }
          ]
        },
        {
          "question": "En kolumn name filtreras med WHERE name LIKE 'A_'. Vilket av dessa värden matchar: 'A', 'Al', 'Ana', 'Ally'?",
          "options": [
            {
              "icon": "",
              "label": "'A' — understrecket är valfritt och matchar noll eller fler tecken"
            },
            {
              "icon": "",
              "label": "'Al' — understrecket matchar exakt ett tecken, så LIKE 'A_' matchar alla tvåteckenssträngar som börjar med A"
            },
            {
              "icon": "",
              "label": "'Ana' och 'Ally' — understrecket matchar ett valfritt antal efterföljande tecken"
            },
            {
              "icon": "",
              "label": "Alla fyra värdena matchar, eftersom LIKE ignorerar längd"
            }
          ]
        },
        {
          "question": "En price-kolumn filtreras med WHERE price BETWEEN 10 AND 20. Inkluderas rader med price exakt 10 eller exakt 20?",
          "options": [
            {
              "icon": "",
              "label": "Nej — BETWEEN utesluter båda slutpunkterna"
            },
            {
              "icon": "",
              "label": "Ja — BETWEEN är inkluderande på båda ändar, motsvarande price >= 10 AND price <= 20"
            },
            {
              "icon": "",
              "label": "Endast price = 10 inkluderas; den övre gränsen är exklusiv"
            },
            {
              "icon": "",
              "label": "Endast price = 20 inkluderas; den nedre gränsen är exklusiv"
            }
          ]
        },
        {
          "question": "En tabell orders har 10 rader, och 3 av dem har en NULL shipped_date. Vad returnerar SELECT COUNT(*) FROM orders, och vad returnerar SELECT COUNT(shipped_date) FROM orders?",
          "options": [
            {
              "icon": "",
              "label": "10, sedan 10 — COUNT räknar alltid rader oavsett NULLs"
            },
            {
              "icon": "",
              "label": "7, sedan 7 — båda formerna hoppar över NULL-rader"
            },
            {
              "icon": "",
              "label": "10, sedan 7 — COUNT(*) räknar varje rad, COUNT(column) räknar bara rader där den kolumnen inte är NULL"
            },
            {
              "icon": "",
              "label": "10, sedan 3 — COUNT(column) räknar bara NULL-värdena"
            }
          ]
        },
        {
          "question": "Du kör SELECT name, salary FROM employees ORDER BY 2 DESC. Vad refererar 2:an till?",
          "options": [
            {
              "icon": "",
              "label": "Ett syntaxfel — ORDER BY accepterar bara kolumnnamn, inte nummer"
            },
            {
              "icon": "",
              "label": "Den andra raden av resultatet"
            },
            {
              "icon": "",
              "label": "Ett litteralt värde på 2, använt som tiebreaker"
            },
            {
              "icon": "",
              "label": "Den andra kolumnen i SELECT-listan, salary — ORDER BY accepterar en kolumns positionsnummer som förkortning"
            }
          ]
        },
        {
          "question": "I standard SQL, vad utvärderas 'Ana' || ' ' || 'Lee' till?",
          "options": [
            {
              "icon": "",
              "label": "Ett syntaxfel — SQL har ingen sammankopplingsoperator"
            },
            {
              "icon": "",
              "label": "3 — || behandlas som ett booleskt OR och returnerar ett tal"
            },
            {
              "icon": "",
              "label": "'AnaLee' — || sammankopplar utan att bevara mellanslag"
            },
            {
              "icon": "",
              "label": "'Ana Lee' — || är standarden SQL-strängsammankopplingsoperator"
            }
          ]
        },
        {
          "question": "Vilket av dessa är exakt motsvarande till 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 har 100 rader; 20 av dem har aldrig gjort en order. Du kör SELECT c.id FROM customers c INNER JOIN orders o ON c.id = o.customer_id. Visas de 20 kunderna utan order i resultat?",
          "options": [
            {
              "icon": "",
              "label": "Ja, en gång var och en, med o.id visat som NULL"
            },
            {
              "icon": "",
              "label": "Ja, men bara om de också förekommer i en WHERE-klausul"
            },
            {
              "icon": "",
              "label": "Nej — INNER JOIN returnerar bara rader som har en matchning i båda tabellerna, så kunder utan order tas bort helt"
            },
            {
              "icon": "",
              "label": "Ja, duplicerad en gång per kolumn i orders"
            }
          ]
        },
        {
          "question": "Du vill ha alla kunder oavsett om de har order eller inte, så du skriver SELECT c.id, o.total FROM customers c LEFT JOIN orders o ON c.id = o.customer_id WHERE o.total > 100. Returnerar detta fortfarande kunder med noll order?",
          "options": [
            {
              "icon": "",
              "label": "Nej — filtrering på o.total i WHERE-klausulen kasserar NULL-raderna som LEFT JOIN producerade för omatchade kunder, så det beter sig som ett INNER JOIN"
            },
            {
              "icon": "",
              "label": "Ja — LEFT JOIN bevarar alltid varje rad från customers oavsett vad som följer"
            },
            {
              "icon": "",
              "label": "Ja, med o.total visat som 0 för kunder utan order"
            },
            {
              "icon": "",
              "label": "Nej — LEFT JOIN konverterar tyst sig själv till RIGHT JOIN när en WHERE-klausul läggs till"
            }
          ]
        },
        {
          "question": "En employees-tabell har en id-kolumn och en manager_id-kolumn som pekar på en annan rads id. För att lista varje anställd bredvid sin chefs namn, kopplar du tabellen till sig själv: SELECT e.name, m.name FROM employees e JOIN employees m ON e.manager_id = m.id. Vad kallas detta mönster?",
          "options": [
            {
              "icon": "",
              "label": "En cross join — varje anställd matchas med varje chef"
            },
            {
              "icon": "",
              "label": "En rekursiv join — den hämtar hela chefskäden"
            },
            {
              "icon": "",
              "label": "En self-join — samma tabell är kopplad till sig själv med två olika alias"
            },
            {
              "icon": "",
              "label": "Detta är ogiltig SQL — en tabell kan inte kopplas till sig själv"
            }
          ]
        },
        {
          "question": "Två SELECT-frågor med samma kolumner kombineras med UNION. Om båda frågorna returnerar en identisk rad, hur många kopior av den raden visas i det slutliga resultatet?",
          "options": [
            {
              "icon": "",
              "label": "En — UNION tar bort dubblettrad över det kombinerade resultatet; UNION ALL skulle behålla båda kopiorna"
            },
            {
              "icon": "",
              "label": "Två — UNION behåller varje rad från båda frågorna"
            },
            {
              "icon": "",
              "label": "Noll — UNION tar bort alla rader som förekommer i båda frågorna"
            },
            {
              "icon": "",
              "label": "Det beror på vilken fråga som listade raden först"
            }
          ]
        },
        {
          "question": "Tabell sizes har 3 rader och colors har 4 rader. Hur många rader returnerar SELECT * FROM sizes CROSS JOIN colors?",
          "options": [
            {
              "icon": "",
              "label": "7 — CROSS JOIN lägger radantalen tillsammans"
            },
            {
              "icon": "",
              "label": "12 — en CROSS JOIN returnerar varje möjlig kombination av rader från båda tabellerna (3 × 4)"
            },
            {
              "icon": "",
              "label": "3 — CROSS JOIN returnerar en rad per rad i den första tabellen"
            },
            {
              "icon": "",
              "label": "0 — CROSS JOIN kräver ett ON-villkor annars returneras ingenting"
            }
          ]
        },
        {
          "question": "orders har 1 rad för order #100, och order_items har 3 rader för order #100 (en per radpost). Du kör SELECT o.id, o.total FROM orders o JOIN order_items i ON o.id = i.order_id WHERE o.id = 100. Hur många rader kommer tillbaka för order #100?",
          "options": [
            {
              "icon": "",
              "label": "3 — join producerar en utmatningsrad per matchande order_items-rad, så order #100:s enda rad upprepas en gång per radpost"
            },
            {
              "icon": "",
              "label": "1 — orders har bara en rad för order #100, så join kan inte producera fler"
            },
            {
              "icon": "",
              "label": "4 — en rad för ordern plus en per radpost"
            },
            {
              "icon": "",
              "label": "0 — att koppla en tabell med en rad till en tabell med tre rader på en icke-unik nyckel misslyckas"
            }
          ]
        },
        {
          "question": "SELECT c.name, o.id FROM customers c RIGHT JOIN orders o ON c.id = o.customer_id returnerar samma rader som vilken av dessa?",
          "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 — att byta tabelordning och använda LEFT JOIN istället för RIGHT JOIN är motsvarande"
            },
            {
              "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": "I standard SQL, du kör SELECT department, name, AVG(salary) FROM employees GROUP BY department. Är detta en giltig fråga?",
          "options": [
            {
              "icon": "",
              "label": "Ja — GROUP BY behöver bara inkludera department eftersom det är listat först"
            },
            {
              "icon": "",
              "label": "Nej — name är vald men varken aggregerad eller listad i GROUP BY, och standard SQL kräver att varje icke-aggregerad vald kolumn förekommer i GROUP BY-klausulen"
            },
            {
              "icon": "",
              "label": "Ja — SQL väljer automatiskt ett namn per avdelning"
            },
            {
              "icon": "",
              "label": "Nej — AVG() kan inte kombineras med GROUP BY i samma fråga"
            }
          ]
        },
        {
          "question": "Du vill ha avdelningar vars genomsnittslön överstiger 80000. Vilken klausul filtrerar på ett aggregerat värde som AVG(salary) efter gruppering — WHERE eller HAVING?",
          "options": [
            {
              "icon": "",
              "label": "WHERE — HAVING används bara med UNION-frågor"
            },
            {
              "icon": "",
              "label": "Båda fungerar identiskt med aggregatfunktioner"
            },
            {
              "icon": "",
              "label": "Ingen av dem — aggregatfiltrering kräver en subquery"
            },
            {
              "icon": "",
              "label": "HAVING — WHERE filtrerar individuella rader före gruppering sker, HAVING filtrerar grupper efter aggregering"
            }
          ]
        },
        {
          "question": "Du skriver SELECT salary * 1.1 AS new_salary FROM employees WHERE new_salary > 50000. Körs detta?",
          "options": [
            {
              "icon": "",
              "label": "Ja — alias definierade i SELECT är alltid tillgängliga för WHERE i samma fråga"
            },
            {
              "icon": "",
              "label": "Ja, men bara för numeriska alias"
            },
            {
              "icon": "",
              "label": "Nej — AS är inte tillåtet inuti en WHERE-filtrerad fråga"
            },
            {
              "icon": "",
              "label": "Nej — WHERE utvärderas före SELECT tilldelar aliaset new_salary, så aliaset finns inte än vid den punkten i körningen"
            }
          ]
        },
        {
          "question": "SELECT name FROM employees e WHERE salary > (SELECT AVG(salary) FROM employees WHERE department = e.department). Varför kallas detta en korrelerad subquery?",
          "options": [
            {
              "icon": "",
              "label": "Eftersom den använder en JOIN istället för en WHERE-klausul"
            },
            {
              "icon": "",
              "label": "Den inre subqueryn refererar till e.department från den yttre frågan, så den måste utvärderas på nytt för varje rad som den yttre frågan överväger"
            },
            {
              "icon": "",
              "label": "Eftersom den returnerar mer än en kolumn"
            },
            {
              "icon": "",
              "label": "Eftersom den körs exakt en gång före den yttre frågan börjar"
            }
          ]
        },
        {
          "question": "En subquery SELECT manager_id FROM employees returnerar några NULL-värden tillsammans med verkliga ids. Du kör SELECT name FROM employees WHERE id NOT IN (SELECT manager_id FROM employees). Vad händer?",
          "options": [
            {
              "icon": "",
              "label": "Det returnerar varje anställd som inte är chef, ignorerar NULLs"
            },
            {
              "icon": "",
              "label": "Det returnerar noll rader — en enda NULL i NOT IN-listan gör varje jämförelse UNKNOWN, så ingen rad kan uppfylla villkoret"
            },
            {
              "icon": "",
              "label": "Det utlöser ett fel eftersom NOT IN inte kan användas med subqueries"
            },
            {
              "icon": "",
              "label": "Det returnerar varje anställd, eftersom NULL behandlas som ett jokertecken"
            }
          ]
        },
        {
          "question": "SELECT name FROM customers c WHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id). Vad returnerar detta?",
          "options": [
            {
              "icon": "",
              "label": "Varje kund som har minst en rad i orders — EXISTS kontrollerar bara om subqueryn returnerar några rader, inte vilka värden de innehåller"
            },
            {
              "icon": "",
              "label": "Varje kund, eftersom SELECT 1 alltid returnerar sant"
            },
            {
              "icon": "",
              "label": "Ett fel, eftersom subqueryn väljer ett nummer istället för ett kolumnnamn"
            },
            {
              "icon": "",
              "label": "Bara kunder med exakt en order"
            }
          ]
        },
        {
          "question": "Du skriver SELECT name, (SELECT order_id FROM orders WHERE customer_id = c.id) AS last_order FROM customers c, och en given kund har 3 rader i orders. Vad händer när denna fråga körs?",
          "options": [
            {
              "icon": "",
              "label": "Det returnerar det första matchande order_id och ignorerar tyst de andra två"
            },
            {
              "icon": "",
              "label": "Det returnerar en kommaseparerad lista över alla tre order_ids"
            },
            {
              "icon": "",
              "label": "Det returnerar 3 rader för den kunden, en per order"
            },
            {
              "icon": "",
              "label": "Det utlöser ett fel vid körning — en skalär subquery i SELECT-listan måste returnera högst en rad, och denna returnerar tre"
            }
          ]
        },
        {
          "question": "Fyra rader är bundna för det högsta värdet. Med RANK() ORDER BY score DESC får alla fyra rank 1. Vilken rank får nästa rad?",
          "options": [
            {
              "icon": "",
              "label": "5 — RANK() lämnar ett gap lika med antalet bundna rader före fortsatt räkning"
            },
            {
              "icon": "",
              "label": "2 — RANK() ökar alltid med exakt ett efter ett oavgjort"
            },
            {
              "icon": "",
              "label": "1 — varje efterföljande rad får också rank 1"
            },
            {
              "icon": "",
              "label": "4 — RANK() börjar om räkningen från antalet bundna rader"
            }
          ]
        },
        {
          "question": "Fyra rader är bundna för det högsta värdet. Med DENSE_RANK() ORDER BY score DESC får alla fyra rank 1. Vilken rank får nästa rad?",
          "options": [
            {
              "icon": "",
              "label": "5 — DENSE_RANK() beter sig exakt som RANK()"
            },
            {
              "icon": "",
              "label": "1 — DENSE_RANK() tilldelar samma rank till varje återstående rad"
            },
            {
              "icon": "",
              "label": "2 — DENSE_RANK() lämnar aldrig gap, så nästa distinkta värde får alltid nästa successiva rank"
            },
            {
              "icon": "",
              "label": "3 — DENSE_RANK() hoppar över en rank per bunden grupp"
            }
          ]
        },
        {
          "question": "SUM(amount) OVER (PARTITION BY region ORDER BY amount) läggs till en fråga. Vad gör PARTITION BY region här?",
          "options": [
            {
              "icon": "",
              "label": "Det startar om löpande summa separat för varje region, istället för att ackumulera över hela resultatuppsättningen"
            },
            {
              "icon": "",
              "label": "Det filtrerar resultaten till en enda region"
            },
            {
              "icon": "",
              "label": "Det grupperar och kollapsar raderna till en per region, som GROUP BY"
            },
            {
              "icon": "",
              "label": "Det sorterar regionerna alfabetiskt före summering"
            }
          ]
        },
        {
          "question": "ROW_NUMBER() OVER (ORDER BY score DESC) tillämpas på fem rader, två av vilka är exakt bundna i värde. Kan två rader någonsin få samma radnummer?",
          "options": [
            {
              "icon": "",
              "label": "Ja — bundna rader delar alltid samma radnummer"
            },
            {
              "icon": "",
              "label": "Bara om PARTITION BY också används"
            },
            {
              "icon": "",
              "label": "Det beror på om bandet är på första eller sista positionen"
            },
            {
              "icon": "",
              "label": "Nej — ROW_NUMBER() tilldelar alltid ett unikt, strikt ökande heltal till varje rad, även när värden är bundna"
            }
          ]
        },
        {
          "question": "WITH high_earners AS (SELECT * FROM employees WHERE salary > 100000) SELECT department, COUNT(*) FROM high_earners GROUP BY department. Vad är high_earners?",
          "options": [
            {
              "icon": "",
              "label": "Ett vanligt tabelluttryck (CTE) — en namngiven, temporär resultatuppsättning som resten av frågan kan referera till som en tabell"
            },
            {
              "icon": "",
              "label": "En permanent tabell skapad i databasen"
            },
            {
              "icon": "",
              "label": "En vy som kvarstår efter att frågan är klar"
            },
            {
              "icon": "",
              "label": "En lagrad procedur som måste anropas separat"
            }
          ]
        },
        {
          "question": "En kolumn är deklarerad PRIMARY KEY. Kan du infoga en rad där denna kolumn är NULL?",
          "options": [
            {
              "icon": "",
              "label": "Ja — PRIMARY KEY tillämpar bara unikitet, inte NULL-ness"
            },
            {
              "icon": "",
              "label": "Ja, men bara en NULL-rad är tillåten, samma som en UNIQUE-begränsning"
            },
            {
              "icon": "",
              "label": "Nej — en PRIMARY KEY-kolumn är implicit NOT NULL, så att infoga NULL i den avvisas"
            },
            {
              "icon": "",
              "label": "Det beror på om kolumnen också har ett standardvärde"
            }
          ]
        },
        {
          "question": "Inne i en öppen transaktion, du kör en UPDATE men har ännu inte kört COMMIT. Från en andra, separat anslutning till databasen, är denna uppdatering synlig?",
          "options": [
            {
              "icon": "",
              "label": "Ja — alla anslutningar ser varje skrivning ömsesidigt när den körs"
            },
            {
              "icon": "",
              "label": "Ja, men bara om den andra anslutningen också öppnar en transaktion"
            },
            {
              "icon": "",
              "label": "Det beror bara på vilken tabell som uppdaterades"
            },
            {
              "icon": "",
              "label": "Nej — en ej bekräftad ändring är bara synlig innanför transaktionen som gjorde den, tills COMMIT gör den hållbar och synlig för andra"
            }
          ]
        },
        {
          "question": "products.category_id har en FOREIGN KEY-begränsning som refererar till categories.id. Du försöker DELETE en rad från categories som fortfarande har products som pekar på det, utan ON DELETE-regel angiven. Vad händer?",
          "options": [
            {
              "icon": "",
              "label": "Kategorirad tas bort och matchande products.category_id-värden sätts automatiskt till NULL"
            },
            {
              "icon": "",
              "label": "Kategorirad tas bort och varje produkt som refererade den tas också bort"
            },
            {
              "icon": "",
              "label": "DELETE avvisas — standardbeteende för främmande nyckel blockerar borttagning av en refererad rad medan beroende rader fortfarande pekar på det"
            },
            {
              "icon": "",
              "label": "DELETE lyckas tyst, vilket lämnar products' category_id pekande på en kategori som inte längre finns"
            }
          ]
        }
      ],
      "optionOrderVersion": "e0466e547cfd8a45"
    }
  }
}