Funciones ② — Funciones de cadena (LENGTH / TRIM / REPLACE / UPPER / SUBSTR)

Datos usados en este artículo — la tabla staff

El segundo artículo sobre funciones se centra en las funciones de cadena. Recorreremos las funciones que usarás siempre que necesites limpiar o transformar texto sacado de una tabla en producción: longitud, eliminación de espacios, sustitución, conversión de mayúsculas, y extracción de subcadena.

El conjunto de datos es la misma tabla staff que la última vez (10 filas: name / city / salary, etc.). Usando los nombres en la columna name como estrella, cuatro ejercicios cubren cálculo de longitud, sustitución de apellido, conversión a mayúsculas, y extracción de iniciales.

Antes de meterte en los ejercicios, verifiquemos las definiciones de columnas y los datos de muestra de la tabla staff.

① Ejecuta PRAGMA table_info(staff); para ver los nombres de columnas, tipos y clave primaria.

② Ejecuta SELECT * FROM staff LIMIT 5; para previsualizar las primeras 5 filas.

Longitud de cadena — `LENGTH` y `CHAR_LENGTH`

La función para medir la longitud de una cadena se comporta diferente entre la consola de este curso (SQLite) y MySQL, así que ¡atención!:

- Consola de este curso (SQLite): LENGTH(s) devuelve el conteo de caracteres ('niño' → 4)

- MySQL: LENGTH(s) devuelve el conteo de bytes ('niño' → 5, porque ñ ocupa 2 bytes en UTF-8). Para obtener el conteo de caracteres, usa CHAR_LENGTH(s)

Este artículo usa LENGTH() para los ejercicios, pero es importante conocer la diferencia — cualquier texto con tildes, eñes o caracteres no ASCII cae en esta trampa.

-- 1) Cuenta caracteres (en la consola de este curso, LENGTH devuelve el conteo de caracteres)
SELECT LENGTH('Alice');         -- 5
SELECT LENGTH('niño');          -- 4 (aquí), 5 (LENGTH de MySQL = conteo de bytes)

-- 2) Ordena por longitud de columna
SELECT name, LENGTH(name) AS name_len FROM staff
ORDER BY name_len DESC;

-- Referencia: en MySQL, el conteo de caracteres es CHAR_LENGTH(s)
--   SELECT CHAR_LENGTH('niño') FROM dual;  -- 4

Imagina una lista de empleados que destaca el «TOP 3 de empleados por longitud de nombre completo». (Si lo ejecutas correctamente, aparecerá una explicación.)

① Desde la tabla staff, extrae name y LENGTH(name) con el alias name_len — 2 columnas en total.

② Ordena por name_len descendente. Para empates, desempata por name ascendente (alfabético) — orden multinivel.

③ Limita a las 3 primeras filas.

④ Verifica que el resultado es 3 filas: Iris Watanabe 13 / Alice Tanaka 12 / Carol Tanaka 12.

Eliminación de espacios y sustitución — `TRIM` y `REPLACE`

En tablas del mundo real, te encontrarás con espacios no deseados — «alguien hizo un copia y pega con espacios al principio o al final», «un sistema previo a la migración dejó espacios de ancho completo dentro de los datos», etc. TRIM(s) quita espacios de ambos extremos de una cadena; LTRIM(s) quita solo el lado izquierdo, y RTRIM(s) solo el derecho.

REPLACE(s, buscar, reemplazar) reemplaza cada ocurrencia de buscar en s con reemplazar. Es la función ideal para normalización y migraciones — «abreviar el apellido frecuente Tanaka a T. para una visualización compacta», «cambiar el dominio de un correo electrónico por uno nuevo», etc. Combínala con UPDATE y puedes reescribir valores directamente en la tabla.

-- 1) Eliminación de espacios: TRIM / LTRIM / RTRIM
SELECT TRIM('  Hello  ');     -- 'Hello'
SELECT LTRIM('  Hello  ');    -- 'Hello  '
SELECT RTRIM('  Hello  ');    -- '  Hello'

-- TRIM en columna: detecta filas con espacios por diferencia de longitud
SELECT name FROM staff
WHERE LENGTH(name) <> LENGTH(TRIM(name));

-- 2) Sustitución: REPLACE
SELECT REPLACE('I LIKE APPLE', 'APPLE', 'BANANA');
-- 'I LIKE BANANA'

-- REPLACE en columna — abreviar 'Tanaka' a 'T.'
SELECT name, REPLACE(name, 'Tanaka', 'T.') AS short_name
FROM staff;

Aplicar TRIM — combinar con UPDATE para arreglar texto inconsistente

TRIM no es solo para leer — combinada con UPDATE, puede reescribir valores directamente en la tabla. Por ejemplo, para normalizar masivamente una columna name con espacios inesperados al inicio o final, escribe algo como UPDATE staff SET name = TRIM(name) WHERE LENGTH(name) <> LENGTH(TRIM(name)); — el patrón seguro es filtrar primero con WHERE, luego UPDATE. Si quitas el WHERE, cada fila recibe TRIM (casi sin daño pero con UPDATE innecesarios). REPLACE funciona igual: UPDATE tabla SET columna = REPLACE(columna, 'A', 'B') es una técnica básica para arreglar texto inconsistente en masa.

