No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso Práctico de SQL

Curso Práctico de SQL

Israel Vázquez Morales

Israel Vázquez Morales

Regularizando expresiones

23/29
Recursos

Aportes 65

Preguntas 4

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

“¡A respirar!, ya acabó el cardio”. JAJAJA

La expresión regular es la siguiente

~*'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}'

Experimentando un poco con lpad y rpad, logre dibujar un árbol 😂 🌲

SELECT lpad('\', s.a, rpad(lpad('/', d.e, ' '), s.a, '*'))
FROM generate_series(18, 26) AS s(a), 
	 generate_series(17,0,-2) AS d(e)
LIMIT 10;```

Interesante clase. Tiro un tip: Este símbolo ‘~’ se hace con ALT + 126.

lo dijo starlord, yo le haria caso

Para los que quieran el filtrado de los ‘’@google’’
~*’[A-Z0-9._%±]+@google[A-Z0-9.-]+.[A-Z]{2,4}’

SELECT  lpad ('*', generate_series, '*')
FROM    generate_series(1,10);```

Código escrito en clase😃.

select email
from platzi.alumnos
where email ~*'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}';
-- ~*: De forma global
--[A-Z0-9.%+-]: Que vayan de la A a la Z sin contar mayúsculas o minúsculas y que vayan del 0 al 9(alfanuméricos) o que incluyan algunos caracteres como ._%+-
-- @[A-Z0-9.-]: específicamente debe existir el caracter @ y luego los demás caracteres y puede tenr . o -
-- \.[A-Z]{2,4}: termina en . y al final van de 2 a 4 caracteres max.

select email
from platzi.alumnos
where email ~*'[A-Z0-9._%+-]+@google[A-Z0-9.-]+\.[A-Z]{2,4}';
-- filtrar correos de google

Dato: La expresión que va dentro de las comillas no debe tener espacios.

Expresiones regulares será uno de mis próximos cursos, es clave para el análisis de textos.

No pude hallarlo en SQL Server.
¿Alguien pudo realizar el código en SQL Server?

Si a alguien le interesa esta es la expresión regular completa para generar números realistas de teléfonos de Estados Unidos:
[2-9][0-9]{2}-[2-9][0-9]{2}-[0-9]{4}

Regularizando expresiones
Permiten insertar una lógica extensa y compleja de manera sencilla

SELECT email
FROM platzi.alumnos
WHERE email ~*'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}';

Ejercicio de la clase anterior:

select lpad('*', s.a, '*')
from generate_series(1, 15) AS s(a);

ya soy fit?

Las expresiones regulares son tremendamente utiles, solamente pensando en los correos, podemos saber de que pais es cada usuario añadiendo un Group by por (.co, .ar, .mx, .ru, etc), esta ha sido la clase que mas me llamo la atencion de lo que va hasta ahora.

Este fue el código que se me ocurrió:

SELECT lpad('*', a.id, '*'), s.a
FROM platzi.alumnos AS a
	INNER JOIN generate_series(0, (SELECT COUNT(*) FROM platzi.alumnos)) AS s(a)
	ON s.a = a.id
LIMIT 30;

Las expresiones regulares son patrones que se utilizan para buscar y manipular texto. Usar expresiones regulares en SQL, específicamente con la función REGEXP o SIMILAR TO, dependiendo del sistema de gestión de bases de datos que estés utilizando.

-- En PostgreSQL utilizando REGEXP
SELECT *
FROM platzi.alumnos
WHERE nombre ~ '^A';

-- En MySQL utilizando REGEXP
SELECT *
FROM platzi.alumnos
WHERE nombre REGEXP '^A';

Para los que usan MySQL Worbench, pueden utilizar el siguiente código:

SELECT email
FROM platzi.alumnos
WHERE email REGEXP ‘[A-Z0-9._%±]+@[A-Z0-9.-]+.[A-Z]{2,4}’;

Ahora las terminaciones de dominio (.com, .travel, .info, .club, .cloud) no son más 2 a 4, pueden ser más extensos. Ojo ahí. Poco comunes, pero los hay.

Curso de expresiones regulares terminando éste 👾

<h3>pruebas=# SELECT rpad(‘sql’, generate_series(0,10),’*’);
rpad</h3>

s
sq
sql
sql*
sql**
sql***
sql****
sql*****
sql******
sql*******
(11 filas)

otra manera de resolver el reto SELECT repeat('\*', s.a) FROM generate\_series(1, 5) AS s(a);
En SQL, las **expresiones regulares** (RegEx) permiten buscar y manipular texto mediante patrones. Estas son extremadamente útiles para validar datos, realizar búsquedas avanzadas, y transformar información. Diferentes bases de datos soportan expresiones regulares de manera distinta. A continuación, te explico cómo usarlas en PostgreSQL, MySQL y Oracle. ## **1. PostgreSQL y expresiones regulares** ### **Operadores comunes** * `~` : Coincide con un patrón (sensible a mayúsculas y minúsculas). * `~*`: Coincide con un patrón (insensible a mayúsculas y minúsculas). * `!~` : No coincide con un patrón (sensible a mayúsculas y minúsculas). * `!~*`: No coincide con un patrón (insensible a mayúsculas y minúsculas). #### **Ejemplo: Buscar nombres que comienzan con "A"** SELECT nombre FROM usuarios WHERE nombre ~ '^A'; **Explicación**: El patrón `^A` busca cadenas que empiezan con la letra "A". #### **Ejemplo: Buscar cadenas que terminan en un número** SELECT nombre FROM usuarios WHERE nombre ~ '\[0-9]$'; **Explicación**: `[0-9]$` busca cadenas que terminan con un dígito. ### **Funciones relacionadas** * `regexp_matches`: Devuelve las coincidencias encontradas. * `regexp_replace`: Reemplaza texto basado en un patrón. #### **Ejemplo: Reemplazar espacios por guiones bajos** SELECT regexp\_replace(nombre, ' ', '\_', 'g') AS nombre\_modificado FROM usuarios; **Explicación**: Reemplaza todos los espacios por guiones bajos. #### **Ejemplo: Extraer el dominio de un correo electrónico** SELECT regexp\_matches(email, '@(.+)$') AS dominio FROM usuarios; **Explicación**: Extrae todo después del símbolo `@`. ## **2. MySQL y expresiones regulares** En MySQL, se utiliza la función `REGEXP` para trabajar con expresiones regulares. ### **Operadores comunes** * `REGEXP` o `RLIKE`: Para buscar coincidencias con un patrón. * `NOT REGEXP`: Para buscar lo que **no** coincide con el patrón. #### **Ejemplo: Buscar correos con dominio "gmail.com"** SELECT email FROM usuarios WHERE email REGEXP 'gmail\\\\.com$'; **Explicación**: Busca correos que terminan con `gmail.com`. Se usa `\\.` para escapar el punto. #### **Ejemplo: Validar números de teléfono (10 dígitos)** SELECT telefono FROM usuarios WHERE telefono REGEXP '^\[0-9]{10}$'; **Explicación**: `^[0-9]{10}$` busca cadenas con exactamente 10 dígitos. ### **Funciones relacionadas** * `REGEXP_REPLACE`: Introducido en MySQL 8.0 para reemplazar texto basado en un patrón. #### **Ejemplo: Reemplazar guiones en números de teléfono** SELECT REGEXP\_REPLACE(telefono, '-', '') AS telefono\_limpio FROM usuarios; **Explicación**: Elimina todos los guiones de la columna `telefono`. ## **3. Oracle y expresiones regulares** Oracle incluye funciones avanzadas para expresiones regulares como `REGEXP_LIKE`, `REGEXP_REPLACE`, `REGEXP_INSTR` y `REGEXP_SUBSTR`. ### **Ejemplo: Buscar nombres que contienen números** SELECT nombre FROM usuarios WHERE REGEXP\_LIKE(nombre, '\[0-9]'); **Explicación**: Busca nombres que contengan algún dígito. ### **Reemplazar texto con** `REGEXP_REPLACE` #### **Ejemplo: Convertir texto a minúsculas** SELECT REGEXP\_REPLACE(nombre, '\[A-Z]', LOWER('\0')) AS nombre\_minusculas FROM usuarios; **Explicación**: Reemplaza todas las letras mayúsculas por minúsculas. ### **Extraer texto con** `REGEXP_SUBSTR` #### **Ejemplo: Extraer el código postal de una dirección** SELECT REGEXP\_SUBSTR(direccion, '\[0-9]{5}') AS codigo\_postal FROM usuarios; **Explicación**: Extrae un número de 5 dígitos (código postal) de la columna `direccion`. ## **Patrones comunes en SQL** PatrónDescripción`^`Inicio de la cadena.`$`Fin de la cadena.`.`Cualquier carácter.`[abc]`Coincide con cualquiera de `a`, `b` o `c`.`[^abc]`No coincide con `a`, `b` o `c`.`[a-z]`Coincide con letras minúsculas de la `a` a la `z`.`[0-9]`Coincide con dígitos del 0 al 9.`\d`Cualquier dígito (igual a `[0-9]`).`\w`Cualquier carácter alfanumérico o guion bajo.`\s`Cualquier espacio en blanco.`{n}`Exactamente `n` repeticiones.`{n,}`Al menos `n` repeticiones.`{n,m}`Entre `n` y `m` repeticiones.`*`Cero o más repeticiones.`+`Una o más repeticiones.`?`Cero o una repetición.
Sintaxis para email: ```js ~*'[caracteres_posibles]+@[caracteres_posibles]+\.[caracteres_posibles]{#_min, #_max}' ``` Sin espacios.
\~\*'\[A-Z0-9.\_%+-]+@\[A-Z0-9.-]+\\.\[A-Z]{2,4}'; Tengo una duda, qué función cumple el backslash "\\" en la expresión regular?
**Principales Usos de los REGEX** 1. **Procesamiento de textos:** Búsqueda y manipulación de texto en archivos, correos electrónicos, logs, etc. 2. **Validación de entradas:** Verificar los datos ingresados por un usuario, que cumplan con un formato definido. 3. **Análisis de datos:** Extraer información específica de grandes volúmenes de texto. 4. **Reemplazo de texto:** Realizar sustituciones masivas en documentos o datos.
El tipo nunca se cambió de ropa. Hizo el curso en 6 horas.
Mucho cardio 🚴‍♂️♥⏱😅
SELECT lpad ('\*', s.a :: INT,'3') FROM generate\_series(0,10) AS s(a);
Unos ejemplos del poder de las \*\*REGEX\*\* ![](https://static.platzi.com/media/user_upload/image-a6a04a02-cf5e-4a83-aa6b-60892d997e05.jpg)
```js SELECT rpad('*', CAST(s.a AS int), '*') FROM generate_series(1,15) AS s(a); ```SELECT rpad('\*', CAST(s.a AS int), '\*') FROM generate\_series(15,1,-2) AS s(a);
```js SELECT LPAD('*',A.ID,'*') FROM PLATZI.alumnos A JOIN GENERATE_SERIES(A.ID,10) AS S(A) ON A.ID=S.A ```
-- Join con secuencia --
SELECT 	a.id,
		a.nombre,
		a.apellido,
		a.carrera_id,
		s.a
FROM	platzi.alumnos AS a
	INNER JOIN	generate_series(0,10) AS s(a)
	ON s.a = a.carrera_id
ORDER BY a.carrera_id;

-- reto solucion 
WITH RECURSIVE Triangulo AS (
  SELECT 1 AS nivel, 1 AS valor
  UNION ALL
  SELECT t.nivel + 1, t.valor + 1
  FROM Triangulo t
  WHERE t.nivel < 30  -- Puedes ajustar el número de niveles
)

SELECT
  LPAD('', (30 - nivel) * 3, '* ') || array_to_string(ARRAY(SELECT valor FROM Triangulo WHERE nivel = t.nivel), ' ') AS fila
FROM Triangulo t
ORDER BY t.nivel DESC;
  • Este ejemplo utiliza una consulta recursiva (WITH RECURSIVE) para generar los valores del triángulo. Puedes ajustar el número de niveles según tus necesidades.

La consulta final utiliza LPAD para agregar espacios en blanco al principio de cada fila y array_to_string para concatenar los valores de cada

Para el caso de postgresql acá vemos los comodines que podemos emplear como regex (expresiones regulares) para buscar patrones en cadenas de texto <https://www.postgresql.org/docs/current/functions-matching.html>
buenas comparto la solución que hice del ejercicio de lpad + generate\_series. Saludos ```js SELECT lpad('*',al.id,'*') from platzi.alumnos as al inner join generate_series(0,10) as s(a) on s.a = al.id ```
```js SELECT rpad('*', a, '*') FROM generate_series(1, 16) AS s(a); ```

ordinality hace casi la misma acción que un SELECT ROW_NUMBER. Aquí mi código:

SELECT *, ROW_NUMBER() OVER() AS row_id
FROM generate_series (10,2,-2)

En MySql, para el uso de expresiones regulares, se utiliza el comando regexp “aquí el patrón”. en este caso para el email quedaría así.

select email, row_number() over()
from alumnos 
where email regexp "[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}";

**ESTO ES UNA ESCARMUZA… prender un cigarro AHORA VIENE LA GUERRA. **

Yo lo hice de esta manera:

SELECT lpad('*', t.s, '*')
FROM platzi.alumnos AS a
         INNER JOIN generate_series(0, 20) AS t(s)
                    ON t.s = a.id
WHERE t.s <= 10;

Es muy importante las expresiones regulares sobre todo para manipulacion de datos de tipo String , en mi caso para agilizar las busquedas usaria un like

SELECT email
FROM alumnos
WHERE email LIKE '%@google%'

En la ultima expresión regular de la clase donde se buscan los correos @google, el resultado no muestra todos los correos de google que hay en la tabla.

La expresión regular

'[A-Z0-9._%+-]+@google[A-Z0-9.-]+\.[A-Z]{2,4}'

indica que debe existir al menos un caracter despues de la palabra google y antes del dominio.

Para obtener todos los correos de google la expresión regular debe permitir que tenga o no caracteres despues de la palabra google. Se logra cambiando el ˝+˝ por un ˝?˝. Quedando la expresion regular:

'[A-Z0-9._%+-]+@google[A-Z0-9.-]?\.[A-Z]{2,4}'

SELECT lpad(’’,generate_series(1,10),’*’);

sirve mi codigo?

– GENERAR UN TRIANGULO A TRAVÉS DE GENERATE_SERIES
SELECT LPAD(‘HOLA’, CAST(PLOX.A AS INTEGER), ‘*’)
FROM (
SELECT DISTINCT S.A
FROM PLATZI.ALUMNOS AS A
INNER JOIN GENERATE_SERIES(0, 100) AS S(A)
ON S.A = A.CARRERA_ID
ORDER BY S.A
) AS PLOX;

Excelente cardio!!

Si en una vista se desea ocultar el nombre de usuario en la dirección de correo electrónico se podría usar regex y lpad así:

SET search_path = 'platzi';
SELECT lpad((regexp_matches(email, '^(.*)(@.*)$'))[2], LENGTH(email), '*') AS token_email FROM alumnos;

puro cardio en zona 1-2 jajaja

Solucion al reto anterior, utilizando ORDINALITY para crear una columna con numeros ordinales, y que se puede utilizar dentro de la funcion lpad

SELECT lpad('*',ordinality::int,'*')
FROM generate_series(100,2,-2) WITH ORDINALITY

Las expresiones regulares se van a utilizar para hacer un filtrado de datos.

Empiezan con ~*

-- Va a filtrar todos los emails de acuerdo al sig. patron
SELECT email FROM platzi.alumnos
WHERE email ~*'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}';

-- Nos trae filtrado la palabra 'google'
SELECT email FROM platzi.alumnos
WHERE email ~*'[A-Z0-9._%+-]+@google[A-Z0-9.-]+\.[A-Z]{2,4}';

Aquí mi solución 😃!

SELECT LPAD('*', a,'*')
FROM generate_series(1,5) AS s(a)

En la última parte no aparecen todos los correos '…@google…'
Para que arroje todos los correos que sean @google yo borré la última parte de la expresión regular.
(Me arrojó 34 rows)

SELECT email
FROM platzi.alumnos
WHERE email ~*'[A-Z0-9._%+-]+@google[A-Z0-9.-]';

Don’t get discourage! ya casi terminamos:)

–RETO: GENERANDO RANGOS CON LPAD:


SELECT lpad('*', carrera_id, '*')
FROM platzi.alumnos AS a
	INNER JOIN generate_series(0,100, 10) AS s(a)
	ON s.a = a.carrera_id
ORDER BY a.carrera_id ASC;

RETO CLASE PASADA

SELECT lpad (’*’, s.a, ‘-’)
FROM generate_series(1,15) AS s(a);

Mi propiesta de solución a la prueba del ejercicio anterior fue la más sencilla que se me ocurrió, quedo abierto a sus comentarios.

SELECT lpad('*',generate_series(1,10),'*') 

**El resultado que obtuve fue: **

Ahí va el reto de mi parte

SELECT rpad('HOLA',n.id,';)')
FROM generate_series(1,100,1) AS n(id)

SELECT lpad(’’, generate_series(1,5),’’)

select lpad(’’,generate_series(1,10),’’)

No entendí nada jejejejeje

	SELECT 
		alumnos.id,
		CONCAT(alumnos.nombre, ' ', alumnos.apellido) as nombre,
		alumnos.fecha_incorporacion as fechaOriginal, 
		alumnos.nroDiasIncremento AS Incremento,
		(alumnos.fecha_incorporacion + alumnos.nroDiasIncremento) as nuevaFecha
	FROM
		(SELECT 
			id, 
			nombre, 
			apellido, 
			CAST(fecha_incorporacion AS DATE) AS fecha_incorporacion, 
			CAST((SELECT MAX(s.dias) FROM generate_series(1, alumnos.id) AS s(dias)) AS int) as nroDiasIncremento 
		FROM alumnos) as alumnos
	ORDER BY alumnos.id

Una vez puse mi correo electrónico en mayúsculas para entrar a platzi y me salió que no estaba registrado. Esta es una falla que ocurre aquí.