Aqui estão sete maneiras de retornar linhas duplicadas no MariaDB quando essas linhas têm uma chave primária ou outra coluna de identificador exclusivo.
Portanto, as linhas duplicadas compartilham exatamente os mesmos valores em todas as colunas, exceto em sua coluna de identificador exclusivo.
Dados de amostra
Usaremos os seguintes dados para nossos exemplos:
SELECT * FROM Dogs;Resultado:
+-------+-----------+----------+ | DogId | FirstName | LastName | +-------+-----------+----------+ | 1 | Bark | Smith | | 2 | Bark | Smith | | 3 | Woof | Jones | | 4 | Ruff | Robinson | | 5 | Wag | Johnson | | 6 | Wag | Johnson | | 7 | Wag | Johnson | +-------+-----------+----------+
As duas primeiras linhas são duplicadas (exceto para o
DogId coluna, que é a chave primária da tabela e contém um valor exclusivo em todas as linhas). As últimas três linhas também são duplicadas (exceto para o DogId coluna). A coluna de chave primária garante que não haja linhas duplicadas, o que normalmente é bom em RDBMSs. No entanto, por definição, isso significa que não há duplicatas. No nosso caso, a coluna de chave primária é um número crescente e seu valor não tem significado e não é significativo. Portanto, precisamos ignorar essa linha se quisermos encontrar duplicatas nas colunas que são significativo.
Opção 1
Podemos usar o
GROUP BY cláusula para agrupar as colunas por suas colunas significativas, então use o COUNT() função para retornar o número de linhas idênticas:SELECT
FirstName,
LastName,
COUNT(*) AS Count
FROM Dogs
GROUP BY FirstName, LastName;Resultado:
+-----------+----------+-------+ | FirstName | LastName | Count | +-----------+----------+-------+ | Bark | Smith | 2 | | Ruff | Robinson | 1 | | Wag | Johnson | 3 | | Woof | Jones | 1 | +-----------+----------+-------+
Conseguimos excluir a coluna de chave primária omitindo-a de nossa consulta.
O resultado nos diz que existem duas linhas contendo Bark Smith e três linhas contendo Wag Johnson. Estes são duplicados (ou triplicados no caso de Wag Johnson). As outras duas linhas não têm duplicatas.
Opção 2
Podemos excluir não duplicados da saída com o
HAVING cláusula:SELECT
FirstName,
LastName,
COUNT(*) AS Count
FROM Dogs
GROUP BY FirstName, LastName
HAVING COUNT(*) > 1;Resultado:
+-----------+----------+-------+ | FirstName | LastName | Count | +-----------+----------+-------+ | Bark | Smith | 2 | | Wag | Johnson | 3 | +-----------+----------+-------+
Opção 3
Também é possível verificar duplicatas em colunas concatenadas. Por exemplo, podemos usar o
CONCAT() função para concatenar nossas duas colunas, use a função DISTINCT palavra-chave para obter valores distintos, então use o COUNT() função para retornar a contagem:SELECT
DISTINCT CONCAT(FirstName, ' ', LastName) AS DogName,
COUNT(*) AS Count
FROM Dogs
GROUP BY CONCAT(FirstName, ' ', LastName);Resultado:
+---------------+-------+ | DogName | Count | +---------------+-------+ | Bark Smith | 2 | | Ruff Robinson | 1 | | Wag Johnson | 3 | | Woof Jones | 1 | +---------------+-------+
Opção 4
Podemos usar o
ROW_NUMBER() função com a função PARTITION BY cláusula:SELECT
*,
ROW_NUMBER() OVER (
PARTITION BY FirstName, LastName
ORDER BY FirstName, LastName
) AS Row_Number
FROM Dogs;Resultado:
+-------+-----------+----------+------------+ | DogId | FirstName | LastName | Row_Number | +-------+-----------+----------+------------+ | 1 | Bark | Smith | 1 | | 2 | Bark | Smith | 2 | | 4 | Ruff | Robinson | 1 | | 6 | Wag | Johnson | 1 | | 5 | Wag | Johnson | 2 | | 7 | Wag | Johnson | 3 | | 3 | Woof | Jones | 1 | +-------+-----------+----------+------------+
Isso cria uma nova coluna com um número de linha que aumenta cada vez que há uma duplicata, mas reinicia novamente quando há uma linha única.
Nesse caso, não estamos agrupando os resultados, o que significa que podemos ver cada linha duplicada, incluindo sua coluna de identificador exclusivo.
Opção 5
Também podemos usar o exemplo anterior como uma expressão de tabela comum em uma consulta maior:
WITH cte AS
(
SELECT
*,
ROW_NUMBER() OVER (
PARTITION BY FirstName, LastName
ORDER BY FirstName, LastName
) AS Row_Number
FROM Dogs
)
SELECT * FROM cte WHERE Row_Number <> 1;Resultado:
+-------+-----------+----------+------------+ | DogId | FirstName | LastName | Row_Number | +-------+-----------+----------+------------+ | 2 | Bark | Smith | 2 | | 5 | Wag | Johnson | 2 | | 7 | Wag | Johnson | 3 | +-------+-----------+----------+------------+
Isso exclui não duplicados da saída e exclui uma linha de cada duplicata da saída.
Essa consulta pode ser usada como precursora de uma operação de desduplicação. Ele pode nos mostrar o que será excluído se decidirmos excluir duplicatas. Para desduplicar a tabela, tudo o que precisamos fazer é substituir o último
SELECT * com DELETE . Opção 6
Aqui está uma maneira mais sucinta de obter a mesma saída do exemplo anterior:
SELECT * FROM Dogs
WHERE DogId IN (
SELECT DogId FROM Dogs
EXCEPT SELECT MIN(DogId) FROM Dogs
GROUP BY FirstName, LastName
);Resultado:
+-------+-----------+----------+ | DogId | FirstName | LastName | +-------+-----------+----------+ | 2 | Bark | Smith | | 6 | Wag | Johnson | | 7 | Wag | Johnson | +-------+-----------+----------+
Este exemplo não requer a geração de nosso próprio número de linha separado.
Podemos substituir
SELECT * com DELETE para excluir as duplicatas. Opção 7
E, finalmente, aqui está outra opção para retornar duplicatas:
SELECT *
FROM Dogs d1, Dogs d2
WHERE d1.FirstName = d2.FirstName
AND d1.LastName = d2.LastName
AND d1.DogId <> d2.DogId
AND d1.DogId = (
SELECT MAX(DogId)
FROM Dogs d3
WHERE d3.FirstName = d1.FirstName
AND d3.LastName = d1.LastName
);Resultado:
+-------+-----------+----------+-------+-----------+----------+ | DogId | FirstName | LastName | DogId | FirstName | LastName | +-------+-----------+----------+-------+-----------+----------+ | 2 | Bark | Smith | 1 | Bark | Smith | | 7 | Wag | Johnson | 5 | Wag | Johnson | | 7 | Wag | Johnson | 6 | Wag | Johnson | +-------+-----------+----------+-------+-----------+----------+
