Introducción
Para trabajar con datos en una base de datos, debe poder recuperar y orientar registros específicos de manera efectiva. Mediante el uso de cláusulas de filtrado dentro de sus consultas, puede agregar criterios específicos para devolver solo los registros más relevantes.
En esta guía, veremos algunas de las operaciones de filtrado más comunes disponibles en PostgreSQL y demostraremos cómo usarlas para reducir el enfoque de sus declaraciones. Mostraremos cómo probar contra características dentro de registros individuales con WHERE cláusulas, cómo agrupar registros para resumir información con GROUP BY , cómo filtrar grupos de registros con HAVING subcláusula, y cómo establecer el número máximo de filas devueltas con el LIMIT cláusula.
Usando WHERE cláusula para definir criterios de coincidencia
Una de las formas más comunes y ampliamente útiles de indicar los requisitos de su consulta es WHERE cláusula. El WHERE La cláusula le permite definir los criterios de búsqueda reales para las declaraciones de consulta especificando las condiciones que deben cumplirse para todos los registros coincidentes.
WHERE Las cláusulas funcionan definiendo expresiones booleanas que se comparan con cada fila de datos candidata. Si el resultado de la expresión es falso, la fila se eliminará de los resultados y no se devolverá ni continuará con la siguiente etapa de procesamiento. Si el resultado de la expresión es verdadero, cumple con los criterios de la búsqueda y continuará para cualquier procesamiento adicional como una fila candidata.
La sintaxis básica de WHERE cláusula se ve así:
SELECT * FROM my_table WHERE <condition>;
El <condition> puede ser cualquier cosa que resulte en un valor booleano. En PostgreSQL, un valor booleano es cualquiera de TRUE , FALSE o NULL .
Las condiciones a menudo se forman usando uno o más de los siguientes operadores:
=:igual a>:mayor que<:menos que>=:mayor o igual que<=:menor o igual que<>o!=:no igualAND:el operador lógico "y" — une dos condiciones y devuelveTRUEsi ambas condiciones sonTRUEOR:operador lógico "o" — une dos condiciones y devuelveTRUEsi al menos una de las condiciones esTRUEIN:el valor está contenido en la lista, serie o rango que sigueBETWEEN:el valor está contenido dentro del rango de los valores mínimo y máximo que siguen, inclusiveIS NULL:coincide si el valor esNULLNOT:niega el valor booleano que sigueEXISTS:la consulta que sigue contiene resultadosLIKE:coincide con un patrón (usando los comodines%para hacer coincidir 0 o más caracteres y_para que coincida con un solo carácter)LIKE:coincide con un patrón (usando los comodines%para hacer coincidir 0 o más caracteres y_para que coincida con un solo carácter), no distingue entre mayúsculas y minúsculasSIMILAR TO:coincide con un patrón usando el dialecto de expresión regular de SQL~:coincide con un patrón utilizando expresiones regulares POSIX, distingue entre mayúsculas y minúsculas~*:coincide con un patrón utilizando expresiones regulares POSIX, sin distinción entre mayúsculas y minúsculas!~:no coincide con un patrón usando expresiones regulares POSIX, distingue entre mayúsculas y minúsculas!~*:no coincide con un patrón usando expresiones regulares POSIX, no distingue entre mayúsculas y minúsculas
Si bien la lista anterior representa algunas de las construcciones de prueba más comunes, hay muchos otros operadores que generan resultados booleanos que se pueden usar junto con WHERE cláusula.
Ejemplos usando WHERE
Una de las comprobaciones más comunes y sencillas es la igualdad, utilizando = operador. Aquí, verificamos si cada fila en el customer la tabla tiene un last_name valor igual a Smith :
SELECT * FROM customer WHERE last_name = 'Smith';
Podemos agregar condiciones adicionales a esto para crear expresiones compuestas usando operadores lógicos. Este ejemplo usa AND cláusula para agregar una prueba adicional contra el first_name columna. Las filas válidas deben cumplir las dos condiciones dadas:
SELECT * FROM customer WHERE first_name = 'John' AND last_name = 'Smith';
Del mismo modo, podemos comprobar si se cumple alguna de una serie de condiciones. Aquí, revisamos las filas de la address tabla para ver si el zip_code el valor es igual a 60626 o el neighborhood columna es igual a la cadena "Roger's Park". Usamos dos comillas simples para indicar que se debe buscar una comilla simple literal:
SELECT * FROM address WHERE zip_code = '60626' OR neighborhood = 'Roger''s Park';
El IN El operador puede funcionar como una comparación entre un número de valores, entre paréntesis. Si hay una coincidencia con alguno de los valores dados, la expresión es TRUE :
SELECT * FROM customer WHERE last_name IN ('Smith', 'Johnson', 'Fredrich');
Aquí, verificamos contra un patrón de cadena usando LIKE . El % funciona como un comodín que coincide con cero o más caracteres, por lo que "Pete", "Peter" y cualquier otra cadena que comience con "Pete" coincidirán:
SELECT * FROM customer WHERE last_name LIKE 'Pete%';
Podríamos hacer una búsqueda similar usando ~* operador para buscar coincidencias usando expresiones regulares POSIX sin importar mayúsculas y minúsculas. En este caso, comprobamos si el valor de last_name comienza con una "d" y contiene la subcadena "on", que coincidiría con nombres como "Dickson", "Donald" y "Devon":
SELECT * FROM customer WHERE last_name ~* '^D.*on.*';
Podemos verificar si un número de calle está dentro del bloque de direcciones 4000 usando BETWEEN y AND operadores para definir un rango inclusivo:
SELECT * FROM address WHERE street_number BETWEEN 4000 AND 4999;
Aquí, podemos mostrar cualquier customer entradas que tienen números de seguro social que no tienen 9 dígitos. Usamos el LENGTH() operador para obtener el número de dígitos en el campo y el <> para verificar la desigualdad:
SELECT * FROM customer WHERE LENGTH(SSN) <> 9;
Usando GROUP BY cláusula para resumir múltiples registros
El GROUP BY La cláusula es otra forma muy común de filtrar resultados al representar múltiples resultados con una sola fila. La sintaxis básica de GROUP BY cláusula se ve así:
SELECT <columns> FROM some_table GROUP BY <columns_to_group>
Cuando un GROUP BY se agrega una cláusula a una declaración, le dice a PostgreSQL que muestre una sola fila para cada valor único para la columna o columnas dadas. Esto tiene algunas implicaciones importantes.
Desde el GROUP BY La cláusula es una forma de representar varias filas como una sola fila, PostgreSQL solo puede ejecutar la consulta si puede calcular un valor para cada una de las columnas que tiene la tarea de mostrar. Esto significa que cada columna identificada por SELECT parte de la declaración tiene que ser:
- incluido en el
GROUP BYcláusula para garantizar que cada fila tenga un valor único - resumido para resumir todas las filas dentro de cada grupo
En términos prácticos, esto significa que cualquier columna en el SELECT lista no incluida en el GROUP BY La cláusula debe usar una función agregada para producir un único resultado para la columna de cada grupo.
Ejemplos usando GROUP BY
Para los ejemplos de esta sección, supongamos que tenemos una tabla llamada pet que hemos definido y rellenado así:
CREATE TABLE pet ( id SERIAL PRIMARY KEY, type TEXT, name TEXT, color TEXT, age INT);INSERT INTO pet (type, name, color, age) VALUES('dog', 'Spot', 'brown', 3),('dog', 'Rover', 'black', 7),('dog', 'Sally', 'brown', 1),('cat', 'Sabrina', 'black', 8),('cat', 'Felix', 'white', 4),('cat', 'Simon', 'orange', 8),('rabbit', 'Buttons', 'grey', 4),('rabbit', 'Bunny', 'brown', 8),('rabbit', 'Briony', 'brown', 6);
El uso más simple de GROUP BY es mostrar el rango de valores únicos para una sola columna. Para hacerlo, use la misma columna en SELECT y GROUP BY . Aquí vemos todos los colores utilizados en la tabla:
SELECT color FROM pet GROUP BY color;
color-------- black grey brown white orange(5 rows)
A medida que avanza más allá de una sola columna en el SELECT lista de columnas, debe agregar las columnas a GROUP BY cláusula o use una función agregada para producir un valor único para el grupo de filas que se representa.
Aquí, agregamos type al GROUP BY cláusula, lo que significa que cada fila representará una combinación única de type y color valores. También añadimos la age columna, resumida por avg() función para encontrar la edad promedio de cada uno de los grupos:
SELECT type, color, avg(age) AS average_age FROM pet GROUP BY type, color;
type | color | average_age--------+--------+-------------------- rabbit | brown | 7.0000000000000000 cat | black | 8.0000000000000000 rabbit | grey | 4.0000000000000000 dog | black | 7.0000000000000000 dog | brown | 2.0000000000000000 cat | orange | 8.0000000000000000 cat | white | 4.0000000000000000(7 rows)
Las funciones agregadas funcionan igual de bien con una sola columna en GROUP BY cláusula. Aquí encontramos la edad media de cada tipo de animal:
SELECT type, avg(age) AS average_age FROM PET GROUP BY type;
type | average_age--------+-------------------- rabbit | 6.0000000000000000 dog | 3.6666666666666667 cat | 6.6666666666666667(3 rows)
Si queremos mostrar el más viejo de cada tipo de animal, podríamos usar max() función en la age columna. El GROUP BY La cláusula colapsa los resultados en las mismas filas que antes, pero la nueva función altera el resultado en la otra columna:
SELECT type, max(age) AS oldest FROM pet GROUP BY type;
type | oldest--------+------- rabbit | 8 dog | 7 cat | 8(3 rows)
Usando HAVING cláusula para filtrar grupos de registros
El GROUP BY La cláusula es una forma de resumir datos mediante el colapso de varios registros en una sola fila representativa. Pero, ¿qué sucede si desea reducir estos grupos en función de factores adicionales?
El HAVING cláusula es un modificador para GROUP BY cláusula que le permite especificar las condiciones que cada grupo debe cumplir para ser incluido en los resultados.
La sintaxis general se ve así:
SELECT <columns> FROM some_table GROUP BY <columns_to_group> HAVING <condition>
El funcionamiento es muy similar al WHERE cláusula, con la diferencia de que WHERE filtra registros individuales y HAVING filtra grupos de registros.
Ejemplos usando HAVING
Usando la misma tabla que presentamos en la última sección, podemos demostrar cómo HAVING funciona la cláusula.
Aquí, agrupamos las filas de la pet tabla por valores únicos en el type columna, encontrando el valor mínimo de age así como. El HAVING Luego, la cláusula filtra los resultados para eliminar cualquier grupo donde la edad no sea mayor que 1:
SELECT type, min(age) AS youngest FROM pet GROUP BY type HAVING min(age) > 1;
type | youngest--------+---------- rabbit | 4 cat | 4(2 rows)
En este ejemplo, agrupamos las filas en pet por su color. Luego filtramos los grupos que solo representan una sola fila. El resultado nos muestra todos los colores que aparecen más de una vez:
SELECT color FROM pet GROUP BY color HAVING count(color) > 1;
color------- black brown(2 rows)
Podemos realizar una consulta similar para obtener las combinaciones de type y color que solo un animal tiene:
SELECT type, color FROM pet GROUP BY type, color HAVING count(color) = 1;
type | color--------+-------- cat | black rabbit | grey dog | black cat | orange cat | white(5 rows)
Usando el LIMIT cláusula para establecer el número máximo de registros
El LIMIT La cláusula ofrece un enfoque diferente para reducir los registros que devuelve su consulta. En lugar de eliminar filas de datos según los criterios dentro de la fila misma, el LIMIT La cláusula establece el número máximo de registros devueltos por una consulta.
La sintaxis básica de LIMIT se parece a esto:
SELECT * FROM my_table LIMIT <num_rows> [OFFSET <num_rows_to_skip>];
Aquí, el <num_rows> indica el número máximo de filas a mostrar de la consulta ejecutada. Esto se usa a menudo junto con ORDER BY cláusulas para obtener las filas con los valores más extremos en una determinada columna. Por ejemplo, para obtener las cinco mejores puntuaciones en un examen, un usuario podría ORDER BY una score columna y luego LIMIT los resultados a 5.
Mientras que LIMIT cuenta desde la parte superior de los resultados de forma predeterminada, el OFFSET opcional La palabra clave se puede usar para compensar la posición inicial que usa. En efecto, esto le permite paginar los resultados mostrando el número de resultados definido por LIMIT y luego agregar el LIMIT número al OFFSET para recuperar la página siguiente.
Ejemplos usando LIMIT
Usaremos la pet tabla anterior para ver los ejemplos de esta sección.
Como se mencionó anteriormente, LIMIT a menudo se combina con un ORDER BY cláusula para definir explícitamente el orden de las filas antes de dividir el número apropiado. Aquí, ordenamos la pet entradas según su age , de mayor a menor. Luego usamos LIMIT para mostrar los 5 animales más antiguos:
SELECT * FROM pet ORDER BY age DESC LIMIT 5;
type | name | color | age | id--------+---------+--------+-----+---- cat | Simon | orange | 8 | 6 cat | Sabrina | black | 8 | 4 rabbit | Bunny | brown | 8 | 8 dog | Rover | black | 7 | 2 rabbit | Briany | brown | 6 | 9(5 rows)
Sin un ORDER BY cláusula, LIMIT hará selecciones de una manera completamente predecible. Los resultados devueltos pueden verse afectados por el orden de las entradas dentro de la tabla o por índices. Esto no siempre es algo malo.
Si necesitamos un registro para cualquier dog dentro de la tabla, podríamos construir una consulta como esta. Tenga en cuenta que, si bien el resultado puede ser difícil de predecir, esta no es una selección aleatoria y no debe usarse como tal:
SELECT * FROM pet WHERE type = 'dog' LIMIT 1;
type | name | color | age | id------+------+-------+-----+---- dog | Spot | brown | 3 | 1(1 row)
Podemos usar el OFFSET Cláusula para paginar a través de los resultados. Incluimos un ORDER BY cláusula para definir un orden específico para los resultados.
Para la primera consulta, limitamos los resultados sin especificar un OFFSET para obtener las primeras 3 entradas más jóvenes:
SELECT * FROM pet ORDER BY age LIMIT 3;
type | name | color | age | id------+-------+-------+-----+---- dog | Sally | brown | 1 | 3 dog | Spot | brown | 3 | 1 cat | Felix | white | 4 | 5(3 rows)
Para obtener los próximos 3 más jóvenes, podemos agregar el número definido en LIMIT al OFFSET para omitir los resultados que ya hemos recuperado:
SELECT * FROM pet ORDER BY age LIMIT 3 OFFSET 3;
type | name | color | age | id --------+---------+-------+-----+---- rabbit | Buttons | grey | 4 | 7 rabbit | Briany | brown | 6 | 9 dog | Rover | black | 7 | 2(3 rows)
Si añadimos el LIMIT al OFFSET de nuevo, obtendremos los siguientes 3 resultados:
SELECT * FROM pet ORDER BY age LIMIT 3 OFFSET 6;
type | name | color | age | id--------+---------+--------+-----+---- cat | Simon | orange | 8 | 6 rabbit | Bunny | brown | 8 | 8 cat | Sabrina | black | 8 | 4(3 rows)
Esto nos permite recuperar filas de datos de una consulta en fragmentos manejables.
Conclusión
Hay muchas formas de filtrar y restringir los resultados que obtiene de las consultas. Cláusulas como WHERE y HAVING evaluar posibles filas o grupos de filas para ver si cumplen ciertos criterios. El GROUP BY La cláusula le ayuda a resumir datos agrupando registros que tienen uno o más valores de columna en común. El LIMIT La cláusula ofrece a los usuarios la capacidad de establecer un máximo estricto en la cantidad de registros para recuperar.
Aprender cómo se pueden aplicar estas cláusulas, individualmente o en combinación, le permitirá extraer datos específicos de grandes conjuntos de datos. Los filtros y modificadores de consultas son esenciales para convertir los datos que residen en PostgreSQL en respuestas útiles.
