Considere que você esteja trabalhando com bancos de dados que contêm informações sobre livros e autores utilizando o SGBD SQLServer.
Analise o script a seguir.
CREATE TABLE #Livros (
LivroID INT,
Titulo VARCHAR(100)
);
CREATE TABLE #Autores (
Nome VARCHAR(100),
LivroID INT
);
Avalie se os itens a seguir apresentam a escrita correta em uma consulta SQL nesse banco, que faça um JOIN entre as tabelas de livros e autores, em que cada livro é listado junto com uma lista de todos os seus autores (nomes de autores agregados em uma única String).
I. SELECT L.Titulo, STRING_AGG(A.Nome, ', ') AS
Autores FROM #Livros L
INNER JOIN #Autores A ON L.LivroID = A.LivroID
GROUP BY L.Titulo;
II. SELECT L.Titulo, GROUP_CONTACT(A.Nome, ', ') AS
Autores FROM Livros L
JOIN Autores A ON L.LivroID = A.LivroID
GROUP BY L.AutorID;
III. SELECT L.Titulo, STRING_AGG(A.Nome) AS
Autores FROM Livros L
JOIN Autores A ON L.LivroID = A.LivroID
GROUP BY L.Titulo
IV. SELECT L.Titulo, STRING_AGG(A.Nome) AS Autores FROM
#Livros L
LEFT JOIN #Autores A ON L.LivroID = A.LivroID
GROUP BY L.Titulo, A.Nome;
A escrita dessa consulta SQL está correta em
AI, apenas.
BIV, apenas.
CI e III, apenas.
DI e IV, apenas.
EI, III e IV.
Revelar gabarito e comentário▾
GabaritoA — I, apenas.
Comentário gerado por IA. É um apoio ao estudo, ancorado em fontes, mas pode conter imprecisões — confira sempre na fonte oficial (lei, súmula, edital e gabarito da banca). Encontrou um erro? Use “Reportar”.
SQL Server: STRING_AGG e agregação de strings
Gabarito: letra A — apenas o item I está correto. No SQL Server, a função correta para concatenar valores de uma coluna em uma única string é STRING_AGG, que exige o separador como segundo argumento; o item I a utiliza corretamente com INNER JOIN e GROUP BY L.Titulo. Os demais itens falham por usar função inexistente (GROUP_CONTACT), omitir o separador obrigatório, agrupar por coluna inexistente ou incluir coluna não agregada no GROUP BY.
A questão cobra um ponto específico do SQL Server: a agregação de strings. Quando você precisa listar, para cada livro, todos os seus autores em uma única string separada por vírgula, a função correta é STRING_AGG. Ela é uma função de agregação, como SUM ou COUNT, mas que concatena valores de texto. A sintaxe básica é STRING_AGG(coluna, separador), e o separador é obrigatório — omiti-lo gera erro de sintaxe. Além disso, como toda função de agregação, ela exige que as demais colunas do SELECT estejam no GROUP BY.
Vamos entender o cenário: temos duas tabelas temporárias, #Livros e #Autores, relacionadas por LivroID. O objetivo é produzir um relatório em que cada linha mostra o título do livro e a lista de autores. Para isso, precisamos juntar as tabelas (via JOIN), agrupar por título (via GROUP BY) e agregar os nomes (via STRING_AGG). O item I faz exatamente isso: usa INNER JOIN para combinar as tabelas, GROUP BY L.Titulo para agrupar por livro e STRING_AGG(A.Nome, ', ') para concatenar os nomes com vírgula e espaço. É a escrita correta.
A pegadinha da banca está em dois pontos: primeiro, a função GROUP_CONTACT não existe no SQL Server — ela é do MySQL (no MySQL, a função é GROUP_CONCAT). Segundo, o STRING_AGG exige o separador como segundo argumento; sem ele, a consulta falha. Além disso, o item IV comete um erro sutil: inclui A.Nome no GROUP BY, o que quebra a agregação — cada autor vira um grupo separado, e o STRING_AGG não agrega nada. O item II ainda agrupa por L.AutorID, coluna que nem existe na tabela #Livros.
Guarde a fronteira entre STRING_AGG (SQL Server) e GROUP_CONCAT (MySQL): é exatamente nela que as alternativas se dividem, junto com a obrigatoriedade do separador e a correta composição do GROUP BY.
Item
Função usada
Separador obrigatório
Tabelas referenciadas
GROUP BY
Veredito
I
STRING_AGG (correta)
Sim (', ')
#Livros e #Autores (corretas)
L.Titulo (correto)
✅ Correto
II
GROUP_CONTACT (inexistente)
—
Livros e Autores (sem #)
L.AutorID (coluna inexistente)
❌ Incorreto
III
STRING_AGG (correta)
Não (omitido)
Livros e Autores (sem #)
—
❌ Incorreto
IV
STRING_AGG (correta)
Sim
#Livros e #Autores (corretas)
L.Titulo, A.Nome (quebra agregação)
❌ Incorreto
STRING_AGG (SQL Server): Sintaxe (STRING_AGG(coluna, separador), Separador é obrigatório); GROUP BY (Só colunas não agregadas, Incluir A.Nome quebra agregação); Confusões comuns (GROUP_CONTACT (não existe), GROUP_CONCAT (MySQL))
Item I — ✅ Correto
Este item está correto. Ele usa STRING_AGG(A.Nome, ', ') com o separador obrigatório, faz o INNER JOIN entre #Livros e #Autores pela chave LivroID, e agrupa por L.Titulo. Como Titulo é a única coluna não agregada no SELECT, o GROUP BY está correto. A consulta produz exatamente o que o enunciado pede: cada livro com a lista de autores concatenada.
Item II — ❌ Incorreto
Este item está incorreto por três motivos. Primeiro, usa GROUP_CONTACT, função que não existe no SQL Server — a função correta é STRING_AGG (no MySQL seria GROUP_CONCAT). Segundo, referencia as tabelas Livros e Autores sem o prefixo #, mas as tabelas criadas no script são temporárias (#Livros e #Autores), então a consulta nem encontraria as tabelas. Terceiro, agrupa por L.AutorID, coluna que não existe na tabela #Livros — o correto seria agrupar por L.Titulo.
Item III — ❌ Incorreto
Este item está incorreto porque omite o separador no STRING_AGG. A sintaxe correta é STRING_AGG(A.Nome, ', ') — o segundo argumento (separador) é obrigatório no SQL Server. Sem ele, a consulta gera erro de sintaxe. Além disso, referencia as tabelas Livros e Autores sem o prefixo #, mas as tabelas criadas são temporárias (#Livros e #Autores).
Item IV — ❌ Incorreto
Este item está incorreto porque inclui A.Nome no GROUP BY. Ao agrupar por L.Titulo, A.Nome, cada combinação de livro e autor vira um grupo separado, e o STRING_AGG não agrega nada — cada grupo terá apenas um nome. O correto seria agrupar apenas por L.Titulo. Além disso, o LEFT JOIN é aceitável (preservaria livros sem autores), mas o GROUP BY errado invalida a consulta.
NÃO CAIA NESSA!
A banca explora duas confusões clássicas: (1) trocar STRING_AGG por GROUP_CONTACT, que é uma função do MySQL (e mesmo lá o nome correto é GROUP_CONCAT); (2) omitir o separador obrigatório no STRING_AGG. Fique atento: no SQL Server, STRING_AGGsempre exige o separador como segundo argumento, e o GROUP BY deve conter apenas as colunas não agregadas do SELECT.
PEGA ESSA DICA!
Para resolver questões de agregação de strings, verifique três pontos na ordem: (1) a função é STRING_AGG no SQL Server (não GROUP_CONCAT nem GROUP_CONTACT); (2) o separador está presente como segundo argumento; (3) o GROUP BY contém exatamente as colunas não agregadas do SELECT. Se qualquer um falhar, o item está errado.