How to Concatenate Two Columns in SQL?

By Cristian G. Guasch • Updated: 03/03/24 • 9 min read

In the world of SQL, merging two columns into one can seem like a daunting task, but it’s a powerful skill that can simplify your data analysis and reporting. I’ve encountered numerous situations where concatenating columns was the key to unlocking more insightful, comprehensive views of data. Whether you’re combining first and last names into a full name, merging dates and times, or any other scenario, mastering this technique is a game-changer.

Let’s dive into the nuts and bolts of how to concatenate two columns in SQL. I’ll walk you through the process step-by-step, ensuring you have a clear, actionable guide to follow. With a bit of practice, you’ll find concatenation to be an invaluable tool in your SQL toolkit, making your queries more efficient and your data more accessible.

Understanding SQL Concatenation

When I delve into the world of SQL, I find concatenation to be a straightforward yet powerful tool. Essentially, it’s the process of combining two columns into one, providing a seamless way to handle data. Whether it’s merging first and last names or combining date fields, mastering SQL concatenation has undeniably streamlined my data analysis tasks.

To begin, let’s tackle the basics. The most common method to concatenate two columns in SQL is by using the CONCAT() function. This function is incredibly flexible, allowing me to merge two or more strings into one. For example, to concatenate a user’s first and last name, I’d use:

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

Here, I’m not just merging two columns; I’m also inserting a space between them to ensure the full name reads correctly.

However, not all SQL databases support the CONCAT() function. In such cases, I rely on the + operator in SQL Server or the ‘ ‘ operator in Oracle and PostgreSQL. For instance, concatenating columns in SQL Server looks like this:

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

One common mistake to watch out for is null values in one of the columns. If any column contains a null value, the entire concatenated result becomes null in some SQL versions. To avoid this, I use the COALESCE() function to ensure null values don’t hinder the concatenation process:

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

This code snippet effectively replaces any null value with an empty string, ensuring the concatenation process runs smoothly.

Another useful variation is concatenating more than two columns or adding conditional statements within the concatenation process. For instance, I might include a user’s title only if it exists:

SELECT CONCAT(first_name, ' ', last_name, CASE WHEN title IS NOT NULL THEN CONCAT(' (', title, ')') ELSE '' END) AS full_name_with_title FROM users;

By paying attention to these nuances and employing the right functions and operators, I’ve managed to avoid common pitfalls and significantly enhance the quality of my data reporting.

Step 1: Using CONCAT Function

After initializing the basics of SQL concatenation, it’s essential to dive into the practical implementation, and CONCAT() is our starting point. This function is straightforward, designed to merge the contents of two or more columns seamlessly.

For a quick hands-on example, let’s consider we’re working with a database containing a table Employee with two columns, FirstName and LastName. If I want to combine these columns into a single full name column, the syntax would look something like this:

SELECT CONCAT(FirstName, ' ', LastName) AS FullName FROM Employee;

In this example, I’ve added a space between the first and last names to ensure the full name appears natural. Remember, without including the space (‘ ‘), the names would be combined directly, like JohnDoe, which is not what we usually want.

A common mistake to avoid is not accounting for null values. If either column contains a null, the whole result turns into null. This is where COALESCE() comes in handy, allowing us to substitute null values with a default value, such as an empty string:

SELECT CONCAT(COALESCE(FirstName, ''), ' ', COALESCE(LastName, '')) AS FullName FROM Employee;

Variations in the use of CONCAT() include combining not just two, but multiple columns. Moreover, it isn’t restricted to just columns; you can concatenate constant strings or numeric values. For instance, adding a title or a suffix to names:

SELECT CONCAT('Mr. ', FirstName, ' ', LastName, ' Jr.') AS FullNameWithTitle FROM Employee;

This flexible approach shows how concatenating columns can adapt to a range of scenarios, catering to different formatting needs. It’s all about playing with the function to fit the specific requirements of your data reporting or manipulation tasks.

Step 2: Utilizing the Plus Symbol (+)

After mastering the CONCAT() function, it’s time to explore another method of fusing columns in SQL: the plus symbol (+). This technique is particularly useful in certain database systems like Microsoft SQL Server, where it’s a straightforward way to concatenate strings.

Here’s how you can combine two columns, FirstName and LastName, into a FullName:

SELECT FirstName + ' ' + LastName AS FullName
FROM Employees;

This method is clean and simple, but it’s crucial to be aware of its limitations. One common mistake is assuming that it will automatically handle null values similarly to the CONCAT() function. Unfortunately, if either FirstName or LastName is null, the entire expression results in null. To bypass this issue, use the ISNULL function:

SELECT ISNULL(FirstName, '') + ' ' + ISNULL(LastName, '') AS FullName
FROM Employees;

