notas de estudio sql-seleccionar

Escuche la clase del profesor Xiaoyu y organice notas SQL

seleccione <lista de campos de la tabla>

de <lista de nombres de tablas>

donde <especificación de restricciones de fila>

agrupar por <especificación de agrupación>

teniendo <especificación de selección de agrupación>

ordenar por <especificación de reglas de pedido>

La sintaxis básica de ordenar por:

SELECCIONAR lista de columnas
    FROM table_name
    [WHERE condición]
    [ORDER BY column1, column2, .. columnN] [ASC | DESC];

p.ej:

El siguiente ejemplo ordena los resultados de la consulta en orden descendente de NOMBRE y SALARIO:

SELECCIONE * DE CLIENTES ORDENE POR NOMBRE, SALARIO DESC;

La sintaxis básica de agrupar por:

La cláusula SQL GROUP BY se utiliza junto con la instrucción SELECT para agrupar los mismos datos en un grupo.

En la instrucción SELECT, la cláusula GROUP BY sigue inmediatamente a la cláusula WHERE y antes de la cláusula ORDER BY.

gramática:

La sintaxis básica de la cláusula GROUP BY se muestra a continuación. La cláusula GROUP BY debe ser posterior a las condiciones de la cláusula WHERE y antes de la cláusula ORDER BY (si corresponde).

    SELECT column1, column2
    FROM table_name
    WHERE [condiciones]
    GROUP BY column1, column2
    ORDER BY column1, column2

palabra clave distinta

La palabra clave SQL DISTINCT se usa con la instrucción SELECT para eliminar todos los registros duplicados y solo devolver elementos únicos.

A veces, puede haber registros duplicados en la tabla de datos. Al recuperar estos registros, solo se debe recuperar el registro único, no el duplicado.

gramática:

La sintaxis básica para usar la palabra clave DISTINCT para eliminar registros duplicados en los resultados de la consulta es la siguiente:

    SELECT DISTINCT column1, column2, ..... columnN
    FROM table_name
    WHERE [condición]

teniendo cláusula

La razón para agregar la cláusula HAVING en SQL es que la palabra clave WHERE no se puede usar con la función agregada.

Sintaxis de SQL HAVING

SELECT nombre_columna, función_agregada (nombre_columna)
FROM nombre_tabla
DONDE nombre_columna valor del operador
GROUP BY nombre_columna
TENIENDO valor del operador función agregada (nombre_columna)

Ejemplo de SQL HAVING

Tenemos la siguiente tabla de "Pedidos":

O_Id	Fecha de orden	Precio del pedido	Cliente
1	2008/12/29	1000	Arbusto
2	2008/11/23	1600	Carretero
3	2008/10/05	700	Arbusto
4	2008/09/28	300	Arbusto
5	2008/08/06	2000	Adams
6	2008/07/21	100	Carretero

Ahora, queremos encontrar clientes cuyo importe total de pedido sea inferior a 2000.

Usamos la siguiente declaración SQL:

SELECCIONE Cliente, SUM (OrderPrice) DE Pedidos
GRUPO POR Cliente
QUE TIENE SUM (OrderPrice) <2000

El conjunto de resultados es similar:

Cliente	SUM (OrderPrice)
Carretero	1700

Ahora queremos encontrar clientes "Bush" o "Adams" que tengan un pedido total de más de 1500.

Agregamos una cláusula WHERE ordinaria a la declaración SQL:

SELECCIONE Cliente, SUM (OrderPrice) DE Órdenes
DONDE Cliente = 'Bush' O Cliente = 'Adams'
GRUPO POR Cliente
QUE TIENE SUMA (OrderPrice)> 1500

Adjunto 1: Acerca de la parte superior, la explicación en Geek Academy

Cláusulas SQL TOP, LIMIT y ROWNUM

La cláusula SQL TOP se utiliza para recuperar los primeros registros N o X% de una tabla de datos .

Nota: Todos los sistemas de bases de datos no admiten la cláusula TOP . Por ejemplo, MySQL admite la cláusula LIMIT para recuperar un número limitado de registros, mientras que Oracle usa la cláusula ROWNUM para lograr esta función.

gramática

La sintaxis básica para usar la cláusula TOP en la instrucción SELECT es la siguiente:

    SELECCIONE el número SUPERIOR | porcentaje nombre_columna (s)
    DESDE el nombre_tabla
    DONDE [condición]

Ejemplo