Imagina una petición: «en un dashboard compacto, abreviar el apellido frecuente Tanaka a T.».

① Desde la tabla staff, extrae name y REPLACE(name, 'Tanaka', 'T.') con el alias short_name — 2 columnas en total.

② Verifica que el resultado tiene 10 filas. Los 4 nombres que contienen Tanaka (Alice / Carol / Frank / Jack) deberían tener short_name como 'Alice T.' / 'Carol T.'.

Conversión de mayúsculas y subcadena — `UPPER` / `LOWER` / `SUBSTR`

UPPER(s) convierte una cadena a todo mayúsculas, y LOWER(s) a todo minúsculas. Úsalas cuando quieras condiciones de búsqueda insensibles a mayúsculas (WHERE UPPER(email) = 'X@Y.COM') o un formato de visualización consistente. No tienen efecto en caracteres sin distinción de mayúsculas (como el japonés).

SUBSTR(s, inicio, longitud) extrae longitud caracteres a partir de la posición inicio (también se puede escribir SUBSTRING). Las posiciones en SQL son base 1, así que SUBSTR('Alice Tanaka', 1, 5) devuelve 'Alice'. Omite el tercer argumento y devuelve hasta el final; pasa un inicio negativo como SUBSTR(s, -3) y cuenta desde el final.

-- 1) UPPER / LOWER
SELECT UPPER('apple'), LOWER('APPLE');
-- 'APPLE', 'apple'

-- Sobre columna: saca los nombres en mayúsculas y minúsculas
SELECT name, UPPER(name) AS upper_name, LOWER(name) AS lower_name
FROM staff;

-- 2) SUBSTR: las posiciones son base 1
SELECT SUBSTR('Alice Tanaka', 1, 5);   -- 'Alice'
SELECT SUBSTR('Alice Tanaka', 7, 6);   -- 'Tanaka'
SELECT SUBSTR('Alice Tanaka', 7);      -- 'Tanaka'  -- omite longitud → hasta el final
SELECT SUBSTR('Alice Tanaka', -6);     -- 'Tanaka'  -- negativo → desde el final

-- Primer carácter de cada nombre
SELECT name, SUBSTR(name, 1, 1) AS initial FROM staff;

-- Referencia: REVERSE es una función MySQL / Oracle — no está en la consola de este curso
--   SELECT REVERSE('Alice Tanaka');  -- 'akanaT ecilA' (funciona en MySQL)

Imagina una petición: «agrupar archivos de empleados por inicial, así que saca cada inicial y ordénalo».

① Desde la tabla staff, extrae name, UPPER(name) como upper_name y SUBSTR(name, 1, 1) como initial — 3 columnas en total.

② Ordena por initial ascendente (alfabético), con name ascendente como desempate.

③ Verifica que el resultado tiene 10 filas, empezando con Alice Tanaka / ALICE TANAKA / A y terminando con Jack Tanaka / JACK TANAKA / J.

Encontrar la posición de una subcadena — `INSTR`

INSTR(objetivo, buscar) devuelve la posición (índice base 1) donde buscar aparece primero en objetivo. Las posiciones empiezan en 1, y si la cadena buscada no se encuentra, devuelve 0. Por ejemplo, INSTR('Alice Tanaka', ' ') devuelve 6 porque el espacio está en la 6ª posición.

Combínala con SUBSTR y puedes cortar una cadena basándote en un separador en vez de una posición fija. Es el combo ideal para transformar cadenas de longitud variable — «separar un correo alrededor del @», «extraer solo el apellido de un nombre completo», etc.

-- 1) INSTR solo — verifica la posición del espacio
SELECT name, INSTR(name, ' ') AS space_pos FROM staff;
-- 'Alice Tanaka' → 6, 'Bob Suzuki' → 4, ...

-- 2) Combinado con SUBSTR para extraer el apellido
SELECT name,
       SUBSTR(name, INSTR(name, ' ') + 1) AS last_name
FROM staff;

-- 3) Separa alrededor de '@' (ejemplo de correo)
SELECT INSTR('alice@example.com', '@'); -- 6

Imagina una petición: «extrae solo la parte apellido de cada nombre completo y muestra el top 5 en orden alfabético por apellido». En staff, name tiene la forma «Alice Tanaka» — «nombre espacio apellido», separado por un espacio de media anchura. Como los nombres varían en longitud, en vez de cortar en una posición fija, usa INSTR para encontrar la posición del espacio y luego corta después.

① Desde la tabla staff, extrae name y SUBSTR(name, INSTR(name, ' ') + 1) con el alias last_name — 2 columnas en total.

② Orden multinivel: last_name ascendente, con name ascendente como desempate. Limita a las 5 primeras filas.

③ Verifica que el resultado es 5 filas (David Sato / Emi Sato / Henry Sato / Bob Suzuki / Grace Suzuki).