This ensures that a null FirstName or LastName doesn’t derail our effort to create a complete FullName. It’s a simple fix, but it keeps our data clean and our outputs intact.

Additionally, while concatenating numeric values with strings, ensure everything is cast to a string to avoid errors:

SELECT FirstName + ' is ' + CAST(Age as varchar) + ' years old'
FROM Employees;

This converts the Age column to a varchar type, ensuring seamless concatenation with the other string components. Neglecting to cast numeric or date types to strings is a common pitfall, often leading to unexpected results or errors.

Exploring these variations and common mistakes highlights the flexibility and potential pitfalls of using the plus symbol for concatenation in SQL. While it’s a powerful tool, making sure you account for null values and type mismatches is key to getting the most out of this method.

Step 3: Handling NULL Values

When I’m working with SQL, one of the hurdles I frequently encounter is handling NULL values during concatenation. These can cause headaches, as they might lead to unexpected results or even cause the entire concatenation to result in NULL. Let’s dive into how to manage this effectively.

In Microsoft SQL Server, for instance, the ISNULL function becomes my best friend. It allows me to replace NULL with a default value, ensuring that the concatenation process runs smoothly. Let’s say I want to concatenate FirstName and LastName into a FullName. If either of these columns contains a NULL value, the result might not be what I expect. Here’s how I tackle it:

SELECT ISNULL(FirstName, '') + ' ' + ISNULL(LastName, '') AS FullName FROM Users;

By using ISNULL, I’m replacing any NULL values with an empty string, ensuring that I get a clean FullName every time.

Another handy function in SQL Server is COALESCE. It offers more flexibility by allowing me to check multiple columns and replace the first NULL value found with a specified value. Here’s how it looks:

SELECT COALESCE(FirstName, 'Guest', 'Unknown') + ' ' + LastName AS FullName FROM Users;

In this example, if FirstName is NULL, SQL Server uses ‘Guest’. If ‘Guest’ were NULL (which it never is in this context), ‘Unknown’ would be used.

Common Mistakes

One common mistake is not considering data types. Remember, when concatenating numeric values with strings, it’s essential to cast the numbers to strings first. Otherwise, SQL might throw an error or yield unexpected results. Here’s an example:

SELECT FirstName + ' is ' + CAST(Age AS varchar) + ' years old' FROM Users;

By casting Age to a varchar, I avoid potential type mismatch errors.

Handling NULL values correctly and being mindful of data types ensures that data concatenation in SQL is both effective and error-free. Whether it’s using ISNULL or COALESCE, choosing the right tool for the job makes all the difference.

Advanced Techniques for Concatenation

When I dive deeper into the realm of SQL, I often find myself needing more sophisticated ways to manipulate and concatenate data. One powerful method involves the CONCAT_WS() function, a variant that allows including a separator between the concatenated values. This can be a game changer when preparing data for human-readable formats or reports.

Here’s a simple yet effective example:

SELECT CONCAT_WS(' - ', FirstName, LastName) AS FullName
FROM Employees;

In this example, I’m merging the FirstName and LastName columns with a hyphen as a separator, creating a FullName column that’s immediately useful for anything from name tags to email salutations.

Another advanced technique I’ve found immensely useful is the use of the CASE statement within concatenation. This is handy for conditional text inclusion or formatting based on certain criteria. For instance,

SELECT FirstName + ' ' +
WHEN MiddleName IS NOT NULL THEN MiddleName + ' '
END + LastName AS FullName
FROM Employees;

Here, I’m conditionally including the MiddleName in the full name, only if it’s not null. Techniques like these ensure the data I present is both accurate and cleanly formatted.

It’s worth pointing out a common mistake: neglecting the order of operations. In SQL, concatenation operators don’t necessarily have the same precedence as arithmetic operators, leading to unexpected results. Always use parentheses to specify the exact order of concatenation, especially when mixing types or including conditions:

SELECT (FirstName + ' ' + LastName) AS FullName,
('Age: ' + CAST(Age AS VARCHAR(10))) AS AgeString
FROM Employees;

Handling these nuances with the strategies I’ve shared not only elevates the quality of your SQL concatenation tasks but also streamlines your data preparation workflows significantly.


Mastering the art of concatenating columns in SQL can significantly elevate your data manipulation skills. By leveraging advanced techniques like CONCAT_WS() and the CASE statement, I’ve shown you how to not only merge data but also format it precisely to your needs. Remember, understanding the order of operations is crucial to avoid any surprises. With these strategies at your disposal, you’re well-equipped to handle complex data presentation challenges, making your SQL queries more powerful and your data preparation tasks a breeze. Happy querying!

Related articles