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).