Что такое concat?

CONCAT: объединение строк в SQL и Python

SQL: CONCAT функция

CONCAT в SQL объединяет несколько строк в одну.

Синтаксис в разных БД

PostgreSQL:

SELECT CONCAT('Hello', ' ', 'World') AS result;
-- Результат: 'Hello World'

SELECT CONCAT('Mr. ', first_name, ' ', last_name) AS full_name
FROM users;
-- Результат: 'Mr. Alice', 'Mr. Bob', ...

MySQL:

SELECT CONCAT('Hello', ' ', 'World') AS result;
-- Результат: 'Hello World'

SQL Server:

SELECT CONCAT('Hello', ' ', 'World') AS result;
-- Или старый синтаксис:
SELECT 'Hello' + ' ' + 'World' AS result;  -- также работает

SQLite:

SELECT 'Hello' || ' ' || 'World' AS result;  -- используется || оператор

Практические примеры CONCAT

Пример 1: Полное имя

SELECT 
    user_id,
    CONCAT(first_name, ' ', last_name) AS full_name,
    CONCAT('Email: ', email) AS email_label
FROM users;

-- Результат:
-- user_id | full_name  | email_label
-- 1       | Alice Smith | Email: alice@example.com
-- 2       | Bob Jones  | Email: bob@example.com

Пример 2: Построение URL

SELECT 
    product_id,
    CONCAT('https://shop.com/product/', product_id, '/', LOWER(REPLACE(name, ' ', '-'))) AS product_url
FROM products;

-- Результат:
-- product_id | product_url
-- 1          | https://shop.com/product/1/wireless-headphones
-- 2          | https://shop.com/product/2/mechanical-keyboard

Пример 3: Создание сообщений

SELECT 
    order_id,
    CONCAT(
        'Order #', order_id, 
        ' for ', user_name,
        ' placed on ', created_at,
        ' - Total: $', amount
    ) AS order_message
FROM orders;

-- Результат:
-- order_id | order_message
-- 1        | Order #1 for Alice placed on 2024-01-15 - Total: $1000

Пример 4: Адрес

SELECT 
    CONCAT(
        street, ', ',
        city, ', ',
        state, ' ',
        postal_code, ', ',
        country
    ) AS full_address
FROM customers;

-- Результат:
-- full_address
-- 123 Main St, New York, NY 10001, USA
-- 456 Oak Ave, Los Angeles, CA 90001, USA

NULL обработка

Важно: CONCAT с NULL

SELECT CONCAT('Hello', NULL, 'World');
-- Результат: NULL (все выражение становится NULL)

-- Решение: использовать COALESCE
SELECT CONCAT('Hello', COALESCE(NULL, ''), 'World');
-- Результат: 'HelloWorld'

-- Или использовать CONCAT_WS (Concat With Separator)
SELECT CONCAT_WS(' ', first_name, middle_name, last_name);
-- Пропускает NULL значения автоматически

CONCAT_WS: безопаснее

CONCAT_WS (Concat With Separator) удобнее работает с NULL:

-- Синтаксис: CONCAT_WS(separator, str1, str2, ...)
SELECT CONCAT_WS(' ', 'John', NULL, 'Doe');
-- Результат: 'John Doe' (NULL пропущен)

SELECT CONCAT_WS(', ', street, city, state, postal_code)
FROM addresses;
-- Автоматически пропускает пустые значения

SELECT CONCAT_WS(' | ', category, subcategory, product_name)
FROM breadcrumbs;
-- Результат: 'Electronics | Computers | Laptop'

Альтернативы CONCAT

String operator (||) — в PostgreSQL, SQLite:

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

-- Проблема: если NULL, результат NULL
SELECT first_name || ' ' || COALESCE(middle_name, '') || ' ' || last_name;

Оператор (+) — в SQL Server:

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

Python: String операции

Способ 1: f-strings (самый модерный)

first_name = 'Alice'
last_name = 'Smith'
email = 'alice@example.com'

# F-string
full_name = f'{first_name} {last_name}'
print(full_name)  # 'Alice Smith'

# Более сложный
message = f'User {first_name} has email {email}'
print(message)  # 'User Alice has email alice@example.com'

# Выражения в f-string
amount = 1000
receipt = f'Total: ${amount:.2f}'  # форматирование
print(receipt)  # 'Total: $1000.00'

Способ 2: format() метод

message = '{} {} ({})'.format('Alice', 'Smith', 'alice@example.com')
print(message)  # 'Alice Smith (alice@example.com)'

# Именованные аргументы
template = '{first} {last} - {email}'
result = template.format(first='Alice', last='Smith', email='alice@example.com')
print(result)  # 'Alice Smith - alice@example.com'

Способ 3: join() - быстро для многих строк

parts = ['Alice', 'Smith', 'alice@example.com']
result = ' - '.join(parts)
print(result)  # 'Alice - Smith - alice@example.com'

# Для разных разделителей
data = ['John', 'Doe', 'New York', 'USA']
address = ', '.join(data)
print(address)  # 'John, Doe, New York, USA'

Способ 4: + оператор (избегай)

# Работает, но неэффективно
result = 'Alice' + ' ' + 'Smith'  # создает 3 строки в памяти

# Лучше f-string
result = f'Alice Smith'  # одна операция

Pandas: String операции

import pandas as pd

df = pd.DataFrame({
    'first_name': ['Alice', 'Bob', 'Charlie'],
    'last_name': ['Smith', 'Jones', 'Brown'],
    'email': ['alice@test.com', 'bob@test.com', 'charlie@test.com']
})

# Способ 1: str.cat() - "concat"
df['full_name'] = df['first_name'].str.cat(df['last_name'], sep=' ')
print(df)
#   first_name last_name        email     full_name
# 0      Alice     Smith alice@test.com  Alice Smith
# 1        Bob     Jones   bob@test.com    Bob Jones
# 2    Charlie     Brown charlie@test.com Charlie Brown

# Способ 2: f-string с apply()
df['full_info'] = df.apply(
    lambda row: f"{row['first_name']} {row['last_name']} - {row['email']}",
    axis=1
)

# Способ 3: + оператор (работает с Series)
df['greeting'] = 'Hello, ' + df['first_name'] + '!'

SQL + Python вместе

import pandas as pd
from sqlalchemy import create_engine, text

engine = create_engine('postgresql://...')

# Способ 1: CONCAT в SQL запросе
query = """
SELECT 
    user_id,
    CONCAT(first_name, ' ', last_name) AS full_name
FROM users
"""
df = pd.read_sql(query, engine)

# Способ 2: CONCAT в Python (если SQL не поддерживает)
query = "SELECT first_name, last_name FROM users"
df = pd.read_sql(query, engine)
df['full_name'] = df['first_name'] + ' ' + df['last_name']  # concat в pandas

# Способ 3: Параметризованный CONCAT
query = text("""
SELECT 
    CONCAT(
        COALESCE(:prefix, ''),
        first_name, ' ', 
        last_name
    ) AS full_name
FROM users
""")
df = pd.read_sql(query, engine, params={'prefix': 'Mr.'})

Случаи использования CONCAT в аналитике

1. Построение уникальных ключей

SELECT 
    CONCAT(user_id, '_', product_id, '_', DATE(created_at)) AS unique_key,
    COUNT(*) as occurrences
FROM events
GROUP BY unique_key;

2. Логирование/аудит

SELECT 
    CONCAT(
        'User ', user_id, 
        ' changed ', field_name, 
        ' from "', old_value, 
        '" to "', new_value, 
        '" at ', updated_at
    ) AS audit_log
FROM audit_trail;

3. Генерация отчетов

SELECT 
    CONCAT(
        'Category: ', category, '\n',
        'Revenue: $', SUM(amount), '\n',
        'Orders: ', COUNT(*), '\n',
        'Avg Order: $', AVG(amount)
    ) AS category_report
FROM orders
GROUP BY category;

4. Обогащение данных

df['description'] = df.apply(
    lambda row: f"{row['product_name']} ({row['category']}) - ${row['price']}",
    axis=1
)

Производительность: когда это критично

-- ХОРОШО для маленьких объемов
SELECT CONCAT(a, b, c, d, e) FROM table1;

-- Для больших объемов лучше делать в приложении
-- SQL: просто выбрать колонки
SELECT a, b, c, d, e FROM table1;

-- Python: объединить
df['concat'] = df['a'] + df['b'] + df['c'] + df['d'] + df['e']
-- Это быстрее на больших датасетах

Памятка

Лучшие практики:

• ✅ SQL: CONCAT_WS для автоматической NULL обработки
• ✅ Python: f-strings для читаемости
• ✅ Pandas: + оператор для простоты, apply() для сложности
• ❌ Избегай множественных + операторов (используй join())
• ❌ Помни про NULL значения в SQL