{
  "assessmentTests": {
    "sql_test": {
      "name": "Pagsusulit sa SQL",
      "desc": "30 scenario na tanong sa filtering, joins, aggregation, subqueries at window functions — alamin kung tumutugma ang iyong SQL sa ibig sabihin ng isang job posting ng SQL proficiency.",
      "recommendation": "Ang iyong SQL skills profile",
      "results": {
        "beginner": {
          "name": "Nagsisimula pa lang",
          "desc": "Kaya mong sumulat ng isang gumaganang SELECT statement at mag-filter sa ilang conditions, pero ang mga tanong na nakaligtaan mo ay nag-cluster sa paligid ng NULL handling at join mechanics sa halip na syntax — ang paghahambing ng isang column sa NULL gamit ang =, kung ano talaga ang pinapanatili ng LEFT JOIN, kung paano gumagana ang mga boundary ng BETWEEN. Wala sa mga ito ang tungkol sa pagiging mahina sa databases; ito ang mga specific na rules na nakakatisod sa mga taong natuto ng SQL sa pamamagitan ng trial and error sa halip na mula sa standard. Mahalaga ang mga ito sa trabaho dahil ang bawat isa ay kung saan nagbabalik ang isang query ng isang mukhang-tama pero maling row count.",
          "recommendation": "Magsimula sa tatlong bagay, sa pagkakasunod-sunod na ito: kung bakit hindi kailanman tumutugma ang WHERE col = NULL sa kahit ano (at kailangan ang IS NULL sa halip), kung paano tinatanggal ng INNER JOIN ang mga unmatched row habang pinapanatili sila ng LEFT JOIN, at ang eksaktong mga boundary na isinasama ng BETWEEN. Sinasaklaw ng SQL tutorial ng Mode Analytics at ng PostgreSQL documentation ang lahat ng tatlo gamit ang mga runnable example."
        },
        "intermediate": {
          "name": "Katamtaman",
          "desc": "Kinaya mong hawakan nang komportable ang everyday reporting queries — joins, GROUP BY, straightforward filtering — at hindi ka mababagalan ng routine dashboard o ad-hoc analysis work. Ang agwat sa pagitan nito at Advanced ay nasa kadalasan kung ano ang mangyayari kapag nag-interact ang mga clause: isang WHERE clause sa joined table na tahimik na binabalik ang isang LEFT JOIN sa INNER JOIN, isang join na nagpapalaki ng row count bago ito ilagay sa isang aggregate, isang NOT IN na tahimik na walang ibinabalik dahil may isang NULL na nakapasok sa subquery. Iyon ang uri ng bugs na nakakapasa sa isang mabilisang eyeball check at lumalabas lamang kapag inihambing ng isang tao ang total sa ibang report.",
          "recommendation": "Mag-focus sa kung paano nag-i-interact ang mga clause sa halip na kung ano ang ginagawa ng bawat isa nang mag-isa: WHERE na nagfi-filter sa right-hand columns ng isang LEFT JOIN, row multiplication mula sa one-to-many joins bago ka mag-aggregate, at kung bakit nasisira ang NOT IN sa presensya ng mga NULL (karaniwang hindi ito nangyayari sa EXISTS). Pagkatapos ang HAVING laban sa WHERE, dahil ang split na iyon ay nakakatisod sa mga taong alam na ang dalawang clause nang hiwalay."
        },
        "advanced": {
          "name": "Mataas",
          "desc": "Ito ang level na ibig sabihin ng karamihan ng job postings kapag sinabi nilang \"strong SQL.\" Binabasa mo ang isang multi-join query at nahuhulaan mo ang row count nito bago pa ito patakbuhin, alam mo kung bakit nagbago ang isang result set sa halip na alam lamang na nagbago ito, at kinukuha mo ang isang CTE o window function sa halip na isang nested subquery kapag iyon ang mas malinaw na tool. Ang naghihiwalay sa band na ito mula sa pinakaitaas ay ang defensive side ng trabaho: ang pag-alam kung aling ranking function ang gagamitin kapag mahalaga ang mga tie, kung ano ang ini-isolate ng isang transaction mula sa isang concurrent session, at kung ano talaga ang ginagawa ng isang nawawalang ON DELETE rule sa database level.",
          "recommendation": "Itulak papasok sa mga parte na nagpo-protect ng data na ginagalaw din ng ibang tao: ang pagkakaiba ng RANK, DENSE_RANK at ROW_NUMBER sa ilalim ng mga tie, kung ano talaga ang ginagawang visible ng COMMIT at kung kanino, at ang foreign key behavior sa DELETE. Gamitin ang deep-dive articles ng The Index newsletter o SQL for Devs sa window functions at transaction isolation bilang susunod na hakbang para sa dalawa."
        },
        "expert": {
          "name": "Eksperto",
          "desc": "Nakakuha ka ng top score sa bawat section — filtering at NULL semantics, joins at set operations, aggregation at subqueries, at window functions, CTEs at constraints. Sa praktikal, ibig sabihin nito ay puwede kang bigyan ng multi-join report query ng isang stranger at maipaliwanag mo kung bakit ito nagbabalik ng row count nito, hindi lang kung ano ang sinasabi ng syntax na dapat nitong gawin, na siyang mas mahirap at mas valuable na skill. Sa level na ito, bihira ang query language mismo ang limiting factor; ang limit ay kadalasan ang schema design o ang laki ng data sa ilalim nito.",
          "recommendation": "Nasa execution plans at design na ngayon ang mga return: ang pagbabasa ng EXPLAIN output bago ipagpalagay na mabagal ang isang query, ang indexing strategy bilang isang tradeoff laban sa write cost sa halip na libreng panalo, at ang mga normalization decision na nananatiling matatag habang lumalaki ang isang schema. Kung sine-screen ka para sa isang role, ilarawan ang isang query bug tulad ng join fan-out o NOT IN/NULL trap na nahanap mo sa production sa halip na pangalanan ang mga SQL feature — ipinapakita nito ang reasoning, hindi lang ang vocabulary."
        }
      },
      "questions": [
        {
          "question": "Ang isang table ay may nullable na column na age. Pinatakbo mo ang SELECT * FROM users WHERE age = NULL. Ilang row ang ibabalik nito, kahit na maraming row ang may age na naka-set sa NULL?",
          "options": [
            {
              "icon": "",
              "label": "Bawat row kung saan NULL ang age, dahil tumutugma ang = sa NULL tulad ng anumang ibang value"
            },
            {
              "icon": "",
              "label": "Zero — ang paghahambing ng kahit ano sa NULL gamit ang = ay gumagawa ng UNKNOWN, hindi kailanman TRUE, kaya walang row na tumutugma; kailangan ang IS NULL sa halip"
            },
            {
              "icon": "",
              "label": "Isang syntax error — hindi puwedeng lumabas ang NULL sa kanang bahagi ng ="
            },
            {
              "icon": "",
              "label": "Bawat row sa table, dahil ang mga NULL comparison ay default sa TRUE"
            }
          ]
        },
        {
          "question": "Pinatakbo mo ang SELECT DISTINCT department, role FROM employees. Ano ang tinatanggal ng DISTINCT na mga duplicate?",
          "options": [
            {
              "icon": "",
              "label": "Ang kombinasyon ng department at role nang magkasama — isang row lang ang tinatanggal kung parehong column nito ay eksaktong tumutugma sa ibang row"
            },
            {
              "icon": "",
              "label": "Mga duplicate na department value lang, pinananatili ang bawat role"
            },
            {
              "icon": "",
              "label": "Mga duplicate na role value lang, pinananatili ang bawat department"
            },
            {
              "icon": "",
              "label": "Wala — gumagana lamang ang DISTINCT sa iisang column"
            }
          ]
        },
        {
          "question": "Ang isang column na name ay na-filter gamit ang WHERE name LIKE 'A_'. Alin sa mga value na ito ang tumutugma: 'A', 'Al', 'Ana', 'Ally'?",
          "options": [
            {
              "icon": "",
              "label": "'A' — optional ang underscore at tumutugma ito sa zero o higit pang character"
            },
            {
              "icon": "",
              "label": "'Al' — tumutugma ang underscore sa eksaktong isang character, kaya tumutugma ang LIKE 'A_' sa anumang two-character string na nagsisimula sa A"
            },
            {
              "icon": "",
              "label": "'Ana' at 'Ally' — tumutugma ang underscore sa anumang bilang ng trailing character"
            },
            {
              "icon": "",
              "label": "Tumutugma ang lahat ng apat na value, dahil binabalewala ng LIKE ang length"
            }
          ]
        },
        {
          "question": "Ang isang column na price ay na-filter gamit ang WHERE price BETWEEN 10 AND 20. Kasama ba ang mga row na may price na eksaktong 10 o eksaktong 20?",
          "options": [
            {
              "icon": "",
              "label": "Hindi — hindi kasama ng BETWEEN ang dalawang endpoint"
            },
            {
              "icon": "",
              "label": "Oo — inclusive ang BETWEEN sa dalawang dulo, katumbas ng price >= 10 AND price <= 20"
            },
            {
              "icon": "",
              "label": "Kasama lamang ang price = 10; exclusive ang upper bound"
            },
            {
              "icon": "",
              "label": "Kasama lamang ang price = 20; exclusive ang lower bound"
            }
          ]
        },
        {
          "question": "Ang table na orders ay may 10 row, at 3 dito ay may NULL na shipped_date. Ano ang ibabalik ng SELECT COUNT(*) FROM orders, at ano ang ibabalik ng SELECT COUNT(shipped_date) FROM orders?",
          "options": [
            {
              "icon": "",
              "label": "10, pagkatapos 10 — laging binibilang ng COUNT ang mga row anuman ang mga NULL"
            },
            {
              "icon": "",
              "label": "7, pagkatapos 7 — linalaktawan ng dalawang anyo ang mga NULL row"
            },
            {
              "icon": "",
              "label": "10, pagkatapos 7 — binibilang ng COUNT(*) ang bawat row, binibilang ng COUNT(column) lamang ang mga row kung saan hindi NULL ang column na iyon"
            },
            {
              "icon": "",
              "label": "10, pagkatapos 3 — binibilang ng COUNT(column) lamang ang mga NULL value"
            }
          ]
        },
        {
          "question": "Pinatakbo mo ang SELECT name, salary FROM employees ORDER BY 2 DESC. Ano ang tinutukoy ng 2?",
          "options": [
            {
              "icon": "",
              "label": "Isang syntax error — tumatanggap lamang ang ORDER BY ng mga column name, hindi ng mga numero"
            },
            {
              "icon": "",
              "label": "Ang pangalawang row ng resulta"
            },
            {
              "icon": "",
              "label": "Isang literal na value na 2, ginagamit bilang tiebreaker"
            },
            {
              "icon": "",
              "label": "Ang pangalawang column sa SELECT list, salary — tumatanggap ang ORDER BY ng position number ng isang column bilang shorthand"
            }
          ]
        },
        {
          "question": "Sa standard SQL, ano ang resulta ng 'Ana' || ' ' || 'Lee'?",
          "options": [
            {
              "icon": "",
              "label": "Isang syntax error — walang concatenation operator ang SQL"
            },
            {
              "icon": "",
              "label": "3 — itinuturing ang || bilang boolean OR at nagbabalik ito ng count"
            },
            {
              "icon": "",
              "label": "'AnaLee' — ikina-concatenate ng || nang hindi pinapanatili ang mga space"
            },
            {
              "icon": "",
              "label": "'Ana Lee' — ang || ay ang standard SQL string concatenation operator"
            }
          ]
        },
        {
          "question": "Alin sa mga ito ang eksaktong katumbas ng 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": "Ang customers ay may 100 row; 20 dito ay hindi pa kailanman naglagay ng order. Pinatakbo mo ang SELECT c.id FROM customers c INNER JOIN orders o ON c.id = o.customer_id. Lumalabas ba ang 20 customer na walang order sa resulta?",
          "options": [
            {
              "icon": "",
              "label": "Oo, isang beses bawat isa, na may o.id na ipinapakita bilang NULL"
            },
            {
              "icon": "",
              "label": "Oo, pero kung lalabas lamang sila sa isang WHERE clause"
            },
            {
              "icon": "",
              "label": "Hindi — ang INNER JOIN lamang ay nagbabalik ng mga row na may tugma sa dalawang table, kaya ang mga customer na walang order ay tinatanggal nang tuluyan"
            },
            {
              "icon": "",
              "label": "Oo, na-duplicate nang isang beses bawat column sa orders"
            }
          ]
        },
        {
          "question": "Gusto mo ang bawat customer, may order man sila o wala, kaya isinulat mo ang SELECT c.id, o.total FROM customers c LEFT JOIN orders o ON c.id = o.customer_id WHERE o.total > 100. Ibinabalik pa rin ba nito ang mga customer na walang order?",
          "options": [
            {
              "icon": "",
              "label": "Hindi — ang pag-filter sa o.total sa WHERE clause ay tinatanggal ang mga NULL row na ginawa ng LEFT JOIN para sa mga unmatched customer, kaya kumikilos ito tulad ng INNER JOIN"
            },
            {
              "icon": "",
              "label": "Oo — laging pinapanatili ng LEFT JOIN ang bawat row mula sa customers anuman ang sumusunod"
            },
            {
              "icon": "",
              "label": "Oo, na may o.total na ipinapakita bilang 0 para sa mga customer na walang order"
            },
            {
              "icon": "",
              "label": "Hindi — tahimik na nagko-convert ang LEFT JOIN sa RIGHT JOIN kapag may idinagdag na WHERE clause"
            }
          ]
        },
        {
          "question": "Ang isang employees table ay may id column at manager_id column na tumuturo sa id ng ibang row. Para ilista ang bawat empleyado sa tabi ng pangalan ng kanilang manager, ino-join mo ang table sa sarili nito: SELECT e.name, m.name FROM employees e JOIN employees m ON e.manager_id = m.id. Ano ang tawag sa pattern na ito?",
          "options": [
            {
              "icon": "",
              "label": "Isang cross join — bawat empleyado ay tinu-tugma sa bawat manager"
            },
            {
              "icon": "",
              "label": "Isang recursive join — kinukuha nito ang buong management chain"
            },
            {
              "icon": "",
              "label": "Isang self-join — ang parehong table ay ino-join sa sarili nito gamit ang dalawang magkaibang alias"
            },
            {
              "icon": "",
              "label": "Ito ay invalid na SQL — hindi puwedeng i-join ang isang table sa sarili nito"
            }
          ]
        },
        {
          "question": "Dalawang SELECT query na may parehong column ay pinagsama gamit ang UNION. Kung ang dalawang query ay nagbabalik ng magkaparehong row, ilang kopya ng row na iyon ang lalabas sa final na resulta?",
          "options": [
            {
              "icon": "",
              "label": "Isa — tinatanggal ng UNION ang mga duplicate row sa kabuuan ng pinagsamang resulta; papanatilihin ng UNION ALL ang dalawang kopya"
            },
            {
              "icon": "",
              "label": "Dalawa — pinapanatili ng UNION ang bawat row mula sa dalawang query"
            },
            {
              "icon": "",
              "label": "Zero — tinatanggal ng UNION ang anumang row na lumalabas sa dalawang query"
            },
            {
              "icon": "",
              "label": "Depende ito sa kung aling query ang unang naglista sa row"
            }
          ]
        },
        {
          "question": "Ang table na sizes ay may 3 row at ang colors ay may 4 row. Ilang row ang ibabalik ng SELECT * FROM sizes CROSS JOIN colors?",
          "options": [
            {
              "icon": "",
              "label": "7 — pinagsasama ng CROSS JOIN ang mga row count"
            },
            {
              "icon": "",
              "label": "12 — ibinabalik ng CROSS JOIN ang bawat posibleng kombinasyon ng mga row mula sa dalawang table (3 x 4)"
            },
            {
              "icon": "",
              "label": "3 — nagbabalik ang CROSS JOIN ng isang row bawat row sa unang table"
            },
            {
              "icon": "",
              "label": "0 — kailangan ng CROSS JOIN ng ON condition o wala itong ibabalik"
            }
          ]
        },
        {
          "question": "Ang orders ay may 1 row para sa order #100, at ang order_items ay may 3 row para sa order #100 (isa bawat line item). Pinatakbo mo ang SELECT o.id, o.total FROM orders o JOIN order_items i ON o.id = i.order_id WHERE o.id = 100. Ilang row ang babalik para sa order #100?",
          "options": [
            {
              "icon": "",
              "label": "3 — gumagawa ang join ng isang output row bawat tumutugmang order_items row, kaya ang iisang row ng order #100 ay inuulit nang isang beses bawat line item"
            },
            {
              "icon": "",
              "label": "1 — iisang row lang ang meron ang orders para sa order #100, kaya hindi kayang gumawa pa ng dagdag ang join"
            },
            {
              "icon": "",
              "label": "4 — isang row para sa order plus isa bawat line item"
            },
            {
              "icon": "",
              "label": "0 — nabibigo ang pag-join ng isang one-row table sa isang three-row table gamit ang non-unique key"
            }
          ]
        },
        {
          "question": "Ang SELECT c.name, o.id FROM customers c RIGHT JOIN orders o ON c.id = o.customer_id ay nagbabalik ng parehong mga row gaya ng alin sa mga ito?",
          "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 — katumbas ang pagpapalit ng order ng table at ang paggamit ng LEFT JOIN sa halip na RIGHT 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": "Sa standard SQL, pinatakbo mo ang SELECT department, name, AVG(salary) FROM employees GROUP BY department. Valid ba ang query na ito?",
          "options": [
            {
              "icon": "",
              "label": "Oo — kailangan lamang isama ng GROUP BY ang department dahil ito ang unang nakalista"
            },
            {
              "icon": "",
              "label": "Hindi — pinili ang name pero hindi ito na-aggregate ni nakalista sa GROUP BY, at kinakailangan ng standard SQL na lumabas ang bawat non-aggregated na napiling column sa GROUP BY clause"
            },
            {
              "icon": "",
              "label": "Oo — awtomatikong pumipili ang SQL ng isang arbitrary na name bawat department"
            },
            {
              "icon": "",
              "label": "Hindi — hindi puwedeng pagsamahin ang AVG() at GROUP BY sa parehong query"
            }
          ]
        },
        {
          "question": "Gusto mo ang mga department na ang average salary ay lampas sa 80000. Aling clause ang nagfi-filter sa isang aggregated value tulad ng AVG(salary) pagkatapos ng grouping — WHERE o HAVING?",
          "options": [
            {
              "icon": "",
              "label": "WHERE — ginagamit lamang ang HAVING sa mga UNION query"
            },
            {
              "icon": "",
              "label": "Pareho silang gumagana nang magkatulad sa mga aggregate function"
            },
            {
              "icon": "",
              "label": "Wala sa dalawa — kailangan ng subquery ang aggregate filtering"
            },
            {
              "icon": "",
              "label": "HAVING — nagfi-filter ang WHERE sa mga indibidwal na row bago mangyari ang grouping, nagfi-filter ang HAVING sa mga group pagkatapos ng aggregation"
            }
          ]
        },
        {
          "question": "Isinulat mo ang SELECT salary * 1.1 AS new_salary FROM employees WHERE new_salary > 50000. Tumatakbo ba ito?",
          "options": [
            {
              "icon": "",
              "label": "Oo — laging available ang mga alias na na-define sa SELECT para sa WHERE sa parehong query"
            },
            {
              "icon": "",
              "label": "Oo, pero para lamang sa mga numeric na alias"
            },
            {
              "icon": "",
              "label": "Hindi — hindi pinapayagan ang AS sa loob ng isang WHERE-filtered na query"
            },
            {
              "icon": "",
              "label": "Hindi — ini-evaluate ang WHERE bago italaga ng SELECT ang alias na new_salary, kaya wala pa ang alias sa puntong iyon ng execution"
            }
          ]
        },
        {
          "question": "SELECT name FROM employees e WHERE salary > (SELECT AVG(salary) FROM employees WHERE department = e.department). Bakit ito tinatawag na correlated subquery?",
          "options": [
            {
              "icon": "",
              "label": "Dahil gumagamit ito ng JOIN sa halip na WHERE clause"
            },
            {
              "icon": "",
              "label": "Tinutukoy ng inner subquery ang e.department mula sa outer query, kaya kailangan itong i-re-evaluate para sa bawat row na isinasaalang-alang ng outer query"
            },
            {
              "icon": "",
              "label": "Dahil nagbabalik ito ng higit sa isang column"
            },
            {
              "icon": "",
              "label": "Dahil tumatakbo ito nang isang beses lamang bago magsimula ang outer query"
            }
          ]
        },
        {
          "question": "Ang subquery na SELECT manager_id FROM employees ay nagbabalik ng ilang NULL value kasama ng mga tunay na id. Pinatakbo mo ang SELECT name FROM employees WHERE id NOT IN (SELECT manager_id FROM employees). Ano ang mangyayari?",
          "options": [
            {
              "icon": "",
              "label": "Ibinabalik nito ang bawat empleyadong hindi manager, binabalewala ang mga NULL"
            },
            {
              "icon": "",
              "label": "Zero row ang ibinabalik nito — ang iisang NULL sa NOT IN list ay ginagawang UNKNOWN ang bawat comparison, kaya walang row na makakatugon sa condition"
            },
            {
              "icon": "",
              "label": "Nagbibigay ito ng error dahil hindi puwedeng gamitin ang NOT IN kasama ng mga subquery"
            },
            {
              "icon": "",
              "label": "Ibinabalik nito ang bawat empleyado, dahil itinuturing ang NULL bilang wildcard"
            }
          ]
        },
        {
          "question": "SELECT name FROM customers c WHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id). Ano ang ibabalik nito?",
          "options": [
            {
              "icon": "",
              "label": "Bawat customer na may kahit isang row sa orders — sinusuri lamang ng EXISTS kung nagbabalik ng anumang row ang subquery, hindi kung ano ang laman ng mga value nito"
            },
            {
              "icon": "",
              "label": "Bawat customer, dahil laging nagbabalik ng true ang SELECT 1"
            },
            {
              "icon": "",
              "label": "Isang error, dahil pumipili ang subquery ng numero sa halip na column name"
            },
            {
              "icon": "",
              "label": "Mga customer lamang na may eksaktong isang order"
            }
          ]
        },
        {
          "question": "Isinulat mo ang SELECT name, (SELECT order_id FROM orders WHERE customer_id = c.id) AS last_order FROM customers c, at ang isang partikular na customer ay may 3 row sa orders. Ano ang mangyayari kapag tumakbo ang query na ito?",
          "options": [
            {
              "icon": "",
              "label": "Ibinabalik nito ang unang tumutugmang order_id at tahimik na binabalewala ang dalawa pa"
            },
            {
              "icon": "",
              "label": "Ibinabalik nito ang comma-separated na listahan ng tatlong order_id"
            },
            {
              "icon": "",
              "label": "Ibinabalik nito ang 3 row para sa customer na iyon, isa bawat order"
            },
            {
              "icon": "",
              "label": "Nagbibigay ito ng error sa runtime — ang isang scalar subquery sa SELECT list ay dapat magbalik ng hindi hihigit sa isang row, at ang isang ito ay nagbabalik ng tatlo"
            }
          ]
        },
        {
          "question": "Apat na row ang tied para sa pinakamataas na score. Gamit ang RANK() ORDER BY score DESC, lahat ng apat ay nakakakuha ng rank 1. Anong rank ang makukuha ng susunod na row?",
          "options": [
            {
              "icon": "",
              "label": "5 — nag-iiwan ang RANK() ng gap na katumbas ng bilang ng mga tied row bago magpatuloy"
            },
            {
              "icon": "",
              "label": "2 — laging dumaragdag ang RANK() nang eksaktong isa pagkatapos ng anumang tie"
            },
            {
              "icon": "",
              "label": "1 — bawat kasunod na row ay nakakakuha rin ng rank 1"
            },
            {
              "icon": "",
              "label": "4 — nagsisimula ulit ang RANK() ng pagbibilang mula sa bilang ng mga tie"
            }
          ]
        },
        {
          "question": "Apat na row ang tied para sa pinakamataas na score. Gamit ang DENSE_RANK() ORDER BY score DESC, lahat ng apat ay nakakakuha ng rank 1. Anong rank ang makukuha ng susunod na row?",
          "options": [
            {
              "icon": "",
              "label": "5 — kumikilos ang DENSE_RANK() nang eksaktong tulad ng RANK()"
            },
            {
              "icon": "",
              "label": "1 — nagbibigay ang DENSE_RANK() ng parehong rank sa bawat natitirang row"
            },
            {
              "icon": "",
              "label": "2 — hindi kailanman nag-iiwan ng gap ang DENSE_RANK(), kaya ang susunod na distinct value ay laging nakakakuha ng susunod na consecutive rank"
            },
            {
              "icon": "",
              "label": "3 — nilalaktawan ng DENSE_RANK() ang isang rank bawat tie group"
            }
          ]
        },
        {
          "question": "Ang SUM(amount) OVER (PARTITION BY region ORDER BY amount) ay idinagdag sa isang query. Ano ang ginagawa ng PARTITION BY region dito?",
          "options": [
            {
              "icon": "",
              "label": "Sinisimulan nito ulit ang running sum nang hiwalay para sa bawat region, sa halip na mag-accumulate sa buong result set"
            },
            {
              "icon": "",
              "label": "Nagfi-filter ito ng mga resulta sa iisang region"
            },
            {
              "icon": "",
              "label": "Ginu-group at kina-collapse nito ang mga row sa isa bawat region, tulad ng GROUP BY"
            },
            {
              "icon": "",
              "label": "Ino-sort nito ang mga region nang alpabetikal bago magbuod"
            }
          ]
        },
        {
          "question": "Ang ROW_NUMBER() OVER (ORDER BY score DESC) ay inilalapat sa limang row, dalawa sa mga ito ay eksaktong tied sa score. Maaari bang makatanggap ang dalawang row ng parehong row number?",
          "options": [
            {
              "icon": "",
              "label": "Oo — laging pareho ang row number ng mga tied row"
            },
            {
              "icon": "",
              "label": "Kung ginamit din lamang ang PARTITION BY"
            },
            {
              "icon": "",
              "label": "Depende ito kung ang tie ay nasa una o huling posisyon"
            },
            {
              "icon": "",
              "label": "Hindi — laging nagbibigay ang ROW_NUMBER() ng natatangi, mahigpit na tumataas na integer sa bawat row, kahit na tied ang mga value"
            }
          ]
        },
        {
          "question": "WITH high_earners AS (SELECT * FROM employees WHERE salary > 100000) SELECT department, COUNT(*) FROM high_earners GROUP BY department. Ano ang high_earners?",
          "options": [
            {
              "icon": "",
              "label": "Isang common table expression (CTE) — isang pinangalanan, pansamantalang result set na puwedeng i-reference ng natitirang bahagi ng query tulad ng isang table"
            },
            {
              "icon": "",
              "label": "Isang permanenteng table na ginawa sa database"
            },
            {
              "icon": "",
              "label": "Isang view na nananatili pagkatapos matapos ang query"
            },
            {
              "icon": "",
              "label": "Isang stored procedure na kailangang tawagin nang hiwalay"
            }
          ]
        },
        {
          "question": "Ang isang column ay idineklarang PRIMARY KEY. Puwede ka bang mag-insert ng row kung saan NULL ang column na iyon?",
          "options": [
            {
              "icon": "",
              "label": "Oo — ang PRIMARY KEY lamang ay nag-e-enforce ng uniqueness, hindi ng NULL-ness"
            },
            {
              "icon": "",
              "label": "Oo, pero isang NULL row lang ang pinapayagan, tulad ng isang UNIQUE constraint"
            },
            {
              "icon": "",
              "label": "Hindi — ang isang PRIMARY KEY column ay implicitly NOT NULL, kaya tinatanggihan ang pag-insert ng NULL dito"
            },
            {
              "icon": "",
              "label": "Depende ito kung ang column ay may default value din"
            }
          ]
        },
        {
          "question": "Sa loob ng isang bukas na transaction, nagpatakbo ka ng UPDATE pero hindi mo pa pinatakbo ang COMMIT. Mula sa isang pangalawa, hiwalay na koneksyon sa database, nakikita ba ang update na iyon?",
          "options": [
            {
              "icon": "",
              "label": "Oo — nakikita ng lahat ng koneksyon ang bawat write sa mismong sandaling tumakbo ito"
            },
            {
              "icon": "",
              "label": "Oo, pero kung magbubukas din lamang ang pangalawang koneksyon ng transaction"
            },
            {
              "icon": "",
              "label": "Depende lamang ito sa kung aling table ang na-update"
            },
            {
              "icon": "",
              "label": "Hindi — ang isang uncommitted na pagbabago ay nakikita lamang sa loob ng transaction na gumawa nito, hanggang gawin itong durable at nakikita sa iba ng COMMIT"
            }
          ]
        },
        {
          "question": "Ang products.category_id ay may FOREIGN KEY constraint na tumutukoy sa categories.id. Sinusubukan mong i-DELETE ang isang row mula sa categories na may mga product pa ring tumuturo dito, na walang tinukoy na ON DELETE rule. Ano ang mangyayari?",
          "options": [
            {
              "icon": "",
              "label": "Nabubura ang category row at awtomatikong itinatakda sa NULL ang mga tumutugmang value ng products.category_id"
            },
            {
              "icon": "",
              "label": "Nabubura ang category row at nabubura rin ang bawat product na tumutukoy dito"
            },
            {
              "icon": "",
              "label": "Tinatanggihan ang DELETE — hinaharangan ng default na foreign key behavior ang pagbura sa isang referenced row habang may mga dependent row pa ring tumuturo dito"
            },
            {
              "icon": "",
              "label": "Nagtatagumpay ang DELETE nang tahimik, iniiwan ang category_id ng mga product na tumuturo sa isang category na wala nang umiiral"
            }
          ]
        }
      ],
      "optionOrderVersion": "e0466e547cfd8a45"
    }
  },
  "testNames": {
    "sql-test": "Pagsusulit sa SQL"
  }
}