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

TareaPostgreSQLMySQLSQL ServerSQLite
Longitud (caracteres)LENGTH(s)CHAR_LENGTH(s)LEN(s)LENGTH(s)
Mayúsculas / minúsculasUPPER(s), LOWER(s)igualigualigual (solo ASCII)
Primera letra en mayúsculaINITCAP(s)(hay que armarla)(hay que armarla)(hay que armarla)
Quitar espaciosTRIM(s)TRIM(s)TRIM(s) (2017+)TRIM(s)
Unir textoa || b, CONCAT(a, b)CONCAT(a, b)a + b, CONCAT(a, b)a || b
Unir con separadorCONCAT_WS(sep, ...)CONCAT_WS(sep, ...)CONCAT_WS(sep, ...) (2017+)concat_ws(sep, ...) (versiones recientes)
Parte de una cadenaSUBSTRING(s, inicio, largo)SUBSTRING(s, inicio, largo)SUBSTRING(s, inicio, largo)SUBSTR(s, inicio, largo)
Primeros / últimos caracteresLEFT(s, n), RIGHT(s, n)igualigualSUBSTR(s, 1, n), SUBSTR(s, -n)
Buscar un carácterPOSITION('@' IN s)LOCATE('@', s)CHARINDEX('@', s)INSTR(s, '@')
Reemplazar textoREPLACE(s, viejo, nuevo)igualigualigual
Reemplazar con un patrónREGEXP_REPLACE(...)REGEXP_REPLACE(...)(no en 2022)(no incluido)
Rellenar con caracteresLPAD(s, n, '0')LPAD(s, n, '0')RIGHT('000' + s, n)SUBSTR('000' || s, -n)
Combinar filas en una cadenaSTRING_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, LENGTH cuenta bytes, no caracteres. LENGTH('José') devuelve 5, porque la é ocupa dos bytes en UTF-8. Usa CHAR_LENGTH('José'), que devuelve 4.
  • En SQL Server, LEN ignora los espacios al final. LEN(' maria ') devuelve 7, no 8. Usa DATALENGTH para contar bytes, incluidos los espacios finales (un NVARCHAR usa 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
  • UPPER y LOWER funcionan en todas. Pasar los correos a minúsculas antes de compararlos o guardarlos evita tratar [email protected] y [email protected] como personas distintas.
  • INITCAP pone 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ónQué 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 NULLPostgreSQLMySQLSQL ServerSQLite
'Email: ' || email o 'Email: ' + emailNULL(no concatena)NULLNULL
CONCAT('Email: ', email)Email:NULLEmail:Email:
CONCAT_WS(' | ', ...)Omite el NULLOmite el NULLOmite el NULLOmite el NULL

Dos cosas que recordar:

  • En MySQL, CONCAT devuelve NULL si cualquier argumento es NULL. Envuelve las columnas en COALESCE(email, '') o usa CONCAT_WS, que omite los NULL.
  • En MySQL, || significa O lógico de forma predeterminada, no concatenación. SELECT 'a' || 'b' devuelve 0. Usa CONCAT.

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 datosBuscar @ en emailDominio
PostgreSQLPOSITION('@' IN email) o STRPOS(email, '@')SPLIT_PART(email, '@', 2)
MySQLLOCATE('@', email) o INSTR(email, '@')SUBSTRING_INDEX(email, '@', -1)
SQL ServerCHARINDEX('@', email)SUBSTRING(email, CHARINDEX('@', email) + 1, LEN(email))
SQLiteINSTR(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 REPLACE anidado.

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 datosSintaxis
PostgreSQLSTRING_AGG(name, ', ' ORDER BY id)
MySQLGROUP_CONCAT(name ORDER BY id SEPARATOR ', ')
SQL ServerSTRING_AGG(name, ', ') WITHIN GROUP (ORDER BY id)
SQLiteGROUP_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é
PostgreSQLNo (devuelve los id 2 y 5)LIKE distingue mayúsculas; usa ILIKE para ignorarlas
MySQLSí (id 1, 2 y 5)La intercalación (collation) predeterminada no distingue mayúsculas
SQL ServerSí (id 1, 2 y 5)La intercalación predeterminada no distingue mayúsculas
SQLiteSí (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: ' || NULL es NULL, y CONCAT de MySQL devuelve NULL si cualquier argumento es NULL. Usa COALESCE o CONCAT_WS.
  • Usar || en MySQL, donde significa O lógico.
  • Contar bytes en lugar de caracteres con LENGTH de MySQL, o no ver los espacios finales con LEN de 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 LIKE y = en tu base de datos, o normaliza con LOWER.
  • 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 SELECT y respalda la tabla antes de un UPDATE.
  • 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