SQL Ultimo

SQL es seguido por un conjunto único de reglas y pautas llamado Sintaxis.
Este tutorial le
brinda un inicio rápido con SQL al enumerar toda la sintaxis básica de SQL.
Todas las sentencias SQL comienzan con cualquiera de las palabras clave como SELECT,
INSERT, UPDATE, DELETE, ALTER, DROP, CREATE, USE, SHOW y todas las sentencias
terminan con un punto y coma (;).
El punto más importante que debe tenerse en cuenta aquí es que SQL no distingue entre
mayúsculas y minúsculas, lo que significa que SELECT y select tienen el mismo significado
en las sentencias SQL. Mientras que MySQL marca la diferencia en los nombres de las
tablas.Por lo tanto, si está trabajando con MySQL, debe proporcionar los nombres de las
tablas tal como existen en la base de datos.
Varias sintaxis en SQL

Todos los ejemplos dados en este tutorial han sido probados con un servidor MySQL.
Instrucción SQL SELECT

SELECT column1, column2....columnN
FROM table_name;
Cláusula SQL DISTINCT

SELECT DISTINCT column1, column2....columnN
FROM table_name;
Cláusula WHERE de SQL

FROM table_name
WHERE CONDITION;
Cláusula Y / O de SQL
FROM table_name
WHERE CONDITION-1 {AND|OR} CONDITION-2;
Cláusula SQL IN
FROM table_name
WHERE column_name IN (val-1, val-2,...val-N);
Cláusula SQL BETWEEN

FROM table_name
WHERE column_name BETWEEN val-1 AND val-2;
Cláusula LIKE de SQL

FROM table_name
WHERE column_name LIKE { PATTERN };
Cláusula ORDER BY de SQL

FROM table_name
WHERE CONDITION
ORDER BY column_name {ASC|DESC};
Cláusula SQL GROUP BY

SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name;
Cláusula SQL COUNT

SELECT COUNT(column_name)
FROM table_name
WHERE CONDITION;
Cláusula HAVING de SQL

SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name
HAVING (arithematic function condition);
Sentencia SQL CREATE TABLE

CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);
Sentencia SQL DROP TABLE

DROP TABLE table_name;
Sentencia SQL CREATE INDEX

CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);
Sentencia SQL DROP INDEX

ALTER TABLE table_name
DROP INDEX index_name;
Declaración DESC de SQL

DESC table_name;
Sentencia SQL TRUNCATE TABLE

TRUNCATE TABLE table_name;
Sentencia SQL ALTER TABLE

ALTER TABLE table_name {ADD|DROP|MODIFY} column_name {data_ype};
Sentencia SQL ALTER TABLE (Cambiar nombre)

ALTER TABLE table_name RENAME TO new_table_name;
Instrucción SQL INSERT INTO

INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);
Sentencia SQL UPDATE

UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE CONDITION ];
Sentencia SQL DELETE

DELETE FROM table_name
WHERE {CONDITION};
Sentencia SQL CREATE DATABASE

CREATE DATABASE database_name;
Sentencia SQL DROP DATABASE

DROP DATABASE database_name;
Sentencia USE SQL

USE database_name;
Sentencia COMMIT de SQL

COMMIT;
Sentencia SQL ROLLBACK

ROLLBACK;
¿Qué es un operador en SQL?

Un operador es una palabra reservada o un carácter que se utiliza principalmente en la
cláusula WHERE de una declaración SQL para realizar operaciones, como comparaciones y
operaciones aritméticas. Estos operadores se utilizan para especificar condiciones en una
declaración SQL y para servir como conjunciones para múltiples condiciones en una
declaración.
 Operadores aritméticos
 Operadores de comparación
 Operadores logicos
 Operadores utilizados para negar condiciones
Operadores aritméticos SQL

Suponga que la 'variable a' tiene 10 y la 'variable b' tiene 20, entonces -
Mostrar ejemplos
Operador Descripción Ejemplo
Agrega valores a ambos lados del operador. a+b

+ (Adición)
dará 30
- (Resta) Resta el operando de la mano derecha del operando de la a-b

mano izquierda. dará -10
Multiplica los valores a ambos lados del operador. a*b

*
dará
(Multiplicación)
200
Divide el operando de la izquierda por el operando de la b/a

/ (División)
derecha. dará 2
Divide el operando de la izquierda por el operando de la b% a

% (Módulo)
derecha y devuelve el resto. dará 0
Operadores de comparación SQL

Suponga que la 'variable a' tiene 10 y la 'variable b' tiene 20, entonces -
Mostrar ejemplos
Operado Descripción Ejemplo

r
Comprueba si los valores de dos operandos son iguales o no, si es (a = b)

= así, la condición se convierte en verdadera. no es
cierto.
Comprueba si los valores de dos operandos son iguales o no, si los (a! = b)
!= valores no son iguales, la condición se convierte en verdadera. es
cierto.
Comprueba si los valores de dos operandos son iguales o no, si los (a <> b)
<> valores no son iguales, la condición se convierte en verdadera. es
cierto.
Comprueba si el valor del operando izquierdo es mayor que el (a> b)

> valor del operando derecho, si es así, la condición se convierte en no es
verdadera. cierto.
Comprueba si el valor del operando izquierdo es menor que el (a <b)

< valor del operando derecho, si es así, la condición se convierte en es
verdadera. cierto.
>= Comprueba si el valor del operando izquierdo es mayor o igual que (a> = b)
el valor del operando derecho, si es así, la condición se convierte no es
en verdadera. cierto.
Comprueba si el valor del operando izquierdo es menor o igual que (a <= b)

<= el valor del operando derecho, si es así, la condición se convierte es
en verdadera. cierto.
Comprueba si el valor del operando izquierdo no es menor que el

(a! <b)
!< valor del operando derecho, si es así, la condición se convierte en
es falso.
verdadera.
Comprueba si el valor del operando izquierdo no es mayor que el (a!> b)

!> valor del operando derecho, si es así, la condición se convierte en es
verdadera. cierto.
Operadores lógicos SQL

Aquí hay una lista de todos los operadores lógicos disponibles en SQL.
Mostrar ejemplos
No Operador y descripción
Señor.
TODOS
1
El operador ALL se utiliza para comparar un valor con todos los valores de otro
conjunto de valores.
Y
2 El operador AND permite la existencia de múltiples condiciones en la cláusula
WHERE de una instrucción SQL.
NINGUNA
3 El operador ANY se utiliza para comparar un valor con cualquier valor
aplicable en la lista según la condición.
ENTRE
4 El operador BETWEEN se utiliza para buscar valores que están dentro de un
conjunto de valores, dado el valor mínimo y el valor máximo.
5 EXISTE
El operador EXISTS se utiliza para buscar la presencia de una fila en una tabla
especificada que cumpla con un cierto criterio.
EN
6 El operador IN se utiliza para comparar un valor con una lista de valores
literales que se han especificado.
COMO
7 El operador LIKE se usa para comparar un valor con valores similares usando
operadores comodín.
NO
8 El operador NOT invierte el significado del operador lógico con el que se

utiliza.Por ejemplo: NO EXISTE, NO ENTRE, NO EN, etc. Este es un
operador de negación.
O
9 El operador OR se utiliza para combinar varias condiciones en la cláusula
WHERE de una instrucción SQL.
ES NULO
10
El operador NULL se utiliza para comparar un valor con un valor NULL.
ÚNICO
11 El operador UNIQUE busca cada fila de una tabla especificada en busca de
unicidad (sin duplicados).
Una expresión es una combinación de uno o más valores, operadores y funciones SQL que
evalúan a un valor. Estas EXPRESIONES SQL son como fórmulas y están escritas en
lenguaje de consulta. También puede usarlos para consultar la base de datos para un
conjunto específico de datos.
Sintaxis
Considere la sintaxis básica de la instrucción SELECT de la siguiente manera:

SELECT column1, column2, columnN
FROM table_name
WHERE [CONDITION|EXPRESSION];
Hay diferentes tipos de expresiones SQL, que se mencionan a continuación:
 Booleano
 Numérico
 Fecha
Analicemos ahora cada uno de estos en detalle.
Expresiones booleanas
Las expresiones booleanas SQL obtienen los datos basándose en la coincidencia de un solo
valor. A continuación se muestra la sintaxis:
FROM table_name
WHERE SINGLE VALUE MATCHING EXPRESSION;
Considere la tabla CLIENTES que tiene los siguientes registros:

SQL> SELECT * FROM CUSTOMERS;
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+
7 rows in set (0.00 sec)
La siguiente tabla es un ejemplo simple que muestra el uso de varias expresiones booleanas
SQL:
SQL> SELECT * FROM CUSTOMERS WHERE SALARY = 10000;
+----+-------+-----+---------+----------+
+----+-------+-----+---------+----------+
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+-------+-----+---------+----------+
1 row in set (0.00 sec)
Expresión numérica
Estas expresiones se utilizan para realizar cualquier operación matemática en cualquier
consulta. A continuación se muestra la sintaxis:
SELECT numerical_expression as OPERATION_NAME
[FROM table_name
WHERE CONDITION] ;
Aquí, la numerical_expression se usa para una expresión matemática o cualquier fórmula. A
continuación se muestra un ejemplo simple que muestra el uso de expresiones numéricas
SQL:
SQL> SELECT (15 + 6) AS ADDITION

+----------+
| ADDITION |
+----------+
| 21 |
+----------+
Hay varias funciones integradas como avg (), sum (), count (), etc., para realizar lo que se
conoce como cálculos de datos agregados contra una tabla o una columna de tabla
específica.
SQL> SELECT COUNT(*) AS "RECORDS" FROM CUSTOMERS;
+---------+
| RECORDS |
+---------+
| 7 |
+---------+
Expresiones de fecha
Las expresiones de fecha devuelven los valores actuales de fecha y hora del sistema -
SQL> SELECT CURRENT_TIMESTAMP;
+---------------------+
| Current_Timestamp |
+---------------------+
| 2009-11-12 06:40:23 |
+---------------------+
Otra expresión de fecha es la que se muestra a continuación:

SQL> SELECT GETDATE();;
+-------------------------+
| GETDATE |
+-------------------------+
| 2009-10-22 12:07:18.140 |
+-------------------------+
La instrucción SQL SELECT se utiliza para obtener los datos de una tabla de base de datos
que devuelve estos datos en forma de tabla de resultados. Estas tablas de resultados se
denominan conjuntos de resultados.
Sintaxis
La sintaxis básica de la instrucción SELECT es la siguiente:
SELECT column1, column2, columnN FROM table_name;
Aquí, column1, column2 ... son los campos de una tabla cuyos valores desea obtener. Si
desea obtener todos los campos disponibles en el campo, puede utilizar la siguiente sintaxis.
SELECT * FROM table_name;
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 código es un ejemplo, que buscaría los campos ID, Nombre y Salario de los
clientes disponibles en la tabla CLIENTES.
SQL> SELECT ID, NAME, SALARY FROM CUSTOMERS;
Esto produciría el siguiente resultado:

+----+----------+----------+
| ID | NAME | SALARY |
+----+----------+----------+
| 1 | Ramesh | 2000.00 |
| 2 | Khilan | 1500.00 |
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+
Si desea obtener todos los campos de la tabla CLIENTES, debe utilizar la siguiente consulta.
SQL> SELECT * FROM CUSTOMERS;
Esto produciría el resultado que se muestra a continuación.

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+
La cláusula WHERE de SQL se utiliza para especificar una condición al obtener los datos de
una sola tabla o al unirse con varias tablas. Si se cumple la condición dada, solo devuelve un
valor específico de la tabla. Debe utilizar la cláusula WHERE para filtrar los registros y
obtener solo los registros necesarios.
La cláusula WHERE no solo se usa en la instrucción SELECT, sino que también se usa en la
instrucción UPDATE, DELETE, etc., que examinaremos en los capítulos siguientes.
Sintaxis
La sintaxis básica de la instrucción SELECT con la cláusula WHERE es la que se muestra a
continuación.
FROM table_name
WHERE [condition]
Puede especificar una condición usando la comparación u operadores lógicos como>, <,

=,LIKE, NOT , etc. Los siguientes ejemplos aclararían este concepto.
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 código es un ejemplo que obtendría los campos ID, Nombre y Salario de la tabla
CLIENTES, donde el salario es mayor que 2000 -
SQL> SELECT ID, NAME, SALARY
FROM CUSTOMERS
WHERE SALARY > 2000;

+----+----------+----------+
+----+----------+----------+
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+
La siguiente consulta es un ejemplo, que buscaría los campos ID, Nombre y Salario de la
tabla CLIENTES para un cliente con el nombre Hardik .
Aquí, es importante tener en cuenta que todas las cadenas deben estar entre comillas simples
(''). Considerando que, los valores numéricos deben darse sin comillas como en el ejemplo
anterior.
FROM CUSTOMERS
WHERE NAME = 'Hardik';

+----+----------+----------+
+----+----------+----------+
| 5 | Hardik | 8500.00 |
+----+----------+----------+
Los operadores SQL AND & OR se utilizan para combinar varias condiciones para restringir

los datos en una declaración SQL. Estos dos operadores se denominan operadores
conjuntivos.
Estos operadores proporcionan un medio para realizar múltiples comparaciones con

diferentes operadores en la misma declaración SQL.
El operador AND
El operador AND permite la existencia de múltiples condiciones en la cláusula WHERE de
una instrucción SQL.
Sintaxis
La sintaxis básica del operador AND con una cláusula WHERE es la siguiente:
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];
Puede combinar N número de condiciones utilizando el operador AND. Para que la
instrucción SQL realice una acción, ya sea una transacción o una consulta, todas las
condiciones separadas por AND deben ser VERDADERAS.
Ejemplo

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+
A continuación se muestra un ejemplo, que obtendría los campos ID, Nombre y Salario de la
tabla CLIENTES, donde el salario es superior a 2000 y la edad es inferior a 25 años:
FROM CUSTOMERS
WHERE SALARY > 2000 AND age < 25;

+----+-------+----------+
+----+-------+----------+
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+-------+----------+
El operador de quirófano
El operador OR se utiliza para combinar varias condiciones en la cláusula WHERE de una
instrucción SQL.
Sintaxis
La sintaxis básica del operador OR con una cláusula WHERE es la siguiente:

FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]
Puede combinar N número de condiciones utilizando el operador OR. Para que la instrucción

SQL realice una acción, ya sea una transacción o una consulta, la única UNA de las
condiciones separadas por OR debe ser VERDADERA.
Ejemplo

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 bloque de código tiene una consulta, que buscaría los campos ID, Nombre y
Salario de la tabla CLIENTES, donde el salario es mayor a 2000 O la edad es menor a 25
años.
FROM CUSTOMERS
WHERE SALARY > 2000 OR age < 25;

+----+----------+----------+
+----+----------+----------+
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+
CLAUSULA LIKE:
La cláusula SQL LIKE se utiliza para comparar un valor con valores similares utilizando

operadores comodín. Hay dos comodines que se utilizan junto con el operador LIKE.
 El signo de porcentaje (%)

 El subrayado (_)
El signo de porcentaje representa cero, uno o varios caracteres. El guión bajo representa un
solo número o carácter. Estos símbolos se pueden utilizar en combinaciones.
Sintaxis
La sintaxis básica de% y _ es la siguiente:
SELECT FROM table_name
WHERE column LIKE 'XXXX%'
or

WHERE column LIKE '%XXXX%'
or

WHERE column LIKE 'XXXX_'
or

WHERE column LIKE '_XXXX'
or

WHERE column LIKE '_XXXX_'
Puede combinar N número de condiciones utilizando operadores AND u OR. Aquí, XXXX

podría ser cualquier valor numérico o de cadena.
Ejemplo
La siguiente tabla tiene algunos ejemplos que muestran que la parte WHERE tiene una
cláusula LIKE diferente con operadores '%' y '_' -
No Declaración y descripción
Señor.
1 DONDE SALARIO COMO '200%'

Encuentra cualquier valor que comience con 200.
DONDE EL SALARIO COMO '% 200%'

2
Encuentra cualquier valor que tenga 200 en cualquier posición.
DONDE SALARIO COMO '_00%'

3
Encuentra cualquier valor que tenga 00 en la segunda y tercera posiciones.
DONDE SALARIO COMO '2 _% _%'

4 Busca cualquier valor que comience con 2 y tenga al menos 3 caracteres de
longitud.
DONDE SALARIO COMO '% 2'

5
Encuentra cualquier valor que termine en 2.
6 DONDE SALARIO COMO '_2% 3'

Encuentra cualquier valor que tenga un 2 en la segunda posición y termine
con un 3.
DONDE SALARIO COMO '2___3'

7 Encuentra cualquier valor en un número de cinco dígitos que comience con 2
y termine con 3.
Tomemos un ejemplo real, considere la tabla CLIENTES que tiene los registros que se
muestran a continuación.
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+
A continuación se muestra un ejemplo, que mostraría todos los registros de la tabla

CLIENTES, donde el SALARIO comienza con 200.
SQL> SELECT * FROM CUSTOMERS
WHERE SALARY LIKE '200%';

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+----------+-----+-----------+----------+
CLAUSULA SUPERIOR:
La cláusula SQL TOP se utiliza para obtener un número TOP N o registros de X por ciento de

una tabla.
Nota : todas las bases de datos no admiten la cláusula TOP. Por ejemplo, MySQL admite
lacláusula LIMIT para obtener un número limitado de registros, mientras que Oracle usa
elcomando ROWNUM para obtener un número limitado de registros.
Sintaxis
La sintaxis básica de la cláusula TOP con una instrucción SELECT sería la siguiente.
SELECT TOP number|percent column_name(s)
FROM table_name
WHERE [condition]
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+
La siguiente consulta es un ejemplo en el servidor SQL, que buscaría los 3 registros

principales de la tabla CUSTOMERS.
SQL> SELECT TOP 3 * FROM CUSTOMERS;

+----+---------+-----+-----------+---------+
+----+---------+-----+-----------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+---------+-----+-----------+---------+
Si está utilizando un servidor MySQL, aquí hay un ejemplo equivalente:

LIMIT 3;

+----+---------+-----+-----------+---------+
+----+---------+-----+-----------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+---------+-----+-----------+---------+
Si está utilizando un servidor Oracle, el siguiente bloque de código tiene un ejemplo

equivalente.
WHERE ROWNUM <= 3;

+----+---------+-----+-----------+---------+
+----+---------+-----+-----------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
+----+---------+-----+-----------+---------+
ORDENAR POR:
La cláusula SQL ORDER BY se utiliza para ordenar los datos en orden ascendente o

descendente, según una o más columnas. Algunas bases de datos clasifican los resultados
de la consulta en orden ascendente de forma predeterminada.
Sintaxis
La sintaxis básica de la cláusula ORDER BY es la siguiente:
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];
Puede utilizar más de una columna en la cláusula ORDER BY. Asegúrese de que cualquier
columna que esté usando para ordenar esa columna debe estar en la lista de columnas.
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 bloque de código tiene un ejemplo, que clasificaría el resultado en orden

ascendente por NOMBRE y SALARIO -
ORDER BY NAME, SALARY;

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

descendente por NOMBRE.
ORDER BY NAME DESC;

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 7 | Muffy | 24 | Indore | 10000.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
+----+----------+-----+-----------+----------+
AGRUPAR POR:
La cláusula SQL GROUP BY se utiliza en colaboración con la instrucción SELECT para

organizar datos idénticos en grupos. Esta cláusula GROUP BY sigue a la cláusula WHERE
en una instrucción SELECT y precede a la cláusula ORDER BY.
Sintaxis
La sintaxis básica de una cláusula GROUP BY se muestra en el siguiente bloque de
código.La cláusula GROUP BY debe seguir las condiciones de la cláusula WHERE y debe
preceder a la cláusula ORDER BY si se utiliza una.
SELECT column1, column2
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2
ORDER BY column1, column2
Ejemplo
Considere que la tabla CLIENTES tiene los siguientes registros:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+
Si desea conocer el monto total del salario de cada cliente, entonces la consulta GROUP BY
sería la siguiente.
SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
GROUP BY NAME;

+----------+-------------+
| NAME | SUM(SALARY) |
+----------+-------------+
| Chaitali | 6500.00 |
| Hardik | 8500.00 |
| kaushik | 2000.00 |
| Khilan | 1500.00 |
| Komal | 4500.00 |
| Muffy | 10000.00 |
| Ramesh | 2000.00 |
+----------+-------------+
Ahora, veamos una tabla donde la tabla CUSTOMERS tiene los siguientes registros con
nombres duplicados:
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Ramesh | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | kaushik | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Ahora, nuevamente, si desea saber el monto total del salario de cada cliente, entonces la
consulta GROUP BY sería la siguiente:
SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS
GROUP BY NAME;

+---------+-------------+
| NAME | SUM(SALARY) |
+---------+-------------+
| Hardik | 8500.00 |
| kaushik | 8500.00 |
| Komal | 4500.00 |
| Muffy | 10000.00 |
| Ramesh | 3500.00 |
+---------+-------------+
PALABRA CLAVE DISTINTA:
La palabra clave SQL DISTINCT se usa junto con la instrucción SELECT para eliminar todos
los registros duplicados y obtener solo registros únicos.
Puede haber una situación en la que tenga varios registros duplicados en una tabla. Al
buscar dichos registros, tiene más sentido buscar solo esos registros únicos en lugar de
buscar registros duplicados.
Sintaxis
La sintaxis básica de la palabra clave DISTINCT para eliminar los registros duplicados es la
siguiente:
SELECT DISTINCT column1, column2,.....columnN
FROM table_name
WHERE [condition]
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+
Primero, veamos cómo la siguiente consulta SELECT devuelve los registros de salario
duplicados.
SQL> SELECT SALARY FROM CUSTOMERS
ORDER BY SALARY;
Esto produciría el siguiente resultado, donde el salario (2000) se duplica, lo que es un

registro duplicado de la tabla original.
+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+
Ahora, usemos la palabra clave DISTINCT con la consulta SELECT anterior y luego veamos
el resultado.
SQL> SELECT DISTINCT SALARY FROM CUSTOMERS
ORDER BY SALARY;
Esto produciría el siguiente resultado donde no tenemos ninguna entrada duplicada.

+----------+
| SALARY |
+----------+
| 1500.00 |
| 2000.00 |
| 4500.00 |
| 6500.00 |
| 8500.00 |
| 10000.00 |
+----------+
La cláusula SQL ORDER BY se utiliza para ordenar los datos en orden ascendente o

descendente, según una o más columnas. Algunas bases de datos clasifican los resultados
de la consulta en orden ascendente de forma predeterminada.
Sintaxis
La sintaxis básica de la cláusula ORDER BY que se usaría para ordenar el resultado en
orden ascendente o descendente es la siguiente:
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];
Puede utilizar más de una columna en la cláusula ORDER BY. Asegúrese de que cualquier
columna que esté usando para ordenar, esa columna debe estar en la lista de columnas.
Ejemplo
+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+
A continuación se muestra un ejemplo, que clasificaría el resultado en orden ascendente por
NOMBRE y SALARIO.
ORDER BY NAME, SALARY;

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

descendente por NOMBRE.
ORDER BY NAME DESC;

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 7 | Muffy | 24 | Indore | 10000.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
+----+----------+-----+-----------+----------+
Para obtener las filas con su propio orden preferido, la consulta SELECT utilizada sería la
siguiente:
ORDER BY (CASE ADDRESS
WHEN 'DELHI' THEN 1
WHEN 'BHOPAL' THEN 2
WHEN 'KOTA' THEN 3
WHEN 'AHMEDABAD' THEN 4
WHEN 'MP' THEN 5
ELSE 100 END) ASC, ADDRESS DESC;

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+
Esto ordenará a los clientes por DIRECCIÓN en su propio orden de preferencia primero y en

un orden natural para las direcciones restantes. Además, las direcciones restantes se
ordenarán en orden alfabético inverso.
SQL AVANZADA:
RESTRICCIONES:
Las restricciones son las reglas que se aplican a las columnas de datos de una tabla. Se
utilizan para limitar el tipo de datos que pueden incluirse en una tabla. Esto asegura la
precisión y confiabilidad de los datos en la base de datos.
Las restricciones pueden estar a nivel de columna o de tabla. Las restricciones de nivel de

columna se aplican solo a una columna, mientras que las restricciones de nivel de tabla se
aplican a toda la tabla.
A continuación se muestran algunas de las restricciones más utilizadas disponibles en

SQL.Estas restricciones ya se han discutido en el capítulo Conceptos de SQL - RDBMS ,
pero vale la pena revisarlas en este punto.
 Restricción NOT NULL : garantiza que una columna no pueda tener un valor NULL.
 Restricción DEFAULT : proporciona un valor predeterminado para una columna
cuando no se especifica ninguno.
 Restricción ÚNICA : garantiza que todos los valores de una columna sean diferentes.
 Clave PRIMARIA : identifica de forma única cada fila / registro en una tabla de base de
datos.
 Clave EXTRANJERA : identifica de forma única una fila / registro en cualquiera de las
tablas de la base de datos dada.
 Restricción CHECK: la restricción CHECK garantiza que todos los valores de una
columna satisfagan determinadas condiciones.
 ÍNDICE : se utiliza para crear y recuperar datos de la base de datos muy rápidamente.
Las restricciones se pueden especificar cuando se crea una tabla con la instrucción CREATE
TABLE o puede usar la instrucción ALTER TABLE para crear restricciones incluso después
de que se crea la tabla.
Eliminación de restricciones
Cualquier restricción que haya definido puede eliminarse utilizando el comando ALTER
TABLE con la opción DROP CONSTRAINT.
Por ejemplo, para eliminar la restricción de clave principal en la tabla EMPLOYEES, puede
usar el siguiente comando.
ALTER TABLE EMPLOYEES DROP CONSTRAINT EMPLOYEES_PK;
Algunas implementaciones pueden proporcionar atajos para eliminar ciertas

restricciones. Por ejemplo, para eliminar la restricción de clave principal para una tabla en
Oracle, puede usar el siguiente comando.
ALTER TABLE EMPLOYEES DROP PRIMARY KEY;
Algunas implementaciones le permiten deshabilitar restricciones. En lugar de eliminar

permanentemente una restricción de la base de datos, es posible que desee deshabilitar
temporalmente la restricción y luego habilitarla más tarde.
Restricciones de integridad
Las restricciones de integridad se utilizan para garantizar la precisión y coherencia de los
datos en una base de datos relacional. La integridad de los datos se maneja en una base de
datos relacional a través del concepto de integridad referencial.
Hay muchos tipos de restricciones de integridad que juegan un papel en la integridad

referencial (RI) . Estas restricciones incluyen la clave principal, la clave externa, las
restricciones únicas y otras restricciones que se mencionan anteriormente.
USO DE COMBINACIONES:
La cláusula SQL Joins se utiliza para combinar registros de dos o más tablas en una base
de datos. Un JOIN es un medio para combinar campos de dos tablas usando valores
comunes a cada uno.
Considere las siguientes dos tablas:
Tabla 1 - Tabla CLIENTES

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+
Tabla 2 - Tabla PEDIDOS

+-----+---------------------+-------------+--------+
|OID | DATE | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+
Ahora, unamos estas dos tablas en nuestra instrucción SELECT como se muestra a
continuación.
SQL> SELECT ID, NAME, AGE, AMOUNT
FROM CUSTOMERS, ORDERS
WHERE CUSTOMERS.ID = ORDERS.CUSTOMER_ID;
Esto produciría el siguiente resultado.

+----+----------+-----+--------+
| ID | NAME | AGE | AMOUNT |
+----+----------+-----+--------+
| 3 | kaushik | 23 | 3000 |
| 3 | kaushik | 23 | 1500 |
| 2 | Khilan | 25 | 1560 |
| 4 | Chaitali | 25 | 2060 |
+----+----------+-----+--------+
Aquí, se nota que la unión se realiza en la cláusula WHERE. Se pueden usar varios
operadores para unir tablas, como =, <,>, <>, <=,> =,! =, BETWEEN, LIKE y NOT; todos
pueden usarse para unir tablas. Sin embargo, el operador más común es el símbolo igual a.
Hay diferentes tipos de combinaciones disponibles en SQL:
 INNER JOIN : devuelve filas cuando hay una coincidencia en ambas tablas.
 LEFT JOIN : devuelve todas las filas de la tabla de la izquierda, incluso si no hay
coincidencias en la tabla de la derecha.
 RIGHT JOIN : devuelve todas las filas de la tabla de la derecha, incluso si no hay
coincidencias en la tabla de la izquierda.
 FULL JOIN : devuelve filas cuando hay una coincidencia en una de las tablas.
 SELF JOIN : se utiliza para unir una tabla consigo misma como si fueran dos tablas,
cambiando temporalmente el nombre de al menos una tabla en la declaración SQL.
 UNIÓN CARTESIANA : devuelve el producto cartesiano de los conjuntos de registros
de las dos o más tablas unidas.
Analicemos ahora cada una de estas uniones en detalle.

CLAUSULA DE UNIONES:
La cláusula / operador SQL UNION se utiliza para combinar los resultados de dos o más
sentencias SELECT sin devolver filas duplicadas.
Para usar esta cláusula UNION, cada instrucción SELECT debe tener
 El mismo número de columnas seleccionadas

 El mismo número de expresiones de columna
 El mismo tipo de datos y
 Tenlos en el mismo orden
Pero no es necesario que tengan la misma longitud.
Sintaxis
La sintaxis básica de una cláusula UNION es la siguiente:
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]
UNION

[WHERE condition]
Aquí, la condición dada podría ser cualquier expresión dada según su requisito.
Ejemplo
Considere las siguientes dos tablas.
Tabla 1 - CLIENTES La tabla es la siguiente.

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+
Tabla 2 - La tabla de PEDIDOS es la siguiente.

+-----+---------------------+-------------+--------+
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+
Ahora, unamos estas dos tablas en nuestra declaración SELECT de la siguiente manera:
SQL> SELECT ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
LEFT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION
SELECT ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
RIGHT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

+------+----------+--------+---------------------+
| ID | NAME | AMOUNT | DATE |
+------+----------+--------+---------------------+
| 1 | Ramesh | NULL | NULL |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
| 5 | Hardik | NULL | NULL |
| 6 | Komal | NULL | NULL |
| 7 | Muffy | NULL | NULL |
+------+----------+--------+---------------------+
La cláusula UNION ALL

El operador UNION ALL se utiliza para combinar los resultados de dos sentencias SELECT,
incluidas las filas duplicadas.
Las mismas reglas que se aplican a la cláusula UNION se aplicarán al operador UNION ALL.
Sintaxis
La sintaxis básica de UNION ALL es la siguiente.

[WHERE condition]
UNION ALL

[WHERE condition]
Aquí, la condición dada podría ser cualquier expresión dada según su requisito.
Ejemplo
Considere las siguientes dos tablas,

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+
Ahora, unamos estas dos tablas en nuestra declaración SELECT de la siguiente manera:
SQL> SELECT ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
LEFT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID
UNION ALL
SELECT ID, NAME, AMOUNT, DATE
FROM CUSTOMERS
RIGHT JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

+------+----------+--------+---------------------+
| ID | NAME | AMOUNT | DATE |
+------+----------+--------+---------------------+
| 1 | Ramesh | NULL | NULL |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
| 5 | Hardik | NULL | NULL |
| 6 | Komal | NULL | NULL |
| 7 | Muffy | NULL | NULL |
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
+------+----------+--------+---------------------+
Hay otras dos cláusulas (es decir, operadores), que son como la cláusula UNION.
 Cláusula SQL INTERSECT : se utiliza para combinar dos sentencias SELECT, pero

devuelve filas solo de la primera sentencia SELECT que son idénticas a una fila de la
segunda sentencia SELECT.
 Cláusula SQL EXCEPT : combina dos sentencias SELECT y devuelve filas de la
primera sentencia SELECT que no son devueltas por la segunda sentencia SELECT.
SINTAXIS ALIAS:
Puede cambiar el nombre de una tabla o columna temporalmente dando otro nombre
conocido como Alias . El uso de alias de tabla es para cambiar el nombre de una tabla en
una declaración SQL específica. El cambio de nombre es un cambio temporal y el nombre
real de la tabla no cambia en la base de datos. Los alias de columna se utilizan para cambiar
el nombre de las columnas de una tabla con el propósito de una consulta SQL en particular.
Sintaxis
La sintaxis básica de un alias de tabla es la siguiente.
SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];
La sintaxis básica de un alias de columna es la siguiente.

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];
Ejemplo
Considere las siguientes dos tablas.

+----+----------+-----+-----------+----------+
+----+----------+-----+-----------+----------+
| 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 |
+----+----------+-----+-----------+----------+

+-----+---------------------+-------------+--------+
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+
Ahora, el siguiente bloque de código muestra el uso de un alias de tabla .

SQL> SELECT C.ID, C.NAME, C.AGE, O.AMOUNT
FROM CUSTOMERS AS C, ORDERS AS O
WHERE C.ID = O.CUSTOMER_ID;

+----+----------+-----+--------+
| ID | NAME | AGE | AMOUNT |
+----+----------+-----+--------+
| 3 | kaushik | 23 | 3000 |
| 3 | kaushik | 23 | 1500 |
| 2 | Khilan | 25 | 1560 |
| 4 | Chaitali | 25 | 2060 |
+----+----------+-----+--------+
A continuación se muestra el uso de un alias de columna .

SQL> SELECT ID AS CUSTOMER_ID, NAME AS CUSTOMER_NAME
FROM CUSTOMERS
WHERE SALARY IS NOT NULL;

+-------------+---------------+
| CUSTOMER_ID | CUSTOMER_NAME |
+-------------+---------------+
| 1 | Ramesh |
| 2 | Khilan |
| 3 | kaushik |
| 4 | Chaitali |
| 5 | Hardik |
| 6 | Komal |
| 7 | Muffy |
+-------------+---------------+
https://www.tutorialspoint.com/sql/sql_questions_answers.htm

SQL Ultimo

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

SQL Ultimo

Cargado por

Copyright:

Formatos disponibles

SQL es seguido por un conjunto único de reglas y pautas llamado Sintaxis.

Varias sintaxis en SQL

Instrucción SQL SELECT

Cláusula SQL DISTINCT

Cláusula WHERE de SQL

Cláusula SQL BETWEEN

Cláusula LIKE de SQL

Cláusula ORDER BY de SQL

Cláusula SQL GROUP BY

Cláusula SQL COUNT

Cláusula HAVING de SQL

Sentencia SQL CREATE TABLE

Sentencia SQL DROP TABLE

Sentencia SQL CREATE INDEX

Sentencia SQL DROP INDEX

Declaración DESC de SQL

Sentencia SQL TRUNCATE TABLE

Sentencia SQL ALTER TABLE

Sentencia SQL ALTER TABLE (Cambiar nombre)

Instrucción SQL INSERT INTO

Sentencia SQL UPDATE

Sentencia SQL DELETE

Sentencia SQL CREATE DATABASE

Sentencia SQL DROP DATABASE

Sentencia USE SQL

Sentencia COMMIT de SQL

Sentencia SQL ROLLBACK

¿Qué es un operador en SQL?

Operadores aritméticos SQL

Operador Descripción Ejemplo

Agrega valores a ambos lados del operador. a+b

- (Resta) Resta el operando de la mano derecha del operando de la a-b

Multiplica los valores a ambos lados del operador. a*b

Divide el operando de la izquierda por el operando de la b/a

Divide el operando de la izquierda por el operando de la b% a

Operadores de comparación SQL

Operado Descripción Ejemplo

Comprueba si los valores de dos operandos son iguales o no, si es (a = b)

Comprueba si el valor del operando izquierdo es mayor que el (a> b)

Comprueba si el valor del operando izquierdo es menor que el (a <b)

Comprueba si el valor del operando izquierdo es menor o igual que (a <= b)

Comprueba si el valor del operando izquierdo no es menor que el

Comprueba si el valor del operando izquierdo no es mayor que el (a!> b)

Operadores lógicos SQL

8 El operador NOT invierte el significado del operador lógico con el que se

Considere la sintaxis básica de la instrucción SELECT de la siguiente manera:

Analicemos ahora cada uno de estos en detalle.

Considere la tabla CLIENTES que tiene los siguientes registros:

SQL> SELECT (15 + 6) AS ADDITION

Otra expresión de fecha es la que se muestra a continuación:

Esto produciría el siguiente resultado:

Esto produciría el resultado que se muestra a continuación.

Puede especificar una condición usando la comparación u operadores lógicos como>, <,

Esto produciría el siguiente resultado:

Esto produciría el siguiente resultado:

Los operadores SQL AND & OR se utilizan para combinar varias condiciones para restringir

Estos operadores proporcionan un medio para realizar múltiples comparaciones con

Considere la tabla CLIENTES que tiene los siguientes registros:

Esto produciría el siguiente resultado:

La sintaxis básica del operador OR con una cláusula WHERE es la siguiente:

Puede combinar N número de condiciones utilizando el operador OR. Para que la instrucción

Considere la tabla CLIENTES que tiene los siguientes registros: