Como Concatenar Duas Colunas em SQL - Um Guia Detalhado

Em SQL, a concatenação é a operação de unir cordas, ou pedaços de informação de texto. Aprenda como concatenar duas colunas em SQL com este guia detalhado.

A concatenação SQL é o processo de combinação de duas ou mais cadeias de caracteres, colunas ou expressões em uma única cadeia de caracteres. Por exemplo, a concatenação de 'Kate', ' ', e 'Smith' nos dá 'Kate Smith'.

A concatenação SQL pode ser usada em uma variedade de situações onde é necessário combinar várias cadeias de caracteres em uma única cadeia de caracteres. Alguns casos de uso comum incluem:

• Criação de nomes completos ou outras cadeias compostas a partir de múltiplas colunas em uma tabela - por exemplo, concatenação do primeiro e último nomes de um usuário para criar um nome completo.
• Criação de rótulos ou títulos personalizados através da concatenação de múltiplos valores de cadeia de caracteres.
• Criação de um identificador único através da concatenação de várias colunas - por exemplo, um ID de cliente e um número de pedido.
• Criação de endereços de e-mail através da concatenação de um nome de usuário (katesmith) e um nome de domínio (learnSQL.com).

Estes são apenas alguns exemplos, mas a concatenação SQL pode ser usada em muitas outras situações onde a combinação de várias cadeias de caracteres é necessária.

A melhor maneira de praticar SQL, incluindo a concatenação SQL, é nossa Curso de Práticas em SQL. Ela contém quase 90 exercícios práticos, que são divididos em cinco seções baseadas em tópicos. Participar do curso é uma ótima maneira de atualizar seus conhecimentos em SQL. Com cada exercício resolvido, você aumenta a confiança em suas habilidades.

Como Concatenar Duas Colunas em SQL

A sintaxe da concatenação SQL pode variar de acordo com o dialeto SQL específico utilizado. Aqui estão alguns exemplos das técnicas mais conhecidas para a concatenação SQL.

O || Operador

SQL padrão utiliza o operador || (assim como algumas outras opções). A maioria dos bancos de dados SQL, com a notável exceção do SQL Server, suporta este operador. O operador ||| pegue dois ou mais argumentos e retorne uma única cadeia concatenada.

Utilização

Vamos imaginar o seguinte caso. Temos uma tabela chamada usuários que armazena informações do usuário:

id	first_name	middle_name	last_name	age	marital_status
--------------------------------------------------------------
1	Derek		Brent		Zoolander	35	S
2	Marty		George	McFly		20	S

Vamos usar o operador || para concatenar o primeiro e último nome dos usuários e obter um nome completo:

SELECT first_name || ' ' || last_name AS full_name 
FROM users;

O resultado:

full_name
---------------
Derek Zoolander
Marty McFly

Neste exemplo, o operador || pega as colunas first_name e last_name do users e as concatena com um espaço entre elas, resultando em um nome completo para cada usuário. O resultado é então aliado a full_name e retornado nos resultados da consulta.

Você pode concatenar várias cadeias usando o operador ||, fornecendo mais de dois argumentos. Por exemplo, a seguinte instrução SQL concatena o primeiro, o meio e o sobrenome dos usuários:

SELECT first_name || ' ' || middle_name || ' ' || last_name AS full_name 
FROM users;

O resultado:

full_name
---------------
Derek Brent Zoolander
Marty George McFly

O operador de concatenação || Trabalha também com colunas semtexto

Os dois exemplos anteriores contêm apenas cordas; e quanto aos outros tipos de dados? Os argumentos do || operador podem ser strings, colunas de texto, expressões e outros tipos de dados como números ou datas. Eles serão automaticamente convertidos em uma cadeia de caracteres.

Aqui está um exemplo de como usar o operador ||| para concatenar o primeiro nome, o sobrenome e a idade de um usuário para formar uma nova cadeia de caracteres:

SELECT 
  first_name || ' ' || last_name || ': ' || age || ' yo' AS user_details 
FROM users;

O resultado:

user_details
---------------
Derek Zoolander: 35 yo
Marty McFly: 20 yo

Note que o primeiro argumento da concatenação deve ser de um tipo de dados de texto. Caso contrário, é preciso lançá-lo em um tipo de texto. Aqui está um exemplo de como usar o operador || para concatenar o ID e o primeiro nome de um usuário para formar um identificador único:

SELECT 
  cast(id as VARCHAR) || '_' || first_name AS unique_id 
FROM users;

O resultado:

unique_id
---------------
1_Derek
2_Marty

Cuidado com as NULLs!

O | operador de concatenação retorna NULL para qualquer argumento NULL.

Imagine que você tenha alguns valores NULL ou NULL vazios em seu banco de dados:

id	first_name	middle_name	last_name	age	marital_status
--------------------------------------------------------
3	Terminator			T-1000	1	S
4	Robocop					2	S

Se um dos argumentos da concatenação for NULL, a expressão completa retorna NULL. No exemplo a seguir, tentaremos uma concatenação com um argumento NULL:

SELECT 
  first_name || ' ' || last_name AS full_name 
FROM users;

O resultado:

full_name
---------------
Terminator T-1000
NULL

O segundo resultado aqui é NULL: Robocop tem um primeiro nome, mas seu nome do meio e sobrenome são NULL. Se você concatenar 'Robocop' com NULL, você obtém NULL.

Nota: No caso do Oracle, uma cadeia NULL é uma cadeia vazia. A concatenação "ignora" a cadeia NULL, e os argumentos concatenados são devolvidos. Oráculo retornará o seguinte:

full_name
---------------
Terminator T-1000
Robocop

Use a função COALESCE() para concatenar valores NULL

Uma dica incrível para evitar os valores NULL é usar a função COALESCE(). A função COALESCE() em SQL é uma função integrada que retorna o primeiro valor não NULL em uma lista de expressões. A função pega um ou mais argumentos e retorna o primeiro argumento que não é NULL.

No exemplo a seguir, suponha que o campo last_name poderia ser NULL. Queremos evitar uma má concatenação, por isso usamos a função COALESCE():

SELECT 
  first_name || ' ' || COALESCE(last_name, '') AS full_name 
FROM users;

O resultado:

full_name
---------------
Terminator T-1000
Robocop

Acima, COALESCE() retorna o sobrenome se o sobrenome não for NULL. Se o sobrenome for NULL, ele retorna a cadeia vazia ‘’. Isto nos permite evitar a concatenação do valor NULL do sobrenome do Robocop e obter um resultado NULL.

O + Operador

O operador + é usado para concatenar cordas no MS SQL Server. Ele pega dois ou mais argumentos e retorna uma única cadeia de caracteres concatenada.

Aqui está um exemplo de utilização do operador + para concatenar o primeiro e o último nome de um usuário:

SELECT 
  first_name + ' ' + last_name AS full_name 
FROM users;

O resultado:

full_name
---------------
Derek Zoolander
Marty McFly

Com o operador +, nenhum dos argumentos será convertido automaticamente. Cada argumento da expressão precisa ser do tipo VARCHAR se a concatenação for bem sucedida. Para concatenar valores de diferentes tipos, usamos a função CAST():

SELECT 
  first_name + ' ' + last_name + ': ' + CAST(age AS VARCHAR) + ' yo' AS user_details 
FROM users;

O resultado:

user_details
---------------
Derek Zoolander: 35 yo
Marty McFly: 20 yo

Sem CAST(), o SQL Server irá lançar o seguinte erro:

MS SQL
Token error: 'Error converting data type varchar to bigint.' 

A função CONCAT

CONCAT() é outra função padrão SQL embutida que concatena dois ou mais valores. Todos os sistemas de banco de dados populares, exceto o SQLite, aceitam esta função; o SQLite aceita apenas o operador ||.

As principais diferenças entre os operadores || e + e a função CONCAT() são:

• CONCAT() os argumentos são automaticamente convertidos em strings, de modo que você pode usar argumentos de diferentes tipos de dados.
• CONCAT() trata os valores NULL como strings vazias e os ignora. A exceção aqui é o MySQL (e, em menor grau, o MariaDB). No MySQL, a função CONCAT() é equivalente ao operador ||; os argumentos NULL produzem resultados em NULL.

Aqui está um exemplo de utilização do CONCAT() para concatenar o primeiro e último nome dos usuários:

SELECT 
  CONCAT(first_name, ' ', last_name) AS full_name 
FROM users;

O resultado:

full_name
---------------
Derek Zoolander
Marty McFly
Terminator T-1000
Robocop

No exemplo a seguir, usaremos CONCAT() para concatenar o ID e o primeiro nome dos usuários para formar um identificador único. Note que a função CAST() não é necessária:

SELECT 
  CONCAT(id, '_', first_name) AS unique_id 
FROM users;

O resultado:

unique_id
---------------
1_Derek
2_Marty
3_Terminator
4_Robocop

A função CONCAT_WS

A função CONCAT_WS em SQL é similar à função CONCAT, mas é usada para concatenar duas ou mais cordas junto com um separador. A função leva dois argumentos: o primeiro argumento é o separador, e o resto dos argumentos são as cordas que você deseja concatenar.

Todos os bancos de dados populares, exceto Oracle e SQLite, aceitam a função CONCAT_WS. Esta função ignora NULLs nos argumentos (que não o separador) - mesmo para o MySQL.

Vamos usar a função CONCAT_WS para concatenar os valores first_name e last_name com um separador de espaço:

SELECT 
  CONCAT_WS(' ', first_name, last_name) AS full_name 
FROM users;

O resultado:

full_name
---------------
Derek Zoolander
Marty McFly
Terminator T-1000
Robocop

Finalmente, vamos tentar concatenar três argumentos, separados por espaços:

SELECT 
  CONCAT_WS(' ', first_name, middle_name, last_name) AS full_name 
FROM users;

O resultado: O resultado:

full_name
---------------
Derek Brent Zoolander
Marty George McFly
Terminator T-1000
Robocop

Se você quiser conhecer funções SQL mais impressionantes, recomendo vivamente a leitura do artigo 5 Funções SQL para Manipular Strings de Marek Pankowski.

Concatenar duas colunas em SQL é fácil!

Espero que tenham gostado tanto de ler este artigo quanto eu o escrevi! As diferenças entre os dialetos SQL são sutis, e é sempre emocionante saber mais sobre eles.

Este artigo o encorajou a aprender mais sobre SQL? Não hesite! Sua jornada SQL já está começando bem, e LearnSQL.com.br tem todos os recursos e ajuda de que você precisa para se tornar um especialista em SQL.

Dominar SQL é uma experiência prática - aprender os conceitos é uma coisa, mas escrever boas consultas requer prática. Eu recomendo sinceramente nosso Curso de Práticas em SQL Ele testa seus conhecimentos básicos de SQL e lhe mostra onde você precisa melhorar.

Então, do que você está esperando? Não fique apenas com colunas concatenadas - aprenda mais SQL hoje!