Selección (WHERE)

Fuente: https://www.w3schools.com/sql/sql_where.asp

aqui mi resumen

WHERE es usado para filtrar registros.
WHERE es cuando para extraer solamente las condiciones que cumplen con esa condición.

SELECT *
FROM tabla_diaria
WHERE id=1;

SELECT *
FROM tabla_diaria
WHERE cantidad>10;

SELECT *
FROM tabla_diaria
WHERE cantidad<100;

Este puede ser combinado con AND ,OR y NOT.

AND y OR son usados para filtrar registros de más de una condición.

• AND muestra un registro si todas las condiciones separadas por AND son TRUE.
• OR muestra un registro si alguna de las condiciones separadas por OR son TRUE.

SELECT *
FROM tabla_diaria
WHERE cantidad > 10
	AND cantidad < 100;

SELECT *
FROM tabla_diaria
WHERE cantidad BETWEEN 10
	AND cantidad < 100;

BETWEEN puede ser usado para definir límites.

La separación por paréntesis es muy importante.

SELECT * 
FROM users
WHERE name = "Israel"
	AND (
	lastname = "Vázquez"
	OR
	lastname = "López"
);

SELECT * 
FROM users
WHERE name = "Israel"
	AND 
	lastname = "Vázquez"
	OR
	lastname = "López";

En el primero va a devolver todos los que son Israel Vázquez o Israel López, en el segundo devolverá a todos los que se llaman Israel Vázquez o se apellida López(sólo apellido).

NOT valida que un dato no sea TRUE.

SELECT column1, column2, ...
FROM table_name
WHERE NOT condition;

Para especificar patrones en una columna usamos LIKE. Podemos mostrar diferentes cosas que buscamos.

SELECT *
FROM users
WHERE name LIKE "Is%";

SELECT *
FROM users
WHERE name LIKE "Is_ael";

SELECT *
FROM users
WHERE name NOT LIKE "Is_ael";

• En el primero, colocamos un % para representar que se va a buscar lo que tenga is% pero que no importa los carácteres después de %.
• En el segundo le estamos diciendo con _ que puede haber lo que sea en medio de Is y ael.
• Y en el último le decimos que ponga todas las filas que no sean igual a lo que arriba estabamos buscando.

Igual podemos decir que nos traiga registros que estén vacíos o que no lo estén.

SELECT * 
FROM users
WHERE name IS NULL;

SELECT *
FROM users
WHERE name IS NOT NULL;

Y para seleccionar filas con datos específicos, usamos IN.

SELECT *
FROM users
WHERE name IN ('Israel','Laura','Luis');

En el operador LIKE Hay 2 comodines que usan comunmente:

• % - El signo de porcentaje representa 0 o mas caracteres.
• _ - El guion bajo representa un unico caracter.

Fuente: https://www.w3schools.com/sql/sql_like.asp

Yo uso diariamente el BETWEEN, LIKE y el IN. Son operadores que entregan mucho poder a tus querys y son faciles de usar! 😄

Realmente me parece que el curso se beneficiaria un montón de ir poniendo retos explícitos a lo largo de estas sesiones, porque se sienten muy teóricas.

un primo del LIKE, es es ILIKE,
con la sintaxis:

SELECT * FROM users WHERE name ILIKE "o%";

este ILIKE hace mach con todos los registros que comiencen con la letra o, ya sea mayúscula o minúscula.

Igual

SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE colegiatura = 2000;

Mayor que

SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE colegiatura > 2000;

Menor que

SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE colegiatura < 4000;

Entre

Opcion No. 1

SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE colegiatura > 2000
   AND colegiatura < 4000;

Opcion No. 2

SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE colegiatura BETWEEN 2000 AND 4000;

And y Or

Opcion No. 1

SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE nombre = 'Edin'
   AND (apellido = 'Keatch' OR apellido = 'Grishin');

Opcion No. 2

SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE nombre = 'Edin'
   AND apellido = 'Keatch' 
    OR apellido = 'Grishin';

Comodin que empieza con Al

SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE nombre LIKE 'Al%';

Comodin que termina con Al

SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE nombre LIKE '%er';

Comodin que contiene con er

SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE nombre LIKE '%er%';

Comodin que no contiene con er

SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE nombre NOT LIKE '%er%';

Comodin que varia la ultima letra

SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE nombre LIKE 'Ali_'

Null

  SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE apellido IS NULL;

Not Null

  SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE apellido IS NOT NULL;

In

 SELECT *
  FROM PRUEBAS.ALUMNOS
 WHERE nombre IN ('Wanda', 'Hilde', 'Veriee');

No es >= y <=???

Al menos a mí no me funcionó con:

"I%"

Tuve que usar comillas simples:

'I%'

Mis notas personales sobre WHERE:

Con esta simple consulta retorno los alumnos que no tienen apellido.

Wow… nunca había visto lo del comodín Is_ael en el LIKE… Gracias! Es muy útil!

Una clase muy divertida. Con lo que más me quedo es con la explicación de los parentesis que son importantes de contemplar.

7. Selección (WHERE)

• Sigma
• Selecciona ciertos rows según nuestra condición.

SELECT * 
FROM tabla_diaria
WHERE id = 1;

SELECT * 
FROM tabla_diaria
WHERE cantidad > 10;

SELECT * 
FROM tabla_diaria
WHERE cantidad < 100;

SELECT * 
FROM tabla_diaria
WHERE cantidad > 10
	AND cantidad < 100;

SELECT * 
FROM tabla_diaria
WHERE cantidad BETWEEN 10
	AND 100;

SELECT * 
FROM users
WHERE name = 'Israel'
	AND (
		 lastname = 'Vázques'
		 OR
		 lastname = 'López'
);

SELECT * 
FROM users
WHERE name = 'Israel'
		 AND lastname = 'Vázques'
		 OR lastname = 'López';

SELECT *
FROM users 
WHERE name LIKE 'Is%';

SELECT *
FROM users 
WHERE name LIKE 'Is_ael';

SELECT *
FROM users 
WHERE name NOT LIKE 'Is_ael';

SELECT *
FROM users 
WHERE name IS NULL;

SELECT *
FROM users 
WHERE name IS NOT NULL;

SELECT *
FROM users 
WHERE name IN ('Israel','Laura','Luis');

where = donde ?

La selección(Simbolo Sigma) = WHERE

Sirve para poner las condiciones para nuestra proyección en su forma más básica.

Selecciona CIERTAS TUPLAS o ROWS, sirve para la optimización de la consulta debido a este filtro.

Ejemplos:

	.....WHERE cantidad >10 AND cantidad <100;
	.....WHERE cantidad BETWEEN 10 AND 100;

... WHERE name = "Diego" AND (lastname = "TORRES" OR lastname = "VASCO")

Uso de LIKE: Es un “parecido”, no queremos una cadena especifica pero si similar con algo que pueda identificar

...WHERE name LIKE "Is%"  #nombre que empieza con Is
....WHERE name LIKE "Is_ael" #nombres que tengan cualquier letra en el _
...WHERE name NOT LIKE "Is_ael" #todas las que no sean como esta
...WHERE name IS/ IS NOT NULL; #Decir que es nulo o no
....WHERE name IN ('pedro','Israel',''  ,)

WHERE es la sentencia que nos ayuda a filtrar tuplas o registros dependiendo de las características que elegimos.

• La propiedad LIKE nos ayuda a traer registros de los cuales conocemos sólo una parte de la información.

• La propiedad BETWEEN nos sirve para arrojar registros que estén en el medio de dos. Por ejemplo los registros con id entre 20 y 30

SELECT = Cual atributo
FROM = De que tabla
WHERE = que filtro quieres aplicar a la base de datos para no traer todo