Considere la tabla CLIENTES con registros como se muestra a continuación:

    + ---- + ---------- + ----- + ----------- + ---------- +
    | ID | NOMBRE | EDAD | DIRECCION | SALARIO |
    + ---- + ---------- + ----- + ----------- + ---------- +
    | 1 | Ramesh | 32 | Ahmedabad | 2000,00 |
    | 2 | Khilan | 25 | Delhi 1500,00 |
    | 3 | kaushik | 23 | Kota | 2000,00 |
    | 4 | Chaitali | 25 | Mumbai | 6500,00 |
    | 5 | Hardik | 27 | Bhopal | 8500,00 |
    | 6 | Komal | 22 | MP | 4500,00 |
    | 7 | Muffy | 24 | Indore | 10000,00 |
    + ---- + ---------- + ----- + ----------- + ---------- +

El siguiente ejemplo recuperará los primeros 3 registros de la tabla CUSTOMERS:

SQL> SELECCIONAR LOS 3 PRINCIPALES * DE CLIENTES;

El resultado es el siguiente:

    + ---- + --------- + ----- + ----------- + --------- +
    | ID | NOMBRE | EDAD | DIRECCION | SALARIO |
    + ---- + --------- + ----- + ----------- + --------- +
    | 1 | Ramesh | 32 | Ahmedabad | 2000,00 |
    | 2 | Khilan | 25 | Delhi 1500,00 |
    | 3 | kaushik | 23 | Kota | 2000,00 |
    + ---- + --------- + ----- + ----------- + --------- +

Si está utilizando un servidor de base de datos MySQL, el ejemplo equivalente es el siguiente:

SQL> SELECCIONAR * DE CLIENTES
LÍMITE 3;

El resultado es el siguiente:

Si está utilizando un servidor de base de datos Oracle, el ejemplo equivalente es el siguiente:

SQL> SELECCIONAR * DE CLIENTES
DONDE ROWNUM <= 3;

El resultado es el siguiente:

Anexo 2 : El uso de like proviene de < http://wiki.jikexueyuan.com/project/sql/like-clause.html >

Cláusula SQL LIKE

La cláusula SQL LIKE utiliza comodines para comparar un valor con otros valores similares. Hay dos comodines que se pueden usar con el operador LIKE :

Signo de porcentaje (%)
Guion bajo (_)

El signo de porcentaje representa cero, uno o más caracteres. El guión bajo representa un solo número o carácter. Ambos símbolos se pueden utilizar juntos.

gramática:

La sintaxis básica de% y _ es la siguiente:

SELECCIONE DESDE table_name
DONDE la columna COMO 'XXXX%'

SELECT FROM table_name
DONDE la columna COMO '% XXXX%'

SELECT FROM table_name
DONDE la columna COMO 'XXXX_'

SELECCIONE DESDE table_name
DONDE columna COMO '_XXXX'

SELECCIONE DESDE table_name
DONDE la columna COMO '_XXXX_'

Puede conectar varias condiciones junto con AND u OR. Aquí, XXXX es cualquier valor numérico o cadena.

Ejemplo:

En los siguientes ejemplos, cada cláusula WHERE tiene una cláusula LIKE diferente, que muestra el uso de% y _:

Declaración	descripción
DONDE SALARIO COMO '200%'	Encuentra todos los valores que comienzan con 200
DONDE SALARIO COMO '% 200%'	Encuentra todos los valores que contienen 200
DONDE SALARIO COMO '_00%'	Encuentra todos los valores donde el segundo y tercer dígitos son 0
DONDE SALARIO COMO '2 _% _%'	Encuentre todos los valores que comienzan con 2 y tienen al menos 3 de longitud
DONDE SALARIO COMO '% 2'	Encuentra todos los valores que terminan en 2
DONDE SALARIO COMO '_2% 3'	Encuentra todos los valores cuyo segundo dígito sea 2 y termine en 3
DONDE SALARIO COMO '2___3'	Encuentra los cinco dígitos que comienzan con 2 y terminan con 3

Veamos un ejemplo real, considere la tabla CLIENTES con los siguientes registros:

El siguiente ejemplo muestra los registros en la tabla CLIENTES cuyo campo SALARIO comienza con 200:

SQL> SELECCIONAR * DE CLIENTES
DONDE SALARIO COMO '200%';

El resultado es el siguiente:

notas de estudio sql-seleccionar

Supongo que te gusta