Las funciones de texto (o de cadenas) de SQL te permiten limpiar y transformar texto dentro de una consulta: cambiar mayúsculas y minúsculas, quitar espacios, unir columnas, extraer parte de un valor, buscar y reemplazar caracteres y combinar valores de muchas filas. Las más comunes son LENGTH, UPPER, LOWER, TRIM, CONCAT, SUBSTRING, REPLACE y STRING_AGG, aunque los nombres cambian un poco entre PostgreSQL, MySQL, SQL Server y SQLite.
Los datos de texto son desordenados. Los nombres llegan con mayúsculas al azar, los correos traen espacios de más, los teléfonos usan cinco formatos distintos y los códigos guardan varios datos en un solo valor. Las funciones de texto te permiten corregir todo eso con SQL, sin exportar primero los datos a una hoja de cálculo.
Esta guía cubre las funciones de texto que más vas a usar, con ejemplos sobre una tabla pequeña y desordenada a propósito. Todos los ejemplos se probaron en PostgreSQL 17, MySQL 8.4, SQL Server 2022 y SQLite, y cada sección indica dónde se comportan distinto. Es la guía compañera de Funciones de Fecha en SQL, que cubre lo mismo para las fechas.
Datos de Ejemplo para Esta Guía
Los ejemplos usan una tabla customers (clientes) con problemas típicos: espacios de más, mayúsculas inconsistentes, un correo faltante, teléfonos en distintos formatos y un código de producto (sku) que combina una categoría, un año y un número de secuencia. Los nombres de tablas y columnas están en inglés para que coincidan con la salida de ejemplo.
CREATE TABLE customers (
id INT PRIMARY KEY,
first_name VARCHAR(50),
last_name VARCHAR(50),
email VARCHAR(100),
phone VARCHAR(20),
city VARCHAR(50),
sku VARCHAR(20)
);
INSERT INTO customers VALUES
(1, ' maria ', 'LOPEZ', '[email protected]', '(760) 555-0142', 'el centro', 'LAP-2026-0042'),
(2, 'James', 'carter', '[email protected]', '760.555.0199', 'Brawley', 'MON-2025-0007'),
(3, 'Sofia', 'Nguyen', '[email protected]', '760-555-0110', 'CALEXICO ', 'KEY-2026-0310'),
(4, 'daniel', 'Brooks', NULL, '7605550123', 'Imperial', 'MOU-2024-0001'),
(5, 'José', 'Ramírez', '[email protected]', '760 555 0177', 'El Centro', 'DES-2026-0015');
Funciona tal cual en PostgreSQL, MySQL y SQLite. En SQL Server, usa NVARCHAR en lugar de VARCHAR y escribe los valores con acentos como N'José' para que se guarden correctamente.
Tabla Rápida: La Misma Tarea en Cuatro Bases de Datos
| Tarea | PostgreSQL | MySQL | SQL Server | SQLite |
|---|---|---|---|---|
| Longitud (caracteres) | LENGTH(s) | CHAR_LENGTH(s) | LEN(s) | LENGTH(s) |
| Mayúsculas / minúsculas | UPPER(s), LOWER(s) | igual | igual | igual (solo ASCII) |
| Primera letra en mayúscula | INITCAP(s) | (hay que armarla) | (hay que armarla) | (hay que armarla) |
| Quitar espacios | TRIM(s) | TRIM(s) | TRIM(s) (2017+) | TRIM(s) |
| Unir texto | a || b, CONCAT(a, b) | CONCAT(a, b) | a + b, CONCAT(a, b) | a || b |
| Unir con separador | CONCAT_WS(sep, ...) | CONCAT_WS(sep, ...) | CONCAT_WS(sep, ...) (2017+) | concat_ws(sep, ...) (versiones recientes) |
| Parte de una cadena | SUBSTRING(s, inicio, largo) | SUBSTRING(s, inicio, largo) | SUBSTRING(s, inicio, largo) | SUBSTR(s, inicio, largo) |
| Primeros / últimos caracteres | LEFT(s, n), RIGHT(s, n) | igual | igual | SUBSTR(s, 1, n), SUBSTR(s, -n) |
| Buscar un carácter | POSITION('@' IN s) | LOCATE('@', s) | CHARINDEX('@', s) | INSTR(s, '@') |
| Reemplazar texto | REPLACE(s, viejo, nuevo) | igual | igual | igual |
| Reemplazar con un patrón | REGEXP_REPLACE(...) | REGEXP_REPLACE(...) | (no en 2022) | (no incluido) |
| Rellenar con caracteres | LPAD(s, n, '0') | LPAD(s, n, '0') | RIGHT('000' + s, n) | SUBSTR('000' || s, -n) |
| Combinar filas en una cadena | STRING_AGG(s, ', ') | GROUP_CONCAT(s SEPARATOR ', ') | STRING_AGG(s, ', ') | GROUP_CONCAT(s, ', ') |
Los ejemplos de abajo usan primero PostgreSQL e indican en qué cambian las demás. Las posiciones en las cadenas de SQL empiezan en 1, no en 0.
Medir la Longitud: LENGTH, CHAR_LENGTH y LEN
SELECT first_name,
LENGTH(first_name) AS len,
LENGTH(TRIM(first_name)) AS trimmed_len
FROM customers
ORDER BY id;
first_name | len | trimmed_len
------------+-----+-------------
maria | 8 | 5
James | 5 | 5
Sofia | 5 | 5
daniel | 6 | 6
José | 4 | 4
' maria ' tiene 8 caracteres, incluidos dos espacios al inicio y uno al final. Comparar la longitud antes y después de TRIM es una forma rápida de encontrar valores con espacios ocultos.
Cuidado con dos diferencias:
- En MySQL,
LENGTHcuenta bytes, no caracteres.LENGTH('José')devuelve 5, porque laéocupa dos bytes en UTF-8. UsaCHAR_LENGTH('José'), que devuelve 4. - En SQL Server,
LENignora los espacios al final.LEN(' maria ')devuelve 7, no 8. UsaDATALENGTHpara contar bytes, incluidos los espacios finales (unNVARCHARusa 2 bytes por carácter).
Cambiar Mayúsculas y Minúsculas: UPPER, LOWER e INITCAP
SELECT id,
INITCAP(TRIM(first_name)) AS first_name,
INITCAP(last_name) AS last_name,
LOWER(TRIM(email)) AS email,
INITCAP(TRIM(city)) AS city
FROM customers
ORDER BY id;
id | first_name | last_name | email | city
----+------------+-----------+--------------------------+-----------
1 | Maria | Lopez | [email protected] | El Centro
2 | James | Carter | [email protected] | Brawley
3 | Sofia | Nguyen | [email protected] | Calexico
4 | Daniel | Brooks | | Imperial
5 | José | Ramírez | [email protected] | El Centro
UPPERyLOWERfuncionan en todas. Pasar los correos a minúsculas antes de compararlos o guardarlos evita tratar[email protected]y[email protected]como personas distintas.INITCAPpone en mayúscula la primera letra de cada palabra. Solo PostgreSQL (y Oracle) la tienen. En las demás, ármala para palabras sueltas:
-- MySQL y SQL Server
CONCAT(UPPER(LEFT(TRIM(first_name), 1)), LOWER(SUBSTRING(TRIM(first_name), 2, 50)))
-- SQLite
UPPER(SUBSTR(TRIM(first_name), 1, 1)) || LOWER(SUBSTR(TRIM(first_name), 2))
Las dos devuelven Maria, James, Sofia, Daniel, José. Nombres como “McDonald” o “de la Cruz” necesitan revisión manual en cualquier base de datos.
Detalle de SQLite: sus funciones UPPER y LOWER integradas solo cambian letras ASCII simples. UPPER('josé') devuelve JOSé.
Quitar Espacios: TRIM, LTRIM y RTRIM
| Función | Qué quita | ' hi ' queda como |
|---|---|---|
TRIM(s) | Espacios en ambos extremos | 'hi' |
LTRIM(s) | Espacios al inicio | 'hi ' |
RTRIM(s) | Espacios al final | ' hi' |
TRIM no toca los espacios de en medio, así que 'El Centro' conserva su doble espacio; para eso usa REPLACE. PostgreSQL y MySQL también pueden quitar otros caracteres: TRIM(BOTH '-' FROM '--abc--') devuelve abc. SQL Server 2022 admite TRIM('-' FROM s).
Por qué importa: los espacios ocultos rompen las agrupaciones y los joins. Agrupar por la columna city sin limpiar da cinco ciudades distintas:
SELECT TRIM(city) AS city, COUNT(*) FROM customers GROUP BY TRIM(city) ORDER BY 1;
city | count
-----------+-------
Brawley | 1
CALEXICO | 1
el centro | 1
El Centro | 1
Imperial | 1
Quitar los espacios no basta, porque “el centro” y “El Centro” siguen siendo distintas por las mayúsculas. Limpia las dos cosas:
SELECT INITCAP(TRIM(city)) AS city, COUNT(*) AS customers
FROM customers
GROUP BY INITCAP(TRIM(city))
ORDER BY city;
city | customers
-----------+-----------
Brawley | 1
Calexico | 1
El Centro | 2
Imperial | 1
Para más técnicas de limpieza, consulta Limpiar Datos Desordenados con SQL Puro.
Unir Texto: CONCAT, || y CONCAT_WS
PostgreSQL y SQLite unen cadenas con ||, y las cuatro bases de datos tienen una función CONCAT (en SQLite, solo en versiones recientes):
SELECT id,
first_name || ' ' || last_name AS with_pipes,
CONCAT(first_name, ' ', last_name) AS with_concat
FROM customers
WHERE id IN (2, 3);
id | with_pipes | with_concat
----+--------------+--------------
2 | James carter | James carter
3 | Sofia Nguyen | Sofia Nguyen
NULL lo Cambia Todo
La mayor diferencia entre bases de datos es qué pasa cuando uno de los valores es NULL, como el correo del cliente 4:
SELECT id,
'Email: ' || email AS pipes,
CONCAT('Email: ', email) AS concat_fn,
CONCAT_WS(' | ', last_name, email, phone) AS ws
FROM customers
WHERE id IN (3, 4)
ORDER BY id;
id | pipes | concat_fn | ws
----+-------------------------+-------------------------+------------------------------------------
3 | Email: [email protected] | Email: [email protected] | Nguyen | [email protected] | 760-555-0110
4 | | Email: | Brooks | 7605550123
| Expresión con un valor NULL | PostgreSQL | MySQL | SQL Server | SQLite |
|---|---|---|---|---|
'Email: ' || email o 'Email: ' + email | NULL | (no concatena) | NULL | NULL |
CONCAT('Email: ', email) | Email: | NULL | Email: | Email: |
CONCAT_WS(' | ', ...) | Omite el NULL | Omite el NULL | Omite el NULL | Omite el NULL |
Dos cosas que recordar:
- En MySQL,
CONCATdevuelve NULL si cualquier argumento es NULL. Envuelve las columnas enCOALESCE(email, '')o usaCONCAT_WS, que omite los NULL. - En MySQL,
||significa O lógico de forma predeterminada, no concatenación.SELECT 'a' || 'b'devuelve0. UsaCONCAT.
CONCAT_WS (“con separador”) es la forma más limpia de unir varios campos opcionales, como las líneas de una dirección, porque no deja separadores duplicados donde falta un valor.
Extraer Parte de una Cadena: SUBSTRING, LEFT y RIGHT
La columna sku guarda tres datos en un solo valor: LAP-2026-0042 es la categoría LAP, el año 2026 y la secuencia 0042.
SELECT sku,
LEFT(sku, 3) AS category,
SUBSTRING(sku, 5, 4) AS year,
RIGHT(sku, 4) AS seq
FROM customers
ORDER BY id;
sku | category | year | seq
---------------+----------+------+------
LAP-2026-0042 | LAP | 2026 | 0042
MON-2025-0007 | MON | 2025 | 0007
KEY-2026-0310 | KEY | 2026 | 0310
MOU-2024-0001 | MOU | 2024 | 0001
DES-2026-0015 | DES | 2026 | 0015
SUBSTRING(sku, 5, 4) significa “empieza en el carácter 5 y toma 4 caracteres”. En SQLite, usa SUBSTR(sku, 1, 3) en lugar de LEFT, y SUBSTR(sku, -4) (un inicio negativo cuenta desde el final) en lugar de RIGHT.
Los resultados siguen siendo texto. Para usar el año como número, conviértelo: CAST(SUBSTRING(sku, 5, 4) AS INT).
Buscar Texto Dentro de una Cadena: POSITION, LOCATE, CHARINDEX e INSTR
Para obtener el dominio de un correo, encuentra la posición de @ y toma todo lo que sigue:
SELECT email,
POSITION('@' IN email) AS at_pos,
SUBSTRING(email FROM POSITION('@' IN email) + 1) AS domain
FROM customers
WHERE email IS NOT NULL
ORDER BY id;
email | at_pos | domain
--------------------------+--------+-------------
[email protected] | 12 | Example.com
[email protected] | 13 | example.com
[email protected] | 6 | nguyen.dev
[email protected] | 13 | example.com
Cada base de datos nombra la función de forma distinta, y el orden de los argumentos no es el mismo:
| Base de datos | Buscar @ en email | Dominio |
|---|---|---|
| PostgreSQL | POSITION('@' IN email) o STRPOS(email, '@') | SPLIT_PART(email, '@', 2) |
| MySQL | LOCATE('@', email) o INSTR(email, '@') | SUBSTRING_INDEX(email, '@', -1) |
| SQL Server | CHARINDEX('@', email) | SUBSTRING(email, CHARINDEX('@', email) + 1, LEN(email)) |
| SQLite | INSTR(email, '@') | SUBSTR(email, INSTR(email, '@') + 1) |
Todas devuelven 0 cuando no encuentran el texto. SPLIT_PART de PostgreSQL y SUBSTRING_INDEX de MySQL son atajos para dividir por un delimitador: SPLIT_PART('LAP-2026-0042', '-', 2) devuelve 2026.
Reemplazar Texto: REPLACE y REGEXP_REPLACE
REPLACE(texto, viejo, nuevo) reemplaza cada aparición de una cadena por otra. Para dejar un teléfono solo con dígitos, anida varias llamadas:
SELECT phone,
REPLACE(REPLACE(REPLACE(REPLACE(REPLACE(phone, '(', ''), ')', ''), '-', ''), '.', ''), ' ', '') AS nested,
REGEXP_REPLACE(phone, '[^0-9]', '', 'g') AS regex
FROM customers
ORDER BY id;
phone | nested | regex
----------------+------------+------------
(760) 555-0142 | 7605550142 | 7605550142
760.555.0199 | 7605550199 | 7605550199
760-555-0110 | 7605550110 | 7605550110
7605550123 | 7605550123 | 7605550123
760 555 0177 | 7605550177 | 7605550177
El REPLACE anidado funciona en todas las bases de datos. Las expresiones regulares son mucho más cortas: [^0-9] significa “cualquier carácter que no sea un dígito”.
- PostgreSQL:
REGEXP_REPLACE(phone, '[^0-9]', '', 'g'); la opción'g'reemplaza todas las coincidencias, no solo la primera. - MySQL 8:
REGEXP_REPLACE(phone, '[^0-9]', '')reemplaza todas las coincidencias de forma predeterminada. - SQL Server 2022 y SQLite no tienen un reemplazo con expresiones regulares integrado, así que usa
REPLACEanidado.
Rellenar Texto: LPAD y RPAD
Rellenar agrega caracteres hasta que una cadena alcanza una longitud fija, algo útil para códigos como C00001:
SELECT id, 'C' || LPAD(id::text, 5, '0') AS customer_code
FROM customers
ORDER BY id;
id | customer_code
----+---------------
1 | C00001
2 | C00002
3 | C00003
4 | C00004
5 | C00005
- MySQL:
CONCAT('C', LPAD(id, 5, '0')). - SQL Server:
'C' + RIGHT('00000' + CAST(id AS VARCHAR(10)), 5), o'C' + FORMAT(id, '00000'). - SQLite:
'C' || SUBSTR('00000' || id, -5).
RPAD funciona igual del lado derecho.
Combinar Filas en una Cadena: STRING_AGG y GROUP_CONCAT
Las funciones de agregación pueden unir los valores de muchas filas en una lista separada por comas:
SELECT STRING_AGG(TRIM(first_name), ', ' ORDER BY id) AS names
FROM customers;
names
-----------------------------------
maria, James, Sofia, daniel, José
| Base de datos | Sintaxis |
|---|---|
| PostgreSQL | STRING_AGG(name, ', ' ORDER BY id) |
| MySQL | GROUP_CONCAT(name ORDER BY id SEPARATOR ', ') |
| SQL Server | STRING_AGG(name, ', ') WITHIN GROUP (ORDER BY id) |
| SQLite | GROUP_CONCAT(name, ', '); la versión 3.44 y posteriores también aceptan ORDER BY dentro y el nombre STRING_AGG |
Combinada con GROUP BY, responde preguntas como “¿qué clientes viven en cada ciudad?” con una fila por ciudad. En MySQL, GROUP_CONCAT corta el resultado en 1,024 caracteres de forma predeterminada (la variable group_concat_max_len).
Búsqueda por Patrones y Mayúsculas: LIKE e ILIKE
LIKE busca patrones: % significa cualquier cantidad de caracteres y _ exactamente un carácter. Pero si ignora o no las mayúsculas depende de la base de datos:
SELECT id, email FROM customers WHERE email LIKE '%@example.com' ORDER BY id;
| Base de datos | ¿Encuentra [email protected]? | Por qué |
|---|---|---|
| PostgreSQL | No (devuelve los id 2 y 5) | LIKE distingue mayúsculas; usa ILIKE para ignorarlas |
| MySQL | Sí (id 1, 2 y 5) | La intercalación (collation) predeterminada no distingue mayúsculas |
| SQL Server | Sí (id 1, 2 y 5) | La intercalación predeterminada no distingue mayúsculas |
| SQLite | Sí (id 1, 2 y 5) | LIKE ignora mayúsculas en letras ASCII |
Lo mismo aplica a =. WHERE last_name = 'CARTER' encuentra a James en MySQL y SQL Server, pero no devuelve nada en PostgreSQL ni en SQLite. Para que una consulta se comporte igual en todas, normaliza ambos lados: WHERE LOWER(email) LIKE '%@example.com'.
PostgreSQL también admite expresiones regulares en WHERE con ~ (distingue mayúsculas) y ~* (no las distingue). MySQL usa REGEXP.
Todo Junto
Esta consulta de PostgreSQL limpia toda la tabla:
SELECT
id,
INITCAP(TRIM(first_name)) || ' ' || INITCAP(TRIM(last_name)) AS full_name,
COALESCE(LOWER(TRIM(email)), 'no email') AS email,
REGEXP_REPLACE(phone, '[^0-9]', '', 'g') AS phone,
INITCAP(TRIM(city)) AS city,
LEFT(sku, 3) AS category
FROM customers
ORDER BY id;
id | full_name | email | phone | city | category
----+---------------+--------------------------+------------+-----------+----------
1 | Maria Lopez | [email protected] | 7605550142 | El Centro | LAP
2 | James Carter | [email protected] | 7605550199 | Brawley | MON
3 | Sofia Nguyen | [email protected] | 7605550110 | Calexico | KEY
4 | Daniel Brooks | no email | 7605550123 | Imperial | MOU
5 | José Ramírez | [email protected] | 7605550177 | El Centro | DES
Para conservar los valores limpios, guárdalos con UPDATE o crea una tabla o vista limpia, después de probar primero el SELECT.
Rendimiento: Funciones en la Cláusula WHERE
Envolver una columna en una función dentro de WHERE normalmente impide que la base de datos use un índice normal de esa columna:
-- No puede usar un índice normal sobre email
SELECT * FROM customers WHERE LOWER(email) = '[email protected]';
En tablas pequeñas no importa. En tablas grandes, guarda los datos ya limpios (correos en minúsculas desde que se registran) o crea un índice de expresión que coincida con la función, que PostgreSQL y SQLite admiten:
CREATE INDEX idx_customers_email_lower ON customers (LOWER(email));
MySQL 8 admite la misma idea, pero la expresión necesita un par de paréntesis extra: ON customers ((LOWER(email))). En SQL Server, indexa una columna calculada.
También evita los patrones que empiezan con %, como LIKE '%example.com'; tampoco pueden usar un índice normal. Consulta Por Qué Tu Consulta SQL Es Lenta para saber más.
Errores Comunes que Debes Evitar
- Olvidar que NULL se propaga.
'Email: ' || NULLes NULL, yCONCATde MySQL devuelve NULL si cualquier argumento es NULL. UsaCOALESCEoCONCAT_WS. - Usar
||en MySQL, donde significa O lógico. - Contar bytes en lugar de caracteres con
LENGTHde MySQL, o no ver los espacios finales conLENde SQL Server. - Empezar las posiciones en 0. Las cadenas de SQL empiezan en la posición 1.
- Suponer que las mayúsculas funcionan igual en todas partes. Prueba
LIKEy=en tu base de datos, o normaliza conLOWER. - Quitar espacios pero no corregir las mayúsculas (o al revés) antes de agrupar o unir tablas.
- Actualizar datos sin probar. Ejecuta la limpieza primero como
SELECTy respalda la tabla antes de unUPDATE. - Armar consultas concatenando lo que escribe el usuario, lo que abre la puerta a la inyección SQL. Usa parámetros.
Preguntas Frecuentes
¿Qué son las funciones de texto en SQL?
Son funciones integradas que trabajan con valores de texto: medir la longitud, cambiar mayúsculas y minúsculas, quitar espacios, unir, extraer, buscar y reemplazar caracteres. Se usan para limpiar datos, crear etiquetas y separar códigos dentro de una consulta.
¿Cómo concateno cadenas en SQL?
Usa CONCAT(a, b) en PostgreSQL, MySQL y SQL Server, || en PostgreSQL y SQLite, o + en SQL Server. Usa CONCAT_WS(separador, ...) para unir varios valores con un separador y omitir los NULL.
¿Cuál es la diferencia entre SUBSTRING y SUBSTR?
Hacen lo mismo. La mayoría de las bases de datos aceptan SUBSTRING; SQLite usa SUBSTR (Oracle también), y MySQL y PostgreSQL aceptan las dos.
¿Cómo quito los espacios de una cadena en SQL?
TRIM quita los espacios de ambos extremos, LTRIM y RTRIM los quitan de un solo lado, y REPLACE(s, ' ', '') quita todos los espacios, incluidos los de en medio.
¿Cómo divido una cadena en SQL?
Usa SPLIT_PART(s, '-', 2) en PostgreSQL o SUBSTRING_INDEX en MySQL. En SQL Server y SQLite, combina CHARINDEX/INSTR con SUBSTRING. SQL Server también tiene STRING_SPLIT para convertir una cadena con delimitadores en filas.
¿Las comparaciones de texto en SQL distinguen mayúsculas?
Depende de la base de datos y de su intercalación. PostgreSQL y SQLite comparan con = distinguiendo mayúsculas; MySQL y SQL Server no las distinguen de forma predeterminada. Usa LOWER en ambos lados cuando necesites un comportamiento consistente.
Conclusión
Unas cuantas funciones de texto resuelven la mayoría de los problemas reales: TRIM y UPPER/LOWER para estandarizar valores, CONCAT y CONCAT_WS para crear etiquetas, SUBSTRING, LEFT y RIGHT para separar códigos, las funciones tipo POSITION para encontrar caracteres, REPLACE y REGEXP_REPLACE para quitar caracteres no deseados y STRING_AGG para combinar filas.
Ten a la mano la tabla rápida, porque los nombres cambian entre bases de datos, y recuerda las tres cosas que causan más sorpresas: los NULL al concatenar, los bytes frente a los caracteres y la distinción entre mayúsculas y minúsculas. Prueba cada limpieza con un SELECT antes de modificar los datos.
Lecturas Relacionadas
- Funciones de Agregación en SQL: COUNT, SUM, AVG, MIN y MAX
- Funciones de Fecha en SQL: Cómo Trabajar con Fechas y Horas
- Limpiar Datos Desordenados con SQL Puro: Guía para Principiantes
- Funciones de Ventana en SQL: Totales Acumulados y Rankings
- ¿Qué Es SQLite? Guía para Principiantes con Ejemplos en Python
