{
  "assessmentTests": {
    "sql_test": {
      "name": "Teste SQL",
      "desc": "30 questões de cenários sobre filtragem, JOINs, agregação, subconsultas e funções de janela — descubra se seu SQL corresponde ao que uma vaga de emprego significa por proficiência em SQL.",
      "recommendation": "Seu perfil de habilidades em SQL",
      "results": {
        "beginner": {
          "name": "Iniciante",
          "desc": "Você consegue escrever um SELECT funcional e filtrar em poucas condições, mas as questões que você errou tendem a girar em torno do tratamento de NULL e da mecânica de JOINs em vez de sintaxe — comparando uma coluna com NULL usando =, o que um LEFT JOIN realmente preserva, como funcionam os limites do BETWEEN. Nada disso é sobre ser ruim em bancos de dados; essas são as regras específicas que tropeçam em pessoas que aprenderam SQL por tentativa e erro, não a partir do padrão. Importam no trabalho porque cada uma é o lugar onde uma query retorna uma contagem de linhas correta, mas com linhas erradas.",
          "recommendation": "Comece com três coisas, nesta ordem: por que WHERE col = NULL nunca encontra nada (e é necessário usar IS NULL), como um INNER JOIN descarta linhas não correspondidas enquanto um LEFT JOIN as mantém, e os limites exatos que o BETWEEN inclui. O tutorial SQL da Mode Analytics e a documentação do PostgreSQL cobrem todos os três com exemplos executáveis."
        },
        "intermediate": {
          "name": "Intermediário",
          "desc": "Você lida confortavelmente com queries de relatório do dia a dia — JOINs, GROUP BY, filtragem direta — e não seria desacelerado por trabalho de dashboard rotineiro ou análise ad-hoc. A diferença entre aqui e Avançado está principalmente no que acontece quando as cláusulas interagem: uma cláusula WHERE na tabela certa de um LEFT JOIN silenciosamente transformando-o de volta em um INNER JOIN, um JOIN que multiplica contagens de linhas antes de um agregado ser aplicado a elas, um NOT IN que silenciosamente retorna nada porque um NULL entrou na subconsulta. Esse é o tipo de bug que passa por uma conferência rápida e só aparece quando alguém compara o total com um relatório diferente.",
          "recommendation": "Concentre-se em como as cláusulas interagem, em vez do que cada uma faz sozinha: filtragem WHERE em colunas à direita de um LEFT JOIN, multiplicação de linhas de JOINs um-para-muitos antes de agregar, e por que NOT IN quebra na presença de NULLs (EXISTS geralmente não quebra). Depois HAVING versus WHERE, já que essa divisão tropeça em pessoas que já conhecem ambas as cláusulas individualmente."
        },
        "advanced": {
          "name": "Avançado",
          "desc": "Este é o nível que a maioria das vagas significa por \"SQL Forte\". Você lê uma query com múltiplos JOINs e consegue prever sua contagem de linhas antes de executar, você sabe por que um conjunto de resultados mudou, e usa um CTE ou uma função de janela em vez de uma subconsulta aninhada quando essa for a ferramenta mais clara. O que separa esse nível do topo é o lado defensivo do trabalho: saber qual função de ranking usar quando empates importam, o que uma TRANSACTION isola de uma sessão concorrente, e o que uma regra ON DELETE ausente realmente faz no nível do banco de dados.",
          "recommendation": "Aprofunde-se nas partes que protegem dados que outras pessoas também tocam: a diferença entre RANK, DENSE_RANK e ROW_NUMBER com empates, o que COMMIT realmente torna visível e para quem, e o comportamento de chaves estrangeiras em DELETE. Use os mergulhos profundos da newsletter The Index ou SQL for Devs sobre funções de janela e isolamento de transação como próximo passo para ambos."
        },
        "expert": {
          "name": "Especialista",
          "desc": "Você pontuou no topo de cada seção — filtragem e semântica de NULL, JOINs e operações de conjunto, agregação e subconsultas, e funções de janela, CTEs e constraints. Praticamente, isso significa que você pode receber uma query de relatório com múltiplos JOINs de alguém desconhecido e explicar por que ela retorna a contagem de linhas que retorna, não apenas o que a sintaxe diz que deveria fazer, que é a habilidade mais difícil e mais valiosa. Nesse nível, a linguagem de query raramente é o fator limitante; o limite geralmente é o design do schema ou o tamanho dos dados debaixo dele.",
          "recommendation": "Os retornos agora estão em planos de execução e design: ler saída EXPLAIN antes de assumir que uma query é lenta, estratégia de indexação como uma troca contra o custo de escrita em vez de uma vitória gratuita, e decisões de normalização que resistem conforme um schema cresce. Se você está sendo avaliado para uma vaga, descreva um bug de query como o fan-out de JOIN ou a armadilha NOT IN/NULL que você encontrou em produção, em vez de nomear recursos SQL — isso demonstra o raciocínio, não apenas o vocabulário."
        }
      },
      "questions": [
        {
          "question": "Uma tabela tem uma coluna age anulável. Você executa SELECT * FROM users WHERE age = NULL. Quantas linhas isso retorna, mesmo que várias linhas tenham age definido como NULL?",
          "options": [
            {
              "icon": "",
              "label": "Toda linha onde age é NULL, porque = encontra NULL como qualquer outro valor"
            },
            {
              "icon": "",
              "label": "Zero — comparar qualquer coisa com NULL usando = produz UNKNOWN, nunca TRUE, então nenhuma linha corresponde; é necessário usar IS NULL"
            },
            {
              "icon": "",
              "label": "Um erro de sintaxe — NULL não pode aparecer no lado direito de ="
            },
            {
              "icon": "",
              "label": "Toda linha na tabela, porque comparações com NULL retornam TRUE por padrão"
            }
          ]
        },
        {
          "question": "Você executa SELECT DISTINCT department, role FROM employees. O que DISTINCT remove duplicatas de?",
          "options": [
            {
              "icon": "",
              "label": "A combinação de department e role juntos — uma linha é removida apenas se ambas as colunas combinam exatamente com outra linha"
            },
            {
              "icon": "",
              "label": "Apenas valores department duplicados, mantendo cada role"
            },
            {
              "icon": "",
              "label": "Apenas valores role duplicados, mantendo cada department"
            },
            {
              "icon": "",
              "label": "Nada — DISTINCT só funciona com uma única coluna"
            }
          ]
        },
        {
          "question": "Uma coluna name é filtrada com WHERE name LIKE 'A_'. Qual desses valores encontra: 'A', 'Al', 'Ana', 'Ally'?",
          "options": [
            {
              "icon": "",
              "label": "'A' — o underscore é opcional e encontra zero ou mais caracteres"
            },
            {
              "icon": "",
              "label": "'Al' — o underscore encontra exatamente um caractere, então LIKE 'A_' encontra qualquer string de dois caracteres começando com A"
            },
            {
              "icon": "",
              "label": "'Ana' e 'Ally' — o underscore encontra qualquer número de caracteres à direita"
            },
            {
              "icon": "",
              "label": "Todos os quatro valores encontram, porque LIKE ignora tamanho"
            }
          ]
        },
        {
          "question": "Uma coluna price é filtrada com WHERE price BETWEEN 10 AND 20. Linhas com price exatamente 10 ou exatamente 20 são incluídas?",
          "options": [
            {
              "icon": "",
              "label": "Não — BETWEEN exclui ambos os extremos"
            },
            {
              "icon": "",
              "label": "Sim — BETWEEN é inclusivo em ambos os extremos, equivalente a price >= 10 AND price <= 20"
            },
            {
              "icon": "",
              "label": "Apenas price = 10 é incluído; o limite superior é exclusivo"
            },
            {
              "icon": "",
              "label": "Apenas price = 20 é incluído; o limite inferior é exclusivo"
            }
          ]
        },
        {
          "question": "Uma tabela orders tem 10 linhas, e 3 delas têm shipped_date como NULL. O que SELECT COUNT(*) FROM orders retorna, e o que SELECT COUNT(shipped_date) FROM orders retorna?",
          "options": [
            {
              "icon": "",
              "label": "10, depois 10 — COUNT sempre conta linhas, independentemente de NULLs"
            },
            {
              "icon": "",
              "label": "7, depois 7 — ambas as formas pulam linhas com NULL"
            },
            {
              "icon": "",
              "label": "10, depois 7 — COUNT(*) conta toda linha, COUNT(column) conta apenas linhas onde essa coluna não é NULL"
            },
            {
              "icon": "",
              "label": "10, depois 3 — COUNT(column) conta apenas os valores NULL"
            }
          ]
        },
        {
          "question": "Você executa SELECT name, salary FROM employees ORDER BY 2 DESC. A que o 2 se refere?",
          "options": [
            {
              "icon": "",
              "label": "Um erro de sintaxe — ORDER BY só aceita nomes de colunas, não números"
            },
            {
              "icon": "",
              "label": "A segunda linha do resultado"
            },
            {
              "icon": "",
              "label": "Um valor literal de 2, usado como desempate"
            },
            {
              "icon": "",
              "label": "A segunda coluna na lista SELECT, salary — ORDER BY aceita o número de posição de uma coluna como atalho"
            }
          ]
        },
        {
          "question": "Em SQL padrão, o que 'Ana' || ' ' || 'Lee' avalia para?",
          "options": [
            {
              "icon": "",
              "label": "Um erro de sintaxe — SQL não tem operador de concatenação"
            },
            {
              "icon": "",
              "label": "3 — || é tratado como um OR booleano e retorna uma contagem"
            },
            {
              "icon": "",
              "label": "'AnaLee' — || concatena sem preservar espaços"
            },
            {
              "icon": "",
              "label": "'Ana Lee' — || é o operador padrão de concatenação de strings em SQL"
            }
          ]
        },
        {
          "question": "Qual desses é exatamente equivalente a 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 tem 100 linhas; 20 delas nunca fizeram um pedido. Você executa SELECT c.id FROM customers c INNER JOIN orders o ON c.id = o.customer_id. Os 20 clientes sem pedidos aparecem no resultado?",
          "options": [
            {
              "icon": "",
              "label": "Sim, uma vez cada, com o.id mostrado como NULL"
            },
            {
              "icon": "",
              "label": "Sim, mas apenas se também aparecerem em uma cláusula WHERE"
            },
            {
              "icon": "",
              "label": "Não — INNER JOIN retorna apenas linhas que têm uma correspondência em ambas as tabelas, então clientes sem pedidos são descartados completamente"
            },
            {
              "icon": "",
              "label": "Sim, duplicadas uma vez por coluna em orders"
            }
          ]
        },
        {
          "question": "Você quer todo cliente, independente de ter pedidos, então você escreve SELECT c.id, o.total FROM customers c LEFT JOIN orders o ON c.id = o.customer_id WHERE o.total > 100. Isso ainda retorna clientes sem pedidos?",
          "options": [
            {
              "icon": "",
              "label": "Não — filtrar em o.total na cláusula WHERE descarta as linhas NULL que LEFT JOIN produziu para clientes não encontrados, então se comporta como um INNER JOIN"
            },
            {
              "icon": "",
              "label": "Sim — LEFT JOIN sempre preserva toda linha de customers, não importa o que venha depois"
            },
            {
              "icon": "",
              "label": "Sim, com o.total mostrado como 0 para clientes sem pedidos"
            },
            {
              "icon": "",
              "label": "Não — LEFT JOIN silenciosamente se converte em um RIGHT JOIN quando uma cláusula WHERE é adicionada"
            }
          ]
        },
        {
          "question": "Uma tabela employees tem uma coluna id e uma coluna manager_id que aponta para outra linha id. Para listar cada funcionário ao lado do nome de seu gerente, você faz JOIN da tabela consigo mesma: SELECT e.name, m.name FROM employees e JOIN employees m ON e.manager_id = m.id. Como esse padrão é chamado?",
          "options": [
            {
              "icon": "",
              "label": "Um CROSS JOIN — todo funcionário é combinado com todo gerente"
            },
            {
              "icon": "",
              "label": "Um JOIN recursivo — ele busca a cadeia completa de gerenciamento"
            },
            {
              "icon": "",
              "label": "Um self-join — a mesma tabela faz JOIN consigo mesma usando dois aliases diferentes"
            },
            {
              "icon": "",
              "label": "Isso é SQL inválido — uma tabela não pode fazer JOIN consigo mesma"
            }
          ]
        },
        {
          "question": "Duas queries SELECT com as mesmas colunas são combinadas com UNION. Se ambas as queries retornam uma linha idêntica, quantas cópias dessa linha aparecem no resultado final?",
          "options": [
            {
              "icon": "",
              "label": "Uma — UNION remove linhas duplicadas no resultado combinado; UNION ALL manteria ambas as cópias"
            },
            {
              "icon": "",
              "label": "Duas — UNION mantém toda linha de ambas as queries"
            },
            {
              "icon": "",
              "label": "Zero — UNION remove qualquer linha que apareça em ambas as queries"
            },
            {
              "icon": "",
              "label": "Depende de qual query listou a linha primeiro"
            }
          ]
        },
        {
          "question": "A tabela sizes tem 3 linhas e colors tem 4 linhas. Quantas linhas SELECT * FROM sizes CROSS JOIN colors retorna?",
          "options": [
            {
              "icon": "",
              "label": "7 — CROSS JOIN adiciona as contagens de linhas"
            },
            {
              "icon": "",
              "label": "12 — um CROSS JOIN retorna toda combinação possível de linhas de ambas as tabelas (3 x 4)"
            },
            {
              "icon": "",
              "label": "3 — CROSS JOIN retorna uma linha por linha na primeira tabela"
            },
            {
              "icon": "",
              "label": "0 — CROSS JOIN requer uma condição ON ou não retorna nada"
            }
          ]
        },
        {
          "question": "orders tem 1 linha para order #100, e order_items tem 3 linhas para order #100 (uma por item de linha). Você executa SELECT o.id, o.total FROM orders o JOIN order_items i ON o.id = i.order_id WHERE o.id = 100. Quantas linhas retornam para order #100?",
          "options": [
            {
              "icon": "",
              "label": "3 — o JOIN produz uma linha de saída por linha de order_items, então a linha única de order #100 é repetida uma vez por item de linha"
            },
            {
              "icon": "",
              "label": "1 — orders tem apenas uma linha para order #100, então o JOIN não pode produzir mais"
            },
            {
              "icon": "",
              "label": "4 — uma linha para o pedido mais uma por item de linha"
            },
            {
              "icon": "",
              "label": "0 — fazer JOIN de uma tabela de uma linha com uma tabela de três linhas em uma chave não única falha"
            }
          ]
        },
        {
          "question": "SELECT c.name, o.id FROM customers c RIGHT JOIN orders o ON c.id = o.customer_id retorna as mesmas linhas que qual dessas?",
          "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 — trocar a ordem das tabelas e usar LEFT JOIN em vez de RIGHT JOIN é equivalente"
            },
            {
              "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": "Em SQL padrão, você executa SELECT department, name, AVG(salary) FROM employees GROUP BY department. Isso é uma query válida?",
          "options": [
            {
              "icon": "",
              "label": "Sim — GROUP BY só precisa incluir department porque está listado primeiro"
            },
            {
              "icon": "",
              "label": "Não — name é selecionado mas nem agregado nem listado em GROUP BY, e SQL padrão exige que toda coluna não agregada selecionada apareça na cláusula GROUP BY"
            },
            {
              "icon": "",
              "label": "Sim — SQL automaticamente escolhe um name arbitrário por department"
            },
            {
              "icon": "",
              "label": "Não — AVG() não pode ser combinado com GROUP BY na mesma query"
            }
          ]
        },
        {
          "question": "Você quer departments cuja média salarial ultrapassa 80000. Qual cláusula filtra em um valor agregado como AVG(salary) após agrupamento — WHERE ou HAVING?",
          "options": [
            {
              "icon": "",
              "label": "WHERE — HAVING é usada apenas com queries UNION"
            },
            {
              "icon": "",
              "label": "Qualquer uma funciona identicamente com funções de agregação"
            },
            {
              "icon": "",
              "label": "Nenhuma — filtragem de agregação requer uma subconsulta"
            },
            {
              "icon": "",
              "label": "HAVING — WHERE filtra linhas individuais antes do agrupamento, HAVING filtra grupos após agregação"
            }
          ]
        },
        {
          "question": "Você escreve SELECT salary * 1.1 AS new_salary FROM employees WHERE new_salary > 50000. Isso executa?",
          "options": [
            {
              "icon": "",
              "label": "Sim — aliases definidos em SELECT sempre estão disponíveis para WHERE na mesma query"
            },
            {
              "icon": "",
              "label": "Sim, mas apenas para aliases numéricos"
            },
            {
              "icon": "",
              "label": "Não — AS não é permitido dentro de uma query filtrada por WHERE"
            },
            {
              "icon": "",
              "label": "Não — WHERE é avaliado antes de SELECT atribuir o alias new_salary, então o alias não existe ainda nesse ponto da execução"
            }
          ]
        },
        {
          "question": "SELECT name FROM employees e WHERE salary > (SELECT AVG(salary) FROM employees WHERE department = e.department). Por que isso é chamado de subconsulta correlacionada?",
          "options": [
            {
              "icon": "",
              "label": "Porque usa um JOIN em vez de uma cláusula WHERE"
            },
            {
              "icon": "",
              "label": "A subconsulta interna referencia e.department da query externa, então precisa ser re-avaliada para toda linha que a query externa considera"
            },
            {
              "icon": "",
              "label": "Porque retorna mais de uma coluna"
            },
            {
              "icon": "",
              "label": "Porque executa exatamente uma vez antes da query externa começar"
            }
          ]
        },
        {
          "question": "Uma subconsulta SELECT manager_id FROM employees retorna alguns valores NULL junto com IDs reais. Você executa SELECT name FROM employees WHERE id NOT IN (SELECT manager_id FROM employees). O que acontece?",
          "options": [
            {
              "icon": "",
              "label": "Retorna todo funcionário que não é gerente, ignorando os NULLs"
            },
            {
              "icon": "",
              "label": "Retorna zero linhas — um único NULL na lista NOT IN torna toda comparação UNKNOWN, então nenhuma linha pode satisfazer a condição"
            },
            {
              "icon": "",
              "label": "Levanta um erro porque NOT IN não pode ser usado com subconsultas"
            },
            {
              "icon": "",
              "label": "Retorna todo funcionário, já que NULL é tratado como um coringa"
            }
          ]
        },
        {
          "question": "SELECT name FROM customers c WHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id). O que isso retorna?",
          "options": [
            {
              "icon": "",
              "label": "Todo cliente que tem pelo menos uma linha em orders — EXISTS só verifica se a subconsulta retorna alguma linha, não quais valores elas contêm"
            },
            {
              "icon": "",
              "label": "Todo cliente, porque SELECT 1 sempre retorna verdadeiro"
            },
            {
              "icon": "",
              "label": "Um erro, porque a subconsulta seleciona um número em vez de um nome de coluna"
            },
            {
              "icon": "",
              "label": "Apenas clientes com exatamente um pedido"
            }
          ]
        },
        {
          "question": "Você escreve SELECT name, (SELECT order_id FROM orders WHERE customer_id = c.id) AS last_order FROM customers c, e um cliente específico tem 3 linhas em orders. O que acontece quando essa query executa?",
          "options": [
            {
              "icon": "",
              "label": "Retorna o primeiro order_id encontrado e silenciosamente ignora os outros dois"
            },
            {
              "icon": "",
              "label": "Retorna uma lista separada por vírgulas de todos os três order_ids"
            },
            {
              "icon": "",
              "label": "Retorna 3 linhas para esse cliente, uma por pedido"
            },
            {
              "icon": "",
              "label": "Levanta um erro em tempo de execução — uma subconsulta escalar na lista SELECT deve retornar no máximo uma linha, e essa retorna três"
            }
          ]
        },
        {
          "question": "Quatro linhas empatam pela pontuação mais alta. Usando RANK() ORDER BY score DESC, as quatro recebem rank 1. Que rank a próxima linha abaixo recebe?",
          "options": [
            {
              "icon": "",
              "label": "5 — RANK() deixa um espaço igual ao número de linhas empatadas antes de continuar"
            },
            {
              "icon": "",
              "label": "2 — RANK() sempre incrementa exatamente um após qualquer empate"
            },
            {
              "icon": "",
              "label": "1 — toda linha subsequente também recebe rank 1"
            },
            {
              "icon": "",
              "label": "4 — RANK() reinicia a contagem do número de empates"
            }
          ]
        },
        {
          "question": "Quatro linhas empatam pela pontuação mais alta. Usando DENSE_RANK() ORDER BY score DESC, as quatro recebem rank 1. Que rank a próxima linha abaixo recebe?",
          "options": [
            {
              "icon": "",
              "label": "5 — DENSE_RANK() se comporta exatamente como RANK()"
            },
            {
              "icon": "",
              "label": "1 — DENSE_RANK() atribui o mesmo rank a toda linha restante"
            },
            {
              "icon": "",
              "label": "2 — DENSE_RANK() nunca deixa espaços, então o próximo valor distinto sempre recebe o próximo rank consecutivo"
            },
            {
              "icon": "",
              "label": "3 — DENSE_RANK() pula um rank por grupo de empate"
            }
          ]
        },
        {
          "question": "SUM(amount) OVER (PARTITION BY region ORDER BY amount) é adicionado a uma query. O que PARTITION BY region faz aqui?",
          "options": [
            {
              "icon": "",
              "label": "Reinicia a soma corrente separadamente para cada region, em vez de acumular em todo o conjunto de resultados"
            },
            {
              "icon": "",
              "label": "Filtra os resultados para uma única region"
            },
            {
              "icon": "",
              "label": "Agrupa e colapsa as linhas em uma por region, como GROUP BY"
            },
            {
              "icon": "",
              "label": "Ordena as regions alfabeticamente antes de somar"
            }
          ]
        },
        {
          "question": "ROW_NUMBER() OVER (ORDER BY score DESC) é aplicado a cinco linhas, duas das quais empatam exatamente em score. Duas linhas podem nunca receber o mesmo número de linha?",
          "options": [
            {
              "icon": "",
              "label": "Sim — linhas empatadas sempre compartilham o mesmo número de linha"
            },
            {
              "icon": "",
              "label": "Apenas se PARTITION BY também for usado"
            },
            {
              "icon": "",
              "label": "Depende se o empate está na primeira ou última posição"
            },
            {
              "icon": "",
              "label": "Não — ROW_NUMBER() sempre atribui um inteiro único e estritamente crescente a toda linha, mesmo quando valores empatam"
            }
          ]
        },
        {
          "question": "WITH high_earners AS (SELECT * FROM employees WHERE salary > 100000) SELECT department, COUNT(*) FROM high_earners GROUP BY department. O que é high_earners?",
          "options": [
            {
              "icon": "",
              "label": "Uma expressão de tabela comum (CTE) — um conjunto de resultados temporário nomeado que o resto da query pode referenciar como uma tabela"
            },
            {
              "icon": "",
              "label": "Uma tabela permanente criada no banco de dados"
            },
            {
              "icon": "",
              "label": "Uma view que persiste após a query terminar"
            },
            {
              "icon": "",
              "label": "Um procedimento armazenado que precisa ser chamado separadamente"
            }
          ]
        },
        {
          "question": "Uma coluna é declarada PRIMARY KEY. Você pode inserir uma linha onde essa coluna é NULL?",
          "options": [
            {
              "icon": "",
              "label": "Sim — PRIMARY KEY só força unicidade, não NULL-ness"
            },
            {
              "icon": "",
              "label": "Sim, mas apenas uma linha NULL é permitida, igual a uma constraint UNIQUE"
            },
            {
              "icon": "",
              "label": "Não — uma coluna PRIMARY KEY é implicitamente NOT NULL, então inserir NULL nela é rejeitado"
            },
            {
              "icon": "",
              "label": "Depende se a coluna também tem um valor padrão"
            }
          ]
        },
        {
          "question": "Dentro de uma transação aberta, você executa um UPDATE mas ainda não executou COMMIT. De uma segunda conexão separada com o banco de dados, essa atualização é visível?",
          "options": [
            {
              "icon": "",
              "label": "Sim — todas as conexões veem toda escrita no instante em que executa"
            },
            {
              "icon": "",
              "label": "Sim, mas apenas se a segunda conexão também abre uma transação"
            },
            {
              "icon": "",
              "label": "Depende apenas de qual tabela foi atualizada"
            },
            {
              "icon": "",
              "label": "Não — uma mudança não confirmada é visível apenas dentro da transação que a fez, até COMMIT torná-la durável e visível para outros"
            }
          ]
        },
        {
          "question": "products.category_id tem uma constraint FOREIGN KEY referenciando categories.id. Você tenta DELETE uma linha de categories que ainda tem products apontando para ela, sem nenhuma regra ON DELETE especificada. O que acontece?",
          "options": [
            {
              "icon": "",
              "label": "A linha de categoria é deletada e os valores products.category_id correspondentes são automaticamente definidos como NULL"
            },
            {
              "icon": "",
              "label": "A linha de categoria é deletada e todo product que a referenciava é deletado também"
            },
            {
              "icon": "",
              "label": "O DELETE é rejeitado — o comportamento padrão de chave estrangeira bloqueia deletar uma linha referenciada enquanto linhas dependentes ainda apontam para ela"
            },
            {
              "icon": "",
              "label": "O DELETE sucede silenciosamente, deixando o products.category_id apontando para uma categoria que não existe mais"
            }
          ]
        }
      ],
      "optionOrderVersion": "e0466e547cfd8a45"
    }
  }
}