La correcta traducción de between es id >= 10 and id <= 100 ya que incluye loas valores de inicio y fin del rango dado.

En la sentencia BETWEEN esta equivocado no es igual que el anterior porque los rangos en BETWEEN incluyen el 10 y 100, en cambio con menor y mayor NO los incluye.
Para que tenga el mismo resultado tendría que ser menor igual y mayor igual

LIKE O ILIKE

En postgreSQL cuando colocamos la función LIKE nos filtra los datos con los resultados sean en minúscula o mayúscula dependiendo de como lo coloco en la función LIKE, En cambio ILIKE nos filtra la información y no depende si es en mayúscula o minúscula, nos trae todo!

Les dejo algunos de los operadores que pueden ser utilizados con WHERE

y LIKE

Proyeccion para tener el total de alumnos por el dominio que tienen sus correos

<SELECT split_part(email, '@', 2) AS domain, count(distinct(id)) as alumnos FROM platzi.alumnos
group by domain
order by alumnos desc> 

Mis apuntes:

puede servirles este link: https://www.w3schools.com/sql/sql_where.asp
saludos.

A continuación comparto mi practica de acuerdo lo visto en clase:

SELECT *
FROM platzi.alumnos
WHERE id = 1;

SELECT *
FROM platzi.carreras
WHERE fecha_alta > '2018-05-13 00:11:20';

SELECT *
FROM platzi.carreras
WHERE fecha_alta  < '2020-06-06 16:40:34';

SELECT *
FROM platzi.carreras
WHERE fecha_alta > '2018-05-13 00:11:20'
	AND  fecha_alta  < '2020-06-06 16:40:34';
	
SELECT * 
FROM platzi.carreras
WHERE fecha_alta 
BETWEEN '2018-05-13 00:11:20' AND '2020-06-06 16:40:34';

SELECT *
FROM platzi.alumnos
WHERE nombre = 'Wanda'
AND (
	apellido = 'Billington'
	OR
	apellido = 'Wakeley'
);

SELECT *
FROM platzi.alumnos
WHERE nombre = 'Wanda'
AND apellido = 'Billington'
OR apellido = 'Wakeley';

SELECT *
FROM platzi.alumnos
WHERE nombre LIKE 'Wa%';

SELECT * 
FROM platzi.alumnos
WHERE nombre LIKE '%da';

SELECT *
FROM platzi.alumnos
WHERE nombre LIKE 'Wa_da';

SELECT *
FROM platzi.alumnos
WHERE nombre NOT LIKE 'Wa_da';

SELECT *
FROM platzi.alumnos
WHERE apellido IS NULL;

SELECT * 
FROM platzi.alumnos
WHERE apellido IS NOT NULL;

SELECT *
FROM platzi.alumnos
WHERE nombre IN ('Wanda', 'Tobe', 'Ruthe', 'Cindy');

Vengo del futuro para advertir que la respuesta del quiz esta mal.

En la sentencia SELECT donde se utiliza la cláusula WHERE y los operadores lógicos AND y OR, y se agrupan los términos con un paréntesis, es importante resaltar que la posición de los paréntesis dentro de la expresión realmente influye en cómo se mostrarán los resultados porque en el ejemplo donde no se colocan los paréntesis, el interpretador de la sentencia (sistema) entiende que los dos primeros términos de la expresión están agrupados.

Ejemplo:

SELECT * FROM users WHERE name = ‘Israel’ AND lastname = ‘VAZQUEZ’ OR lastname = ‘LOPEZ’

sería igual a hacer esto:

SELECT * FROM users WHERE name = (‘Israel’ AND lastname = ‘VAZQUEZ’) OR lastname = ‘LOPEZ’

El sistema lo leería así: Muestrame todos los registros donde el nombre sea Israel y el apellido Vazquez, y si no hay ningún registros así, muestrame entonces todos los registros donde el apellido sea López, sin importar el nombre.

Con el paréntesis:

SELECT * FROM users WHERE name = ‘Israel’ AND (lastname = ‘VAZQUEZ’ OR lastname = ‘LOPEZ’)

Se leería así: Muestrame todos los registros donde el nombre sea Israel, y que el apellido sea Vazquez o López. En la proyección solo encontraríamos tuplas con nombre Israel, y algunos de los dos apellidos.

Hay que tener cuidado con las condiciones, ya que se pueden agrupar.

SELECT *
FROM users
WHERE name = "Israel"
	AND (
		lastname = "Vázquez"
		OR
		lastname = "López"
	);

SELECT *
FROM users
WHERE name = "Israel"
AND lastname = "Vázquez"
OR lastname = "López";

En el primer caso traerá todos los Israel que se apelliden Vásquez o López.

Para el segundo, traerá a todos los Israel Vásquez y todos los que se apellidan López.

SELECT * FROM platzi.alumnos
WHERE colegiatura BETWEEN 3500 AND 4000 

EJEMPLO

SELECT id, nombre, apellido, email, colegiatura 
	FROM platzi.alumnos WHERE nombre = 'Wanda' AND 
	(apellido = 'Stoffer' OR apellido = 'Billington');

te entiendo porque e llevado ya sql para preincipientes pero creo que tus videos falta la practica, bueno mas en estos de inicio
en youtube esta este Cursos SQL SERVER “https://www.youtube.com/c/deividcopteroPLUS” el canal de deividcoptero Programación esta sencillos y paso a paso , Saludos banda gracias por compratir

SELECT *
FROM alumnos
WHERE nombre NOT IN (
  'Bartolemo',
  'Silvia',
  'Carmelita'
)

where, donde lo va ubicar a que va buscar y donde.

Segunda parte de la practica.

La sentencia WHERE tiene como función la de filtrar los datos de manera lógica, si la condición se cumple entonces se proyectan los datos. Esta sentencia filtra los renglones mientras que el SELECT filtra las columnas.

Y recuerden que el placeholder funciona de varias maneras

'Is%' -> Israel, Ismael, Isaac…
'%is' -> Ludacris, Cris, Isis
'%is%' -> Cristian, Beatrisia

– SELECT *
– FROM platzi.alumnos
– WHERE colegiatura BETWEEN 4500 AND 5000;

– SELECT *
– FROM platzi.alumnos
– WHERE nombre = ‘Wanda’
– AND (apellido = ‘Billington’
– OR apellido = ‘Garnall’);

– SELECT *
– FROM platzi.alumnos
– WHERE nombre = ‘Wanda’
– AND apellido = ‘Billington’
– OR apellido = ‘Garnall’;

– SELECT *
– FROM platzi.alumnos
– WHERE nombre LIKE ‘%nda’;

SELECT *
FROM platzi.alumnos
WHERE nombre NOT IN (‘Wanda’, ‘Malynda’, ‘Lucinda’);

SELECT *
FROM tabla_diaria
WHERE id = 1; 

SELECT * 
FROM tabla_diaria
WHERE cantidad > 10;

SELECT * 
FROM tabla_diaria
WHERE cantidad < 100;

Se puede agregar and para sumar otra condición 
SELECT * 
FROM tabla_diaria
Where cantidad > 10
AND cantidad < 100;

Para filtrar rangos también podemos usar between y and 
SELECT * 
FROM tabla:diaria 
WHERE cantidad BETWEEN 10 AND 100;

También podemos filtrar por 'O' si se cumple A o B 
SELECT * 
FROM users
Where name = 'Israel'
AND (lastname = 'Vázques'
			OR 
		lastname = 'López');

Tolos los Israel Vázquez o + los que apellidan lópez
SELECT * 
FROM users
WHERE name ='Israel'
AND lastname = 'Vázquez'
OR lastname = 'López'

Para trabajar con cadenas, like empiezan con determinadas letras 
SELECT* 
FROM users
where name LIKE 'Is%';

like comodín, cualquier letra
SELECT * 
FROM users
where name like "Is_ael";

