Funciones Especiales avanzadas en PosgreSQL
• COALES: compara dos valores y retorna el que es nulo
• NULLIF: Retorna null si son iguales
• GREATEST: Compara un arreglo y retorna el mayor
• LEAST: Compara un arreglo de valores y retorna el menor
• BLOQUES ANONIMOS: Ingresa condicionales dentro de una consulta de BD
Configurar Postgres
Qué aprenderás sobre PostgreSQL
¿Qué es Postgresql?
Instalación y configuración de la Base de Datos
Interacción con Postgres desde la Consola
PgAdmin: Interacción con Postgres desde la Interfaz Gráfica
Archivos de Configuración
Comandos más utilizados en PostgreSQL
Presentación del Proyecto
Tipos de datos
Diseñando nuestra base de datos: estructura de las tablas
Jerarquía de Bases de Datos
Gestión de la información en bases de datos
Creación de Tablas
Particiones
Creación de Roles
Llaves foráneas
Inserción y consulta de datos
Inserción masiva de datos
Generar consultas avanzadas
Cruzar tablas: SQL JOIN
Funciones Especiales Principales
Funciones Especiales Avanzadas
Vistas
PL/SQL
Triggers
Integrar bases de datos con servicios externos
Simulando una conexión a Bases de Datos remotas
Transacciones
Otras Extensiones para Postgres
Implementar mejores prácticas
Backups y Restauración
Mantenimiento
Introducción a Réplicas
Implementación de Réplicas en Postgres
Otras buenas prácticas
Cierre del curso
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Funciones Especiales Avanzadas
20/32Recursos
Aportes 337
Preguntas 12
Ordenar por:
Mi aporte
SELECT id, nombre, fecha_nacimiento,
CASE
WHEN nombre ILIKE 'a%' THEN 'Comienza con A'
WHEN nombre ILIKE 'e%' THEN 'Comienza con E'
WHEN nombre ILIKE 'i%' THEN 'Comienza con I'
WHEN ( current_date - fecha_nacimiento) > 6570 Then 'Es mayor de 18 años'
ELSE 'Su nombre no inicia con A, E o I y ademas es un niño'
END
FROM pasajero ORDER BY fecha_nacimiento;```
lo hice simple pero funciono.
Buena explicacion, este es el codigo del video
SELECT * FROM pasajero WHERE id = 5;
UPDATE pasajero SET nombre = NULL WHERE id = 5
SELECT COALESCE(nombre, 'Nombre en Null') AS nombrenull , * FROM pasajero WHERE id = 5;
SELECT NULLIF(0,0);
SELECT NULLIF(0,1);
SELECT GREATEST(5,5,8,95,75,4225,8,6,9,212,6);
SELECT LEAST(5,5,8,95,75,4225,8,6,9,212,6);
-- Reto
SELECT COALESCE(nombre, 'Nombre en Null') AS nombrenull , *,
CASE WHEN fecha_nacimiento > '2015-01-01' THEN
'Niño' ELSE 'Mayor' END,
CASE WHEN nombre ILIKE 'D%' THEN
'Empieza con D' ELSE 'No empieza con D' END,
Case WHEN extract(years from age(current_timestamp,fecha_nacimiento::timestamp)) >= 18 THEN
'Mayor de edad.' ELSE 'Menor de edad.' END
FROM pasajero;
Funciones Especiales Avanzadas
- COALESCE
- NULLIF
- GREATEST
- LEAST
- BLOQUES ANONIMOS
-- Si el nombre es null, entonces me mostra 'No Aplica'
SELECT id, COALESCE(nombre, 'No Aplica') AS nombre, direccion_residencia FROM public.pasajero
WHERE id = 1;
-- Si dos campos son iguales ---> 0: False
SELECT NULLIF(0,1);
-- Devuelve el mayor
SELECT GREATEST(0,1,2,5,2,3,6,10,2,1,20);
-- Devuelve en menor
SELECT LEAST(0,1,2,5,2,3,6,10,2,1,20);
-- Devuelve si es Niño o Mayor
SELECT id, nombre, direccion_residencia, fecha_nacimiento,
(CASE
WHEN (fecha_nacimiento) > '2015-01-01' THEN
'Niño'
ELSE
'Mayor'
END)
FROM public.pasajero;
-- Reto
SELECT id, nombre, direccion_residencia, fecha_nacimiento,
(CASE
WHEN (CURRENT_DATE - fecha_nacimiento)/365 >= 18 THEN
'>Mayor'
ELSE
'<Menor'
END)
FROM public.pasajero;
Reto:
SELECT
id
,nombre
,CASE
WHEN nombre ILIKE 'A%' THEN 'A'
WHEN nombre ILIKE 'E%' THEN 'E'
WHEN nombre ILIKE 'I%' THEN 'I'
WHEN nombre ILIKE 'O%' THEN 'O'
WHEN nombre ILIKE 'U%' THEN 'U'
ELSE 'OTRA'
END AS comienzo
,fecha_nacimiento
,DATE_PART('year',current_date)-DATE_PART('year',fecha_nacimiento) as edad
,CASE
WHEN DATE_PART('year',current_date)-DATE_PART('year',fecha_nacimiento) >= 18 THEN 'MAYOR'
ELSE 'MENOR'
END AS mayores
FROM pasajeros;
Esta es mi solución al ejercicio:
SELECT id, nombre, direccion_red, fecha_nac,
CASE
WHEN fecha_nac >= (CURRENT_DATE - INTERVAL '18 years') THEN
'menor de edad'
Else
'mayor de edad'
END
FROM public.pasajero
WHERE nombre ILIKE 'a%';```
Practica solicitada en el vídeo:
SELECT
id, nombre, direccion_residencia, fecha_nacimiento,
CASE WHEN (date_part(‘year’,current_date) - date_part(‘year’,fecha_nacimiento)) >= 18 THEN
’Mayor de Edad’
ELSE
’Menor de Edad’
END as Tipo,
CASE WHEN upper(nombre) LIKE ‘O%’ THEN
’Inicia con O’
ELSE
’No inicia con O’
END as Inicio_O
FROM public.pasajero;
YO REALICE UNA CONSULTA PARECIDA AL DEL PROFE SOLO QUE TAMBIÉN MOSTRÉ SU EDAD EN AÑOS Y MESES
AQUÍ LES DEJO LA CONSULTA
Comparto mi código y solución al reto 😃
SELECT full_name, dni, birth_date,
CASE
WHEN full_name ilike ‘a%’ then
’Empieza con A’
ELSE
’No empieza con A’
END,
CASE
WHEN birth_date>‘25-01-2004’ then
’Menor de edad’
ELSE
’Mayor de edad’
END
from passengers;
Para que el nombre de la columna no salga case, al final escriben:
END AS column_name
--Reto listar cuáles pasajero sus nombres comienzan con la letra 'o' y cuáles de ellos tiene más de 18 años
SELECT
id, nombre, direccion_residencia, fecha_nacimiento,
CASE
WHEN nombre ILIKE 'o%' THEN
'Si Aplica'
ELSE
'No Aplica'
END AS Comienza_con_O,
EXTRACT(year FROM age(current_date,fecha_nacimiento)) AS edad
FROM public.pasajero
WHERE EXTRACT(year FROM age(current_date,fecha_nacimiento)) >=18 AND nombre ILIKE 'o%' ;
select id, nombre, direccion_residencia, fecha_nacimiento,
case when nombre ILIKE 'd%' then
'SI' else 'NO' end as Letra_Inicial_D,
case when extract(years from age(current_timestamp, fecha_nacimiento::timestamp)) >= 18 then
'mayor' else 'menor' end as Edad
from public.pasajero;```
Gracias por esta clase!!!
# Funciones Avanzadas en PostgreSQL
COALESCE: Compara entre dos valores para ver cual es NULL y retorna el que NO lo sea
**SELECT user\_id, COALESCE(user\_name, 'No Aplica') FROM public.usuarios;**
Retorna todos los usuarios cuyo nombre no sea NULL
**NULLIF:** Retorna null si ambos valores son iguales
**SELECT NULLIF(10,10) ⇒ Null**
GREATEST: Compara un arreglo y retorna el mayor
LEAST: Compara un arreglo de valores y retorna el meno
Bloques Anónimos: Estos son condicionales como los de cualquier lenguaje de programación pero con una sintaxis distinta
**SELECT \* FROM users**
**CASE**
**WHEN user\_age > 18 THEN**
**‘Mayor de edad’**
**ELSE**
**‘Menor de edad’**
**END**
En el script realizado se puede identificar diferentes iniciales y si la persona es o no mayor de edad.
Esta es mi solución al reto:
SELECT id, nombre, direccion_residencia, fecha_nacimiento,
CASE
WHEN nombre ILIKE ('o%') THEN
'Inicia con O'
ELSE
'Inicia con otra letra'
END AS nombres_por_O,
CASE
WHEN age(current_date, fecha_nacimiento) > '18 years' THEN
'Mayor de edad'
ELSE
'Menor de edad'
END AS mayoria_edad
FROM public.pasajeros;
La función age() te devuelve los años, meses y días que tiene la persona respecto al primer valor fecha que introduces.
Check this 😃
SELECT
nombre,
fecha_nacimiento,
CASE
WHEN (
current_date - fecha_nacimiento) > 0
THEN (current_date - fecha_nacimiento) / 365
END AS EDAD -- para calcular la edad e imprimir la columna edad,
CASE
WHEN (
current_date - fecha_nacimiento)/365 >= 30
THEN ' >= 30'
ELSE '< 30'
END AS VALIDACION -- este hace la validación entre aquellos que efectivamente tengan 30 años o sean menores de esta edad.
FROM public.pasajero
WHERE nombre ILIKE 's%'; -- que me muestre solamente los pasajeros que inician con la letra 'S'
SELECT *,
CASE
WHEN nombre ILIKE 'o%'
THEN 'SI'
ELSE 'NO'
END AS Comienza_con_O,
CASE
WHEN (
SELECT CAST(CONCAT(birth_year+18,'-',birth_month,'-',birth_day) AS date)
FROM (
SELECT EXTRACT(YEAR FROM fecha_nacimiento) AS birth_year,
EXTRACT(MONTH FROM fecha_nacimiento) AS birth_month,
EXTRACT(DAY FROM fecha_nacimiento) AS birth_day
) AS DIF
) < current_date
THEN 'SI'
ELSE 'NO'
END AS MAYOR_EDAD
FROM pasajero;
SELECT *,
CASE WHEN nombre ILIKE 'o%' THEN TRUE
ELSE FALSE
END AS starts_with_o,
CASE WHEN DATE_PART('YEAR', AGE(fecha_nacimiento)) >= 18 THEN TRUE
ELSE FALSE
END AS is_adult
FROM pasajero
Puede anidar unos CASE dentro de otros en el ELSE. Es hermoso :’)
SELECT id, name,
CASE
WHEN name ILIKE 'o%'
THEN 'True'
ELSE 'False'
END AS start_with_an_O,
CASE
WHEN EXTRACT(YEAR FROM current_date) - EXTRACT(YEAR FROM birthday) < 30
THEN 'Menor de edad.'
ELSE 'Mayor de edad.'
END AS older_age
FROM public.passenger
ORDER BY start_with_an_o DESC;
Gracias por la clase, es genial!
SELECT id, nombre, direccion, fecha_nacimiento,
CASE
WHEN nombre ILIKE ‘o%’ THEN
’Inicia con O’
ELSE
’Inicia con otra letra’
END AS Inicial,
CASE
WHEN ((CURRENT_DATE-fecha_nacimiento)/365) >= 18 THEN
’Mayor’
ELSE
’Menor’
END AS Edad
FROM pasajero;
SELECT id_pasajero, nombre , direccion_residencia, fecha_nacimiento,
CASE
WHEN nombre ILIKE('D%') THEN
'SI'
ELSE
'NO'
END AS NOMBRE_EMP_D,
CASE
WHEN EXTRACT(YEAR FROM current_date)- EXTRACT(YEAR FROM fecha_nacimiento)<18 THEN
'MENOR DE EDAD'
ELSE
'MAYOR DE EDAD'
END
FROM public.pasajeros;```
```js
-- Agregar información a una tabla mediante CASE (Función especial: Bloques anónimos)
SELECT id, nombre, direccion_residencia, fecha_nacimiento,
CASE
WHEN fecha_nacimiento > '2012-01-01' THEN 'Niño'
WHEN fecha_nacimiento > '2006-01-01' THEN 'Adolescente'
ELSE 'Adulto'
END
FROM public.pasajeros;
```-- Agregar información a una tabla mediante CASE (Función especial: Bloques anónimos)
SELECT id, nombre, direccion\_residencia, fecha\_nacimiento,
CASE
WHEN fecha\_nacimiento > '2012-01-01' THEN 'Niño'
WHEN fecha\_nacimiento > '2006-01-01' THEN 'Adolescente'
ELSE 'Adulto'
END
FROM public.pasajeros;
SELECT id, nombre, direccion\_residencia, fecha\_nacimiento,
CASE
WHEN nombre ILIKE 'M%' THEN 'M'
ELSE 'Otros'
END AS nombre\_category,
CASE
WHEN fecha\_nacimiento <= (CURRENT\_DATE - INTERVAL '18 years') THEN '+18yo'
ELSE '-18yo'
END AS age\_category
FROM public.pasajero;
SELECT id,nombre,fecha\_nacimiento,
CASE WHEN nombre ilike 'c%' THEN 'begin with c' ELSE 'false' END AS BEGIN\_C,
CASE WHEN (current\_date - fecha\_nacimiento) > 5475 THEN 'over 15 years' END AS IS\_ADULT
FROM pasajero
```js
select id, nombre, dirección, fecha_nacimiento,
case when nombre ilike 'O%' then
'Elegido'
else
'No elegido'
end as "Elegido o no elegido",
case when fecha_nacimiento < '2006-01-01' then
'Mayor de edad'
else
'Aun es un niñó'
end as "Etapa de vida"
from pasajero
order by id asc;
```select id, nombre, dirección, fecha\_nacimiento,
case when nombre ilike 'O%' then
'Elegido'
else
'No elegido'
end as "Elegido o no elegido",
case when fecha\_nacimiento < '2006-01-01' then
'Mayor de edad'
else
'Aun es un niñó'
end as "Etapa de vida"
from pasajero
order by id asc;
Buenas noches
use la siguiente instruccion sql para lo requerido, utilizando dos funciones como son LEFT y AGE.
select \* ,
case when left(nombre,1)='R' then 'SELECCIONADO' ELSE 'NO CUMPLE' END AS seleccionado,
Age(fecha\_nacimiento) edad, date\_part('year',age(fecha\_nacimiento)) AS EDAD
from public.pasajero
where left(nombre,1)='R';
Este fue mi resultado:
```js
-- Muestra una tabla que contenga una columna que cumpla con los siguientes
-- requicitos:
-- Su nombre debe iniciar con O-o (No importa si es mayúscula o minúscula)
-- y que además sea mayor de edad.
-- Esta debe ser resuelta por medio de la tabla "Pasajeros"
SELECT *,
CASE
WHEN p."Nombre" ILIKE 'o%' AND
(EXTRACT(YEAR FROM CURRENT_DATE::date) -
EXTRACT(YEAR FROM p."Fecha_nacimiento"::date) ) >= 18 THEN 'Adulto'
ELSE 'Joven'
END
FROM public."Pasajeros" p;
```
Que tal, yo agregue el condicioal AND para buscar que el nombre del pasajero comenzara con G e igualmente fuera mayor de edad.
Aqui mi resultado:
Esta fue mi solución al ejercicio
```js
SELECT id, nombre, direccion_residencia, fecha_nacimiento,
case
when nombre ilike 'O%' then 'Comienza con la O'
when nombre not ilike 'O%' then 'No comienza con la O'
end as letter_case,
case
when (date_part('Year', now()) - date_part('Year', fecha_nacimiento)) >= 18
then 'Es mayor de edad'
else 'Es menor de edad'
end as edad_case
FROM public.pasajeros;
```
SELECT id, nombre, direccion_residencia, fecha_nacimiento,
CASE
WHEN nombre ILIKE ‘A%’ OR nombre ILIKE ‘E%’ OR nombre ILIKE ‘I%’ OR nombre ILIKE ‘O%’ OR nombre ILIKE ‘U%’ THEN
’Vocal’
ELSE
’Consonante’
END AS inicial
FROM public.pasajero;
SELECT nombre, fecha\_nacimiento,
CASE
WHEN fecha\_nacimiento > '2006-01-01' THEN
'Mayor de edad' ELSE 'Menor de edad'
END
FROM pasajeros
WHERE nombre ILIKE '%a';
Mi aporte 👾, utilice 2 funciones que todavía no hemos visto, para calcular cuantos años han pasado a partir de 2 fechas. Es otra forma de hacerlo.
Resultado
aqui mi reto:
1. Columna nueva Mostrar los que su nombre empiezan con "J".
2. Columna nueva mayores a 18 años sobre la fecha actual.
SELECT \*,
Case when nombre like 'J%' then nombre Else 'No es la J' End,
case when current\_date - fecha\_nacimiento >=18 then '18 años' Else 'Menor a 18 años' End
FROM public.pasajero
ORDER BY id ASC
`-- crea una tabla donde se muestre si el pasajero es mayor de edad`
`SELECT id_pasajero, nombre, `
`DATE_PART('year', now()) - DATE_PART('year', fecha_nacimiento) AS edad,`
`CASE`
`WHEN DATE_PART('year', now()) - DATE_PART('year', fecha_nacimiento)>=18`
`THEN 'mayor de edad'`
`ELSE`
`'menor de edad'`
`END`
` FROM public.pasajero;`
Como realicé el reto:
```js
SELECT pas_id, pas_nombre, pas_direccion_residencia, pas_fecha_nacimiento,
CASE
WHEN pas_nombre ILIKE 'a%' THEN 'Comienza con A'
WHEN pas_nombre ILIKE 'e%' THEN 'Comienza con E'
WHEN pas_nombre ILIKE 'i%' THEN 'Comienza con I'
WHEN pas_nombre ILIKE 'o%' THEN 'Comienza con O'
WHEN pas_nombre ILIKE 'u%' THEN 'Comienza con U'
ELSE 'Comienza con una consonante'
END AS primera_letra,
CASE
WHEN (current_date - pas_fecha_nacimiento) > 6570 THEN 'Mayor de edad'
ELSE 'Menor de edad'
END AS mayor_edad
FROM public.pasajero ORDER BY pas_fecha_nacimiento;
```
Ahí va mi código. He metido un condicional dentro de otro para que el resultado aporte más información.
SELECT id, nombre, direccion\_residencia, fecha\_nacimiento,
CASE
WHEN nombre ILIKE 's%' AND fecha\_nacimiento > '2015-01-01' THEN
'Empieza con la S y es mayor de 18 años'
ELSE
CASE
WHEN fecha\_nacimiento < '2015-01-01' THEN
'No empieza con la S pero es mayor de 18 años'
ELSE 'No empieza con la S ni es mayor de 18 años'
END
END AS consulta\_inicial\_edad
FROM public.pasajero;
Mi solucion a si empieza con Z y ademas es adulo mayor o adulto joven:
`SELECT *,`
` ``CASE WHEN fecha_nacimiento > '1990-01-01' THEN`
` ``'JovenAdulto' ELSE 'Adulto' END,`
`CASE WHEN nombre ILIKE 'z%' THEN`
` ``'Empieza con Z' ELSE 'Nombre sin Z' END`
` ``FROM pasajeros;`
Les comparto mi código
Al principio, en vez de fecha de nacimiento, lo que hice fue crear la columna age.
SELECT id, name, age, residence_address,
CASE
WHEN age < 18 THEN
'Child'
ELSE
'Adult'
END,
CASE
WHEN name LIKE 'O%' THEN
'Yes'
ELSE
'No'
END AS start_with_O
FROM public.passengers;
Haciendo uso de otras herramientas:
* (~) Para aplicar **REGEX** que es más potente que un **LIKE**
* **between** para buscar entre rangos
Dato, el **IDE** que uso para gestionar y hacer código **SQL** es: \*\*DBeaver\*\*
Reto:
SELECT id, nombre,
CASE
WHEN nombre ILIKE 'm%' THEN 'M'
WHEN nombre ILIKE 'a%' THEN 'A'
WHEN nombre ILIKE 'r%' THEN 'R'
ELSE 'Otra letra'
END AS letra_inicio,
direccion_residencia, fecha_nacimiento, EXTRACT(YEAR FROM AGE(fecha_nacimiento)) AS edad,
CASE
WHEN EXTRACT(YEAR FROM AGE(fecha_nacimiento)) >= 18
THEN 'Mayor de edad'
ELSE 'Menor de edad'
END AS edad_categoria
FROM public.pasajero;
Solo para compartir como hice una columna para poder ver la edad de todos, aunque me parece que seria mejor si usara los días para la edad exacta
`SELECT nombre, direccion_residencia, (EXTRACT(YEAR FROM fecha_nacimiento)) AS año_nacimiento`
`FROM passengers`
`WHERE EXTRACT(YEAR FROM CURRENT_DATE)-EXTRACT(YEAR FROM fecha_nacimiento)>=18`
no conocia coales y llevo varios años usando postgres
`SELECT id, name, address, birth_day, `
` ``EXTRACT(YEAR FROM (AGE(CURRENT_DATE,birth_day))) AS edad,`
` ``CASE `
` `` ``WHEN AGE(CURRENT_DATE,birth_day) > INTERVAL '18 years'`
` `` ``THEN 'Mayor de edad'`
` `` ``ELSE 'Menor de edad'`
` ``END AS Condicion,`
` ``CASE`
` `` ``WHEN name ILIKE 'o%' THEN 'Nombre empieza con O'`
` `` ``ELSE 'Nombre no empieza con O' END AS Letra_Nombre`
` ``FROM public.pasajero;`
`SELECT id, nombre, direccion_residencia, fecha_nacimiento,`
`CASE`
`WHEN nombre ILIKE 'o%' THEN`
`'Comienza con o'`
`ELSE`
`'No comienza con o'`
`END AS Nombre_comienza_con_ooo,`
`CASE`
`WHEN (DATE_PART('year',current_date) - DATE_PART('year',fecha_nacimiento))>=18 THEN`
`'Mayor de edad'`
`ELSE`
`'Menos de edad'`
`END AS Edad`
`FROM pasajeros;`
7 "Sofía Torres" "1980-07-12" "Es mayor de 18 años"
3 "Ana Gómez" "1985-08-20" "Comienza con A"
5 "Laura Martínez" "1988-11-30" "Es mayor de 18 años"
2 "Juan Pérez" "1990-05-15" "Es mayor de 18 años"
4 "Carlos Rodríguez" "1992-02-10" "Es mayor de 18 años"
6 "Miguel Sánchez" "1995-04-25" "Es mayor de 18 años"
199 "Estrella Orwin" "2000-12-10" "Comienza con E"
992 "Janot Element" "2000-12-20" "Es mayor de 18 años"
846 "Adele Rutt" "2000-12-23" "Comienza con A"
284 "Tildy Walsham" "2000-12-25" "Es mayor de 18 años"
882 "Marcie Cosans" "2001-01-03" "Es mayor de 18 años"
431 "Julie Clitheroe" "2001-01-04" "Es mayor de 18 años"
315 "Corine Brettelle" "2001-01-11" "Es mayor de 18 años"
740 "Esra Klousner" "2001-01-27" "Comienza con E"
310 "Brion Knutton" "2001-02-06" "Es mayor de 18 años"
702 "Dredi Gingold" "2001-02-15" "Es mayor de 18 años"
982 "Cate Harmond" "2001-02-23" "Es mayor de 18 años"
932 "Kira Allibone" "2001-02-23" "Es mayor de 18 años"
94 "Trude McKendo" "2001-02-24" "Es mayor de 18 años"
582 "Gail Casale" "2001-02-26" "Es mayor de 18 años"
57 "Abel Pes" "2001-03-22" "Comienza con A"
911 "Simonette Bedberry" "2001-03-30" "Es mayor de 18 años"
414 "Marc Elstub" "2001-04-11" "Es mayor de 18 años"
390 "Nananne Gunnell" "2001-04-19" "Es mayor de 18 años"
496 "Thomasa Callis" "2001-05-03" "Es mayor de 18 años"
916 "Pearline Kee" "2001-05-19" "Es mayor de 18 años"
1006 "Adrianna Dolder" "2001-05-27" "Comienza con A"
498 "Betsy Yakovitch" "2001-05-27" "Es mayor de 18 años"
583 "Loraine Farlam" "2001-05-29" "Es mayor de 18 años"
446 "Yasmin Barnett" "2001-06-08" "Es mayor de 18 años"
APORTANTO:
Confirme si esta bien:
```js
SELECT id, nombre, direccion_residencia, fecha_nacimiento,
CASE
WHEN fecha_nacimiento > '2005-12-11' AND nombre LIKE 'O%' THEN
'Mayor de edad y su nombre empieza con O'
ELSE
'OTROS NO IMPORTANTES'
END
FROM public.pasajero;
```SELECT id, nombre, direccion\_residencia, fecha\_nacimiento,
CASE
WHEN fecha\_nacimiento > '2005-12-11' AND nombre LIKE 'O%' THEN
'Mayor de edad y su nombre empieza con O'
ELSE
'OTROS NO IMPORTANTES'
END
FROM public.pasajero;
![]()
Mi aporte!
```js
SELECT nombre,
CASE
WHEN fecha_nacimiento > '2010-01-01'
THEN 'Niño'
ELSE
'Mayor'
END
FROM pasajero
WHERE nombre ILIKE 'O%' AND fecha_nacimiento < '2004-01-01'
;
```
```js
SELECT nombre,
CASE
WHEN fecha_nacimiento > '2010-01-01'
THEN 'Niño'
ELSE
'Mayor'
END
FROM pasajero
WHERE nombre ILIKE 'O%' AND fecha_nacimiento < '2004-01-01'
;
```SELECT nombre,
CASE
WHEN fecha\_nacimiento > '2010-01-01'
THEN 'Niño'
ELSE
'Mayor'
END
FROM pasajero
WHERE nombre ILIKE 'O%' AND fecha\_nacimiento < '2004-01-01'
;
Mi aporte:
SELECT id, nombre_pasajero, direccion_residencia, fecha_nacimiento,
CASE
WHEN EXTRACT('YEAR'FROM AGE(CURRENT_DATE,fecha_nacimiento))>= 18
THEN
'Mayor de edad'
ELSE
'Menor de edad'
END AS mayoria_edad,
CASE
WHEN nombre_pasajero ILIKE 'M%'
THEN
'Comienza por M'
ELSE
'No comienza por M'
END AS nombre_empieza
FROM public.pasajeros;
SELECT id, nombre, residencia, fecha_nacimiento,
CASE
WHEN nombre like ‘O%’ THEN
’Si’
ELSE
’No’
END as nombre_comienza_con_o,
CASE
WHEN fecha_nacimiento < ‘2005-11-14’ THEN
’Es mayor de edad’
ELSE
’Es menor de edad’
END as edad
FROM public.pasajero;
Mi script
SELECT *,
CASE
WHEN fecha_nacimiento > '2005-01-01' AND nombre ILIKE 'p%'
THEN
'Mayor de Edad que su nombre comienza con P'
ELSE
'No aplica'
END
FROM pasajero;
Lo hice de esta manera, me funcionó, pero no sé si sea la manera más adecuada
SELECT *,
CASE
WHEN nombre ILIKE 'o%' THEN 'Si'
ELSE 'No'
END AS Empieza_con_O,
CASE
WHEN EXTRACT(years FROM age(CURRENT_DATE,fecha_nacimiento)) >= 18 THEN 'Mayor de edad'
ELSE 'Menor de edad'
END AS Mayor_Menor
FROM public.pasajeros;
Las funciones anonimas al igual que coalesce esta superpotentes para transformacion de datos
*\*RETO\*:* Con este query se buscan todos los pasajeros mayores de edad cuyo nombre empiece con 'a'
```txt
SELECT id, nombre, direccion_residencia, fecha_nacimiento,
CASE
WHEN fecha_nacimiento < current_date - interval '18 years' then 'Major'
ELSE 'Minor'
END AS "Age"
FROM pasajero
WHERE nombre ILIKE 'a%';
```
COALESCE:
- UK:*/ˌkəʊəˈlɛs/
- US:/ˌkoʊəˈlɛs/
- es más parecido a koulés
Mi código para el reto:
SELECT id, nombre_pasajero, direccion_residencia, fecha_nacimiento,
CASE
WHEN EXTRACT('YEAR'FROM AGE(CURRENT_DATE,fecha_nacimiento))>= 18
THEN
'Mayor de edad'
ELSE
'Menor de edad'
END AS mayoria_edad,
CASE
WHEN nombre_pasajero ILIKE 'M%'
THEN
'Comienza por M'
ELSE
'No comienza por M'
END AS nombre_empieza
FROM public.pasajeros;
````txt
# Mi código del reto
SELECT id, nombre_pasajero, direccion_residencia, fecha_nacimiento,
CASE
WHEN EXTRACT('YEAR'FROM AGE(CURRENT_DATE,fecha_nacimiento))>= 18
THEN
'Mayor de edad'
ELSE
'Menor de edad'
END AS mayoria_edad,
CASE
WHEN nombre_pasajero ILIKE 'M%'
THEN
'Comienza por M'
ELSE
'No comienza por M'
END AS nombre_empieza
FROM public.pasajeros;
```SELECT id, nombre\_pasajero, direccion\_residencia, fecha\_nacimiento,
CASE
WHEN EXTRACT('YEAR'FROM AGE(CURRENT\_DATE,fecha\_nacimiento))>= 18
THEN
'Mayor de edad'
ELSE
'Menor de edad'
END AS mayoria\_edad,
CASE
WHEN nombre\_pasajero ILIKE 'M%'
THEN
'Comienza por M'
ELSE
'No comienza por M'
END AS nombre\_empieza
FROM public.pasajeros;
````
SELECT Nombre, FechaNacimiento,
CASE
WHEN Nombre ILIKE 'a%'
THEN
'Vocal A'
WHEN Nombre ILIKE 'e%'
THEN
'Vocal E'
WHEN Nombre ILIKE 'i%'
THEN
'Vocal I'
WHEN Nombre ILIKE 'o%'
THEN
'Vocal O'
WHEN Nombre ILIKE 'u%'
THEN
'Vocal U'
ELSE
CONCAT('Abecedario',' ',SUBSTRING(Nombre,1,1))
END AS "Nombres Vocales",
CASE
WHEN FechaNacimiento < '2005-01-01'
THEN
'Mayor de Edad'
ELSE
'Menor de Edad'
END AS "EDAD"
FROM pasajeros;
Solución al reto
Yo decidí hacerlo simple con lo que nos ha enseñado.
<SELECT
id,
nombre,
domicilio,
fecha_nacimiento,
CASE WHEN fecha_nacimiento > '2002-08-31' THEN
'Mayor de edad'
else
'Menor de edad'
end as edad
FROM public.pasajeros
where nombre ilike 'a%'
and (CASE WHEN fecha_nacimiento < '2022-08-31' THEN
'Mayor de edad'
else
'Menor de edad'
end) like 'Mayor%'
;>
<SELECT id, nombre, direccion_residencia, fecha_nacimiento,
CASE
WHEN fecha_nacimiento < '2006-01-01' AND (nombre ILIKE 'a%' OR nombre ILIKE 'e%' OR nombre ILIKE 'i%' OR nombre ILIKE 'o%' OR nombre ILIKE 'u%') THEN
'su nombre inicia con vocal y es mayor de edad'
WHEN fecha_nacimiento >= '2006-01-01' AND (nombre ILIKE 'a%' OR nombre ILIKE 'e%' OR nombre ILIKE 'i%' OR nombre ILIKE 'o%' OR nombre ILIKE 'u%') THEN
'su nombre inicia con vocal pero es menor de edad'
WHEN fecha_nacimiento < '2006-01-01' THEN
'su nombre no inicia con vocal y es mayor de edad'
ELSE
'su nombre no inicia con vocal y es un menor de edad'
END
FROM public.pasajero;>
Para hacer el ejercicio de bloques anónimos (toda la vida les llamé condicionales) mas lógico para mi, acorde al ejemplo:
select * ,
case when fecha_nacimiento >= '2011-01-01' then 'Infante'
when fecha_nacimiento <= '1960-01-01' then 'Adulto mayor'
else 'Sin descuento' end tarifa
from pasajero
where fecha_nacimiento > '2011-01-01'
SELECT nombre, CASE
WHEN (date_part('year', current_date) - date_part('year',fecha_nacimiento)) >=18 THEN
'Mayor de Edad' ELSE 'Menor de Edad'
END AS Condicion,
CASE
WHEN nombre ILIKE 'C%' THEN 'Cumple' ELSE 'No Cumple' END AS Letra_inicial_C
FROM pasajero;
SELECT id, nombre, direccion_residencia, fecha_nacimiento,
CASE WHEN fecha_nacimiento > '2005-08-12' THEN 'Menor 18'
ELSE 'Mayor 18'
END AS edad
FROM public.pasajero;
SELECT nombre,
CASE WHEN fecha_nacimiento > '2005-08-12' THEN 'Menor 18'
ELSE 'Mayor 18'
END AS edad
FROM public.pasajero
WHERE nombre ILIKE 'o%';
Prueba de queries
Mi aporte
SELECT "ID", "Nombre", "Dirección_Residencia", "Fecha",
CASE
WHEN "Nombre" LIKE 'A%' THEN 'Inicia_con_A'
WHEN "Nombre" LIKE 'J%' THEN 'Inicia_con_J'
WHEN current_date > '2015-01-01' THEN 'Adulto'
ELSE 'Niño e inicia con vocal'
END
FROM public."pasajero";
En la nueva versión de pgAdmin 4, me funcionó este query para el último ejercicio:
SELECT
id_pasajero,
nombre_pasajero,
direccion_residencia,
fecha_nacimiento,
CASE
WHEN fecha_nacimiento > '2015-01-01' THEN 'Niño'
ELSE 'Mayor'
END AS categoria
FROM
public.pasajeros;
Por si a alguien se topa con algún error en la sintaxis cerca de WHEN.
SELECT id, nombre, direccion_residencia, fecha_nacimiento,
CASE
WHEN fecha_nacimiento > '2005-01-01' THEN
'Menor'
ELSE
'Mayor'
END,
CASE
WHEN nombre ILIKE 'p%' THEN
'nombre empieza por P'
ELSE
'no'
END
FROM public.pasajero;
Mi aporte al reto
SELECT *
FROM public.passenger
WHERE name ILIKE 'l%';
SELECT *,
CASE
WHEN name ILIKE 'l%' THEN
CASE
WHEN (current_date - birthdate) > 6570 THEN
'You are 18 years old and your name begins with L'
ELSE
'Your name starts with L and you are a boy'
END
ELSE
CASE
WHEN (current_date - birthdate) > 6570 THEN
'You are 18 years old and your name does not start with L'
ELSE
'You are a boy and your name does not start with L'
END
END as consulta
FROM public.passenger ORDER BY birthdate;
Clase 20: Funciones Especiales Avanzadas
- COALESCE: Permite comparar entre dos valores y retornar cual de los dos no es nulo.
- NULLIF: Permite comparar dos valores y retorna NULL si son iguales.
- GREATEST: Permite comparar un arreglo de valores y retorna el mayor
- LEAST: Permite comparar un arreglo de valores y retorna el menor
- BLOQUES ANÓNIMOS al igual que el desarrollo de software nos permite ingresar condicionales pero dentro de una consulta de base de datos.
–RETO
SELECT id, nombre,direccion_residencia,fecha_nacimiento ,
CASE
when (nombre ilike 'a%') then 'Comiensa con a'
when nombre ilike 'e%' then 'Comiensa con e'
when nombre ilike 'i%' then 'Comiensa con i'
when nombre ilike 'o%' then 'Comiensa con o'
when nombre ilike 'u%' then 'Comiensa con u'
else
'No - a,e,i,o,u'
end inicia_vocal ,
case
when (current_date-fecha_nacimiento) >18
then '>18' else '<18'
end edad_18
FROM pasajero
20. Funciones Especiales Avanzadas
Avanzadas
- COALESCE
- NULLIF
- GREATEST
- LEAST
- BLOQUES ANÓNIMOS
🐄
SELECT id, nombre, fecha_nacimiento,
CASE
WHEN pasajeros.nombre ILIKE ANY (ARRAY['a%', 'w%', 'm%'])
THEN 'es menor de edad y su nombre empieza con "a", "w" o "m"'
ELSE 'menor de edad'
END AS menores_de_edad
FROM transporte.pasajeros
WHERE pasajeros.fecha_nacimiento > '2005-01-01';
SELECT id nombre, fecha_nacimiento
CASE
WHEN fecha_nacimiento > ‘2015-01-01’ THEN
’Nino’
ELSE
‘Mayor’
END
FROM public.pasajero
WHERE nombre = ILIKE ‘o%’;
SELECT id, nombre, direccion_residencia, fecha_nacimiento,
CASE
WHEN nombre LIKE 'O%' THEN 'EMPIEZA POR LA LETRA O'
ELSE 'Otra letra'
END AS letra,
CASE
WHEN (current_date - fecha_nacimiento)/365 > 18 THEN 'Mayor de edad'
ELSE 'Menor de edad'
END as edad
from pasajero;
`
Les comparto mi codigo en base a los datos de mi tabla
SELECT id, nombre, direccion, fecha,
CASE
WHEN Nombre ILIKE 'o%' THEN
'Comienza con o'
ELSE
'otra letra'
END AS LETRAS,
CASE
WHEN fecha > '2022-01-01' THEN
'Es un beibi'
ELSE
'OTROS'
END AS EDAD
FROM public.pasajero;
funciones especiales avanzadas:
COALESCE: comparar dos valores y retornar cuál de los dos no es Null
NULLIF: comparar dos valores y retorna NULL si son iguales
GREATEST: Regresa el valor mayor en el caso de LEAST retorna el menor
BLOQUES ANÓNIMOS: permite ingresar condicionales dentro de una consulta de datos.
Resumen de la clase
COALESCE
La función COALESCE en PostgreSQL devuelve el primer valor no nulo de una lista de expresiones. Por ejemplo:
SELECT COALESCE(null, 2, 3)
Esta consulta devuelve 2, ya que es el primer valor no nulo de la lista.
Más información: https://www.postgresql.org/docs/current/functions-conditional.html#FUNCTIONS-COALESCE
NULLIF
La función NULLIF en PostgreSQL devuelve nulo si dos expresiones son iguales, o la primera expresión si son diferentes. Por ejemplo:
SELECT NULLIF(2, 2);
Esta consulta devuelve nulo, ya que las expresiones son iguales.
Más información: https://www.postgresql.org/docs/current/functions-conditional.html#FUNCTIONS-NULLIF
GREATEST
La función GREATEST en PostgreSQL devuelve el valor máximo de una lista de expresiones. Por ejemplo:
SELECT GREATEST(1, 2, 3);
Esta consulta devuelve 3, ya que es el valor máximo de la lista.
Más información: https://www.postgresql.org/docs/current/functions-conditional.html#FUNCTIONS-GREATEST
LEAST
La función LEAST en PostgreSQL devuelve el valor mínimo de una lista de expresiones. Por ejemplo:
SELECT LEAST(1, 2, 3);
Esta consulta devuelve 1, ya que es el valor mínimo de la lista.
Más información: https://www.postgresql.org/docs/current/functions-conditional.html#FUNCTIONS-LEAST#
Consulta
SELECT id_pasajero, nombre, direccion, fecha_nacimiento,AGE(CURRENT_DATE, fecha_nacimiento) AS edad,
CASE
WHEN fecha_nacimiento >= (CURRENT_DATE - INTERVAL '20' ) THEN 'menor de edad'
ELSE
'mayor de edad'
END AS edad
FROM public.pasajeros
WHERE nombre like 'A%'
Salida
Mientras realizaba el ejercicio final me encontré con esta función que me pareció interesante:
Se puede calcular la edad de una persona en años utilizando la función age. La función age toma dos argumentos, la fecha actual y la fecha de nacimiento de la persona, y devuelve un intervalo que representa la diferencia entre ambas fechas.
Para calcular la edad de un pasajero en años, se puede utilizar la siguiente consulta
SELECT id_pasajero, nombre, direccion, fecha_nacimiento, age(current_date, fecha_nacimiento) as edad
FROM public.pasajeros;
Easy 🤗
SELECT id, nombre, direccion, fecha_nacimiento,
CASE
--inicia bloque anónimo
WHEN nombre ILIKE 'm%' THEN '1'
ELSE '0'
END as nombre_inicia_o,
--termina bloque anónimo
CASE
--inicia bloque anónimo
WHEN EXTRACT(YEAR FROM current_date)- EXTRACT(YEAR FROM fecha_nacimiento) <= 18 THEN
'Mayor de 18 años'
ELSE
'Menor de 18 años'
END as Mayoria_de_edad
--termina bloque anónimo
FROM public.pasajeros;
Solucion al reto, yo se q esto no cuenta los viciestos pero igual se defiende bastante bien la formula con casos de personas q ya cumplieron años este año o no
SELECT *,
CASE
WHEN nombre ILIKE 'o%' THEN
'Comienza con O'
WHEN nombre ILIKE 's%' THEN
'Comienza con S'
WHEN nombre ILIKE 'm%' THEN
'Comienza con M'
ELSE
'OTRO'
END,
CASE
WHEN (CURRENT_DATE - fecha_nacimiento) / 365 >= 18 THEN
'Mayor de edad'
ELSE
'Menor de edad'
END, (CURRENT_DATE - fecha_nacimiento) / 365 AS edad
FROM pasajeros;
SELECT id, nombre, direccion_residencia, fecha_nacimiento,
CASE
WHEN EXTRACT(year FROM fecha_nacimiento) - EXTRACT(year FROM CURRENT_TIMESTAMP) > 18 THEN
'Mayor'
ELSE
'Menor'
END,
CASE
WHEN nombre ILIKE 'o%' THEN
'startss with o'
ELSE
'dont starts with o'
END
FROM public.pasajeros;```
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?