Not like filtrame todos las que no cumplan con determinado patrón 
SELECT *
FROM users
WHERE name NOT LIKE "Is_ael";

Nulos
SELECT *
FROM users
WHERE name IS NULL;

No nulos 
SELECT *
FROM users
WHERE name IS NOT NULL;

Para filtrar los valores dentro de los paréntesis de IN
SELECT *
FROM users
WHERE name IN ('Israel', 'Laura', 'Luis');

Ya avancé bastante con la clase 😄
Prueben estas consultas.

SELECT
    *
FROM
    platzi.alumnos a;

SELECT
    *
FROM
    platzi.carreras c
ORDER BY
    carrera ASC;

-- CONTAR LA CANTIDAD DE ALUMNOS
SELECT
    COUNT(*) AS "Cantidad Alumnos"
FROM
    platzi.alumnos a;

--CONTAR LA CANTIDAD TOTAL DE CARRERAS SEGÚN ID Y CANTIDAD UNICA DE CARRERAS SEGUN EL NOMBRE
SELECT
    COUNT(c.carrera) AS "Cantidad Total Carreras",
    COUNT(DISTINCT c.carrera) AS "Cantidad Unica de Carreras"
FROM
    platzi.carreras c;

--CANTIDAD TOTAL DE CARRERAS AGRUPADAS POR VIGENCIA
SELECT
    CASE WHEN vigente = FALSE THEN
        'No Vigente'
    ELSE
        'Vigente'
    END AS StatusVigente,
    COUNT(id) AS "Cantidad Carreras"
FROM
    platzi.carreras c
GROUP BY
    StatusVigente;

--LISTAR EL TOP 5 DE CARRERAS CON MAYOR CANTIDAD DE ALUMNOS INSCRITOS(EXCLUIR LAS CARRERAS QUE NO TENGAN ALUMNOS INSCRITOS)
SELECT
    c.carrera,
    COUNT(a.id) AS "Cantidad alumnos"
FROM
    platzi.alumnos a
    RIGHT JOIN platzi.carreras c ON a.carrera_id = c.id
GROUP BY
    c.carrera
ORDER BY
    "Cantidad alumnos" DESC
LIMIT 5;

--CARRERAS QUE NO TIENEN ALUMNOS INSCRITOS
SELECT
    c.carrera,
    COUNT(a.id) AS "Cantidad alumnos"
FROM
    platzi.alumnos a
    RIGHT JOIN platzi.carreras c ON a.carrera_id = c.id
GROUP BY
    c.carrera
HAVING
    COUNT(a.id) = 0
ORDER BY
    "Cantidad alumnos" ASC;

--LISTADO DE ALUMNOS QUE NO ESTAN INSCRITOS EN UNA CARRERA
SELECT
    a.nombre,
    c.carrera
FROM
    platzi.alumnos a
    LEFT JOIN platzi.carreras c ON a.carrera_id = c.id
WHERE
    a.carrera_id IS NULL
ORDER BY
    c.carrera ASC;

Uso de WHERE

Sería Genial que en este curso coloquen los playground como los hay en el curso de fundamentos de base de datos…

Espero que sean implementados en todos los cursos de programación !! 😃

Comparen en un Query la diferencia con y sin parentesis

SELECT *
FROM platzi.alumnos
WHERE nombre = 'Rhianna’
AND (apellido='Saby’
OR apellido IS NULL);

SELECT *
FROM platzi.alumnos
WHERE nombre = 'Rhianna’
AND apellido='Saby’
OR apellido IS NULL;

A mi el like solo me funciona entre comillas simples ’ ’ y no dobles " "

Aquí dejo la sentencia para filtrar la tabla sin una serie de nombres:

select * 
from platzi.alumnos as al
where nombre not in ('Bill', 'Lou','Axel');

Se puede usar varios ‘and’, pero aun no se si es la forma correcta para hacerlo, si alguien me dice, se lo agradeceria mucho!!!

select * from platzi.alumnos where id >=100;
select * from platzi.alumnos where id between 10 and 100;

Si quieren buscar sin importar mayúsculas o minúsculas pueden usar ilike. Ejemplo:

SELECT * FROM USUARIOS WHERE NOMBRE ILIKE 'Ne%';

retornará aquella que coincide con ‘Nelson’, ‘nelson’, ‘NELSON’

Dejo mi aporte , el profe Israel en los ejemplos esta utilizando comillas dobles (" ) pero en postgree sql lo que debes hacer es utilizar comillas simples ( ’ ) .

Selección WHERE

Esta operación se refiere a Where y se representa también con el símbolo ∑. Cumplir los requerimientos de nuestros queries. Seleccionar rows (renglones)

Ejercicio de la clase

.

SELECT * FROM platzi.alumnos
WHERE apellido NOT LIKE 'Freeborn';

En el Browser Brave se me detienen los videos.

Notas 😄

Selección (WHERE)

• Se representa con $\sigma$, y equivale a la sentencia WHERE.

• Algunos ejemplos:

  SELECT * FROM tabla
  WHERE id = 1; # tabla.id -> id pq ya se seleccionó
  
  SELECT * FROM tabla
  WHERE cantidad > 10;
  
  SELECT * FROM tabala
  WHERE cantidad < 100;
  

• Se pueden poner cotas superiores e inferiores usando AND:

  SELECT * FROM tabla
  WHERE cantidad > 10
  	AND cantidad < 100;
  
  # Una manera equivalente
  SELECT * FROM tabla
  WHERE cantidad BETWEEN 10
  	AND 100;
  

• También está el OR:

  SELECT * FROM users
  WHERE name = 'Israel'
  	AND (
  		lastname = 'Vázquez'
  		OR
  		lastname = 'López'
  	);
  
  # Si quitas los paréntesis, no es lo mismo!
  SELECT * FROM users
  WHERE name = 'Israel'
  	AND lastname = 'Vázquez'
  	OR lastname = 'López';
  

• En el caso particular de las cadenas de texto, podemos buscar mejor usando LIKE

  # Comienza con Is
  SELECT * FROM users
  WHERE name LIKE 'Is%';
  
  # _ es lo que sea (Israel, Ismael)
  SELECT * FROM users
  WHERE name LIKE 'Is_ael';
  
  # Se puede usar el negativo
  SELECT * FROM users
  WHERE name NOT LIKE 'Is_ael';
  

• Para manejar NULL:

  SELECT FROM users
  WHERE name IS NULL;
  

• Finalmente, puede ser IN:

  SELECT * FROM users
  WHERE name IN ('Israel', 'Laura', 'Luis')
  

Si vienen de matemáticas o ciencias y no tanto de progrmación, pueden estudiar un tema de teoría de conjuntos denominado leyes de morgan, creo que puede facilitar el aprendizaje de algunos 😄

Les dejo un ejemplo con las bases del curso.

me funcionó pero con comilla simple

![](

mi primera consulta

Hice una consulta para averiguar todos los alumnos que empiezan por v y me fije, no sé si es por la versión, el LIKE en Postgress va con comillas sencillas

<select * from platzi.alumnos where nombre LIKE  'V%' ;> 

![](

Query para categorizar los precios de la colegiatura 😃

SELECT nombre, apellido, colegiatura, carrera,
CASE 
	WHEN colegiatura > 4000 THEN 'CARO'
	WHEN colegiatura BETWEEN 3000 AND 4000 THEN 'BUEN PRECIO'
	ELSE 'Barato'
END AS Precio
FROM platzi.alumnos
INNER JOIN platzi.carreras ON carrera_id = carreras.id
ORDER BY precio DESC
;

Moraleja: Siempre utlicen parentesis 😅

Me encanta!!! Estoy practicando con las tablas que nos brindaron y entiendo mucho mejor todo, he recordado y eliminado varias dudas que pensé que sabía. Muchas gracias, estoy encantada de seguir aprendiendo!!

No tenía claro como funcionaba LIKE

un ejemplo implementando a un stock de productos

SELECT stock FROM productos WHERE stock > 0
SELECT count(nombre_prodcuto) FROM productos

Selección (WHERE)

• Se representa con la letra sigma
• Se pueden usar operadores lógicos
• Función BETWEEN
• Función LIKE y NOT LIKE con Wildcards
• Wildcards: % (cualquier cantidad de caracteres), _ (caracter comodín)
• IS NULL, IS NOT NULL
• IN ( arreglo_de_nombres, segundo_string, etc.)

5. SELECCIÓN (Where) - Se representa también con el símbolo sgma 

• SELECT *
  FROM tabla_diaria
  WHERE id = 1;
  Se seleccionan las tuplas cuyo id sea igual a 1. Esta selección aplica para ciertas instancias de un atributo
• SELECT *
  FROM tabla_diaria
  WHERE id > 1;
  Se seleccionan las tuplas cuyo id sea mayor a 10. Esta selección aplica para ciertas instancias de un atributo
• SELECT *
  FROM tabla_diaria
  WHERE id < 100;
  Se seleccionan las tuplas cuyo id sea menor a 10. Esta selección aplica para ciertas instancias de un atributo
• SELECT *
  FROM tabla_diaria
  WHERE cantidad > 10
  AND cantidad < 100;
  Se seleccionan las tuplas cuya cantidad sea mayor a 10 y además sean menores que 100. Esta selección aplica para ciertas instancias de un atributo
• SELECT *
  FROM tabla_diaria
  WHERE cantidad BETWEEN 10
  AND 100;
  Se seleccionan las tuplas cuya cantidad sea mayor a 10 y además sean menores que 100. Esta selección aplica para ciertas instancias de un atributo. Entre un rango y otro.
• SELECT *
  FROM users
  WHERE name = "Israel"
  AND (
  lastname = "Vázquez"
  OR
  lastname = “López”
  );
• SELECT *
  FROM users
  WHERE name = "Israel"
  AND lastname = "Vázquez"
  OR lastname = “López”;
• SELECT *
  FROM users
  WHERE name LIKE “Is%”; —> Después del % puede venir cualquier cosa.
• SELECT *
  FROM users
  WHERE name LIKE “Is_ael”; —> Comodín
• SELECT *
  FROM users
  WHERE name NOT LIKE “Is_ael”; —> Complemento del comodín
• ELECT *
  FROM users
  WHERE name IS NULL;
• ELECT *
  FROM users
  WHERE name IS NOT NULL;
  ELECT *
  FROM users
  WHERE name IN (‘Israel’ , ‘Laura’ , ‘Luis’
  ); --> Trae los row cuya columna nombre tenga estos nombres

Alguien me explica cuál es la diferencia entre tener valor valos vacio versus el NULL? gracias

📄 Mas informacion

En las últimas consulta queda claro el poder del paréntesis.

SELECT * FROM `deposito` WHERE NombreSucursal IN ('Norte','Centro','Sur')

Consultas de la Practica:

SELECT * FROM platzi.alumnos WHERE apellido IS NOT NULL

SELECT * FROM platzi.alumnos WHERE apellido IS NOT NULL AND (apellido LIKE 'C%' OR apellido LIKE '%st%')

SELECT * FROM platzi.alumnos WHERE apellido IS NOT NULL AND (apellido LIKE 'C%' OR apellido LIKE '%st%') AND nombre NOT IN ('Frederique','Kitty')

IN: incluye los datos de la cadenada (“a”,“b”,etc)
NOT IN: no incluye los datos de la cadena (“a”,“b”,etc)

interesante los temas de like IN NOT NULL
que aplico cuando genera query

para probar lo aprendido en clase compile estos querys y si me funciono, espero que les ayude practicando este tema