Lenguaje SQL

SQL (Structured Query Language) es un lenguaje de programación diseñado para almacenar, manipular y recuperar datos almacenados en bases de datos relacionales. La
primera encarnación de SQL apareció en 1974, cuando un grupo de IBM desarrolló el primer prototipo de una base de datos relacional. Relational Software (luego se convirtió
en Oracle) lanzó la primera base de datos relacional comercial. Existen estándares para SQL. Sin embargo, el SQL que puede utilizarse en cada uno de las principales RDBMS
actuales viene en distintas formas. Esto se debe a dos razones: 1) el estándar SQL es bastante complejo, y no es práctico implementar el estándar completo, y 2) cada
proveedor de base de datos necesita una forma de diferenciar su producto de otros. En esta guía de referencia, dichas diferencias se señalarán cuando sea apropiado.

Este sitio de la guía de referencia SQL enumera los comandos SQL normalmente utilizados, y se divide en las siguientes secciones:

 Comandos SQL: Las instrucciones SQL básicas para almacenamiento, recuperación y manipulación de datos en una base de datos relacional.
 Manipulación de Tabla: Cómo se utilizan las instrucciones SQL para administrar las tablas dentro de una base de datos.
 SQL Avanzado: Comandos SQL avanzados.
 Sintaxis SQL: Una página única que enumera la sintaxis para todos los comandos SQL en esta guía de referencia.

Para cada comando, primero se presentará y explicará la sintaxis SQL, seguida por un ejemplo. Al final de esta guía de referencia, deberá tener una idea general de la sintaxis
SQL. Además, deberá poder realizar consultas SQL utilizando la sintaxis apropiada.
SQL > Manipulación de Tabla > Create Table

Las tablas son la estructura básica donde se almacena la información en la base de datos. Dado que en la mayoría de los casos, no hay forma de que el proveedor de base de
datos sepa con antelación cuales son sus necesidades de almacenamiento de datos, es probable que necesite crear tablas en la base de datos usted mismo. Muchas
herramientas de base de datos le permiten crear tablas sin ingresar SQL, pero debido a que las tablas son los contenedores de toda la información, es importante incluir la
sintaxis CREATE TABLE en esta guía de referencia. Antes de sumergirnos en la sintaxis SQL para CREATE TABLE, es una buena idea comprender lo que se incluye en una tabla.
Las tablas se dividen en filas y columnas. Cada fila representa una parte de los datos, y cada columna puede pensarse como la representación de un componente de aquella
parte de los datos. Entonces, por ejemplo, si tenemos una tabla para registrar la información del cliente, las columnas pueden incluir información tal como Primer Nombre,
Apellido, Dirección, Ciudad, País, Fecha de Nacimiento y demás. Como resultado, cuando especificamos una tabla, incluimos los títulos de columna y los tipos de datos para
esta columna en particular.

En la siguiente tabla mostramos los diferentes tipos de datos y sus principales características:

Tipo de de dato Características

VARCHAR2(tamaño) Almacena cadenas de caracteres de una longitud variable. La longitud máxima son 4000 caracteres.
CHAR(tamaño) Almacena caracteres con una longitud fija. Siendo 2000 caracteres el máximo
Almacena datos numéricos, tanto enteros como decimales, con o sin signo. Precisión, indica el número máximo de digitos que va a
NUMBER(precision,escala) tener el dato. Escala, indica el número de digitos que puede haber a la derecha del punto decimal.
LONG Almacena cadenas de caracteres de longitud variable. Puede almacenar hasta 2 gigas de información
LONG RAW Almacena datos binarios. Se emplea para el almacenamiento de gráficos, sonidos, etc. Su tamaño máximo es de 2 gigas
Almacena información de fechas y horas. De forma predeterminada almacena un dato con el siguiente formato:
DATE siglo/año/mes/dia/hora/minutos/segundos. Este formato se puede cambiar con otros parámetros.
RAW(tamaño) Almacena datos binarios. Puede almacenar como mucho 2000 bytes.
ROWID Se trata de un campo que representa una cadena hexadecimal que indica la dirección de una fila en su tabla
1
 Es similar al varchar2 pero el tamaño de un carácter depende de la eleccion del juego de caracteres. El tamaño máximo es 2000
NVARCHAR2(tamaño) bytes.
NCHAR(tamaño) Similar al char y con las mismas caracteristicas que el nvarchar2
CLOB Similar al LONG y se usua para objectos carácter
NCLOB Similar al CLOB solo que el tamaño del carácter depende del juego de caracteres utilizado
BLOB Similar al LONG RAW. Este se usa para objetos binarios.

Entonces ¿Qué son los tipos de datos? Generalmente, los datos se generan en formas variadas. Podría ser un entero (tal como 1), un número real (tal como 0,55), una línea (tal
como 'sql'), una fecha/expresión de tiempo (tal como '25-ene-2000 03:22:22'), o incluso en formato binario. Cuando especificamos una tabla, necesitamos especificar el tipo
de dato asociado con cada columna (es decir, especificaremos que ‘First_Name’ es de char(50) tipo – lo que significa que es una línea con 50 caracteres). Una cosa a tener en
cuenta es que las diferentes bases de datos relacionales permiten diferentes tipos de datos, entonces es prudente consultar primero una referencia específica de base de
datos.

La sintaxis SQL para CREATE TABLE es

CREATE TABLE "nombre_tabla"
("columna 1" "tipo_de_datos_para_columna_1",
"columna 2" "tipo_de_datos_para_columna_2",
... );

Entonces, si debemos crear una tabla para el cliente tal como se especifica anteriormente, ingresaríamos
CREATE TABLE Customer
(First_Name char(50),
Last_Name char(50),
Address char(50),
City char(50),
Country char(25),
Birth_Date datetime);

A veces, deseamos brindar un valor predeterminado a cada columna. Se utiliza un valor predeterminado cuando no especifica un valor de columna cuando ingresa datos a la
tabla. Para establecer un valor predeterminado, agregue “[valor] Predeterminado” luego de la instrucción de tipo de datos. En el ejemplo anterior, si deseamos predeterminar
una columna “Address” como “Desconocida” y Ciudad como “Barcelona”, ingresaríamos
CREATE TABLE Customer
(First_Name char(50),
Last_Name char(50),
Address char(50) default 'Unknown',
City char(50) default 'Barcelona',
Country char(25),
Birth_Date datetime);

También puede limitar el tipo de información que una tabla /columna puede mantener. Esto se realiza a través de la palabra clave CONSTRAINT, que se describe a
continuación.
SQL > Manipulación de Tabla > Constraint

2
Puede colocar restricciones para limitar el tipo de dato que puede ingresarse en una tabla. Dichas restricciones pueden especificarse cuando la tabla se crea por primera vez a
través de la instrucción CREATE TABLE, o luego de crear la tabla a través de la instrucciónALTER TABLE.

Los tipos comunes de restricciones incluyen las siguientes:

- NOT NULL - Clave primaria

- UNIQUE - Clave externa
- CHECK

Cada uno se describe en detalle a continuación.

NOT NULL

En forma predeterminada, una columna puede ser NULL. Si no desea permitir un valor NULL en una columna, querrá colocar una restricción en esta columna especificando que
NULL no es ahora un valor permitido.

Por ejemplo, en la siguiente instrucción,

CREATE TABLE Customer
(SID integer NOT NULL,
Last_Name varchar (30) NOT NULL,
First_Name varchar(30));

Las columnas “SID” y “Last_Name” no incluyen NULL, mientras que “First_Name” puede incluir NULL.

UNIQUE

La restricción UNIQUE asegura que todos los valores en una columna sean distintos.

Por ejemplo, en la siguiente instrucción,

CREATE TABLE Customer
(SID integer Unique,
Last_Name varchar (30),
First_Name varchar(30));

La columna “SID” no puede incluir valores duplicados, mientras dicha restricción no se aplica para columnas “Last_Name” y “First_Name”.

Por favor note que una columna que se especifica como clave primaria también puede ser única. Al mismo tiempo, una columna que es única puede o no ser clave primaria.

3
CHECK

La restricción CHECK asegura que todos los valores en una columna cumplan ciertas condiciones.

Por ejemplo, en la siguiente instrucción,

CREATE TABLE Customer
(SID integer CHECK (SID > 0),
Last_Name varchar (30),
First_Name varchar(30));

La columna “SID” sólo debe incluir enteros mayores a 0.

Por favor note que la restricción CHECK no sea ejecutada por MySQL en este momento.

SQL > Manipulación de Tabla > Clave primaria

La clave primaria se utiliza para identificar en forma única cada línea en la tabla. Puede ser parte de un registro real, o puede ser un campo artificial (uno que no tiene nada que
ver con el registro real). Una clave primaria puede consistir en uno o más campos en una tabla. Cuando se utilizan múltiples campos como clave primaria, se los denomina
claves compuestas.

Las claves primarias pueden especificarse cuando se crea la tabla (utilizando CREATE TABLE) o cambiando la estructura existente de la tabla (utilizando ALTER TABLE).

A continuación se presentan ejemplos para la especificación de una clave primaria cuando se crea una tabla:

MySQL:
CREATE TABLE Customer
(SID integer,
Last_Name varchar(30),
First_Name varchar(30),
PRIMARY KEY (SID));

Oracle:
CREATE TABLE Customer
(SID integer PRIMARY KEY,
Last_Name varchar(30),
First_Name varchar(30));

SQL Server:
CREATE TABLE Customer
(SID integer PRIMARY KEY,

4
Last_Name varchar(30),
First_Name varchar(30));

A continuación se presentan ejemplos para la especificación de una clave primaria al modificar una tabla:

MySQL:
ALTER TABLE Customer ADD PRIMARY KEY (SID);

Oracle:
ALTER TABLE Customer ADD PRIMARY KEY (SID);

SQL Server:
ALTER TABLE Customer ADD PRIMARY KEY (SID);

Nota: Antes de utilizar el comando ALTER TABLE para agregar una clave primaria, necesitará asegurarse de que el campo esté definido como 'NOT NULL' -- en otras palabras,
NULL no puede aceptarse como valor para ese campo.
SQL > Manipulación de Tabla > Clave externa

Una clave externa es un campo (o campos) que señala la clave primaria de otra tabla. El propósito de la clave externa es asegurar la integridad referencial de los datos. En otras
palabras, sólo se permiten los valores que se esperan que aparezcan en la base de datos.

Por ejemplo, digamos que tenemos dos tablas, una tabla CUSTOMER que incluye todos los datos del CUSTOMER, y la tabla ORDERSque incluye los pedidos del CUSTOMER. La
restricción aquí es que todos los pedidos deben asociarse con un CUSTOMER que ya se encuentra en la tabla CUSTOMER. En este caso, colocaremos una clave externa en la
tabla ORDERS y la relacionaremos con la clave primaria de la tabla CUSTOMER. De esta forma, nos aseguramos que todos los pedidos en la tabla ORDERS estén relacionadas
con unCUSTOMER en la tabla CUSTOMER. En otras palabras, la tabla ORDERS no puede contener información de un CUSTOMER que no se encuentre en la tabla CUSTOMER.

La estructura de estas dos tablas será la siguiente:

Tabla CUSTOMER
Nombre de Columna Característica
SID Clave Primaria
Last_Name
First_Name

Tabla ORDERS
Nombre de Columna Característica
Order_ID Clave Primaria
Order_Date

5
Customer_SID Clave Externa
Amount

En el ejemplo anterior, la columna Customer_SID en la tabla ORDERS es una clave externa señalando la columna SID en la tablaCUSTOMER.

A continuación se muestran ejemplos de cómo especificar la clave externa a la hora de crear la tabla ORDERS:

MySQL:
CREATE TABLE ORDERS
(Order_ID integer,
Order_Date date,
Customer_SID integer,
Amount double,
PRIMARY KEY (Order_ID),
FOREIGN KEY (Customer_SID) REFERENCES CUSTOMER (SID));

Oracle:
CREATE TABLE ORDERS
(Order_ID integer PRIMARY KEY,
Order_Date date,
Customer_SID integer REFERENCES CUSTOMER (SID),
Amount double);

SQL Server:
CREATE TABLE ORDERS
(Order_ID integer PRIMARY KEY,
Order_Date datetime,
Customer_SID integer REFERENCES CUSTOMER (SID),
Amount double);

A continuación se presentan ejemplos para la especificación de una clave externa al modificar una tabla: Esto asume que se ha creado la tabla ORDERS, y que la clave externa
todavía no se ha ingresado:

MySQL:
ALTER TABLE ORDERS
ADD FOREIGN KEY (Customer_SID) REFERENCES CUSTOMER (SID);

Oracle:
ALTER TABLE ORDERS
ADD (CONSTRAINT fk_orders1) FOREIGN KEY (Customer_SID) REFERENCES CUSTOMER (SID);

6
SQL Server:
ALTER TABLE ORDERS
ADD FOREIGN KEY (Customer_SID) REFERENCES CUSTOMER (SID);

SQL > Manipulación de Tabla > Drop Table

A veces podemos decidir que necesitamos eliminar una tabla en la base de datos por alguna razón. De hecho, sería problemático si no podemos hacerlo ya que esto crearía
una pesadilla de mantenimiento para DBA. Afortunadamente, SQL nos permite hacerlo, ya que podemos utilizar el comando DROP TABLE. La sintaxis para DROP TABLE es
DROP TABLE "nombre_tabla";

Entonces, si deseamos eliminar una tabla denominada cliente que creamos en la sección CREATE TABLE, simplemente ingresamos
DROP TABLE Customer;

SQL > Manipulación de Tabla > Truncate Table

A veces deseamos eliminar los datos en una tabla. Una forma de hacer esto es con DROP TABLE, que vimos en la última sección Pero ¿Si deseamos simplemente deshacernos
de los datos pero no de la tabla en sí? Para esto, podemos utilizar el comando TRUNCATE TABLE. La sintaxis para TRUNCATE TABLE es
TRUNCATE TABLE "nombre_tabla";

Entonces, si deseamos truncar una tabla denominada cliente que creamos en SQL CREATE TABLE, simplemente ingresamos
TRUNCATE TABLE Customer;

SQL > Manipulación de Tabla > Insert Into

En las secciones anteriores, hemos visto cómo obtener información de tablas. Pero ¿Cómo se ingresan estas filas de datos en estas tablas en primer lugar? Esto es lo que se
trata en esta sección, que explica la instrucción INSERT, y en la siguiente sección, que explica la instrucción UPDATE.

En SQL, hay fundamental y básicamente dos formas para INSÉRER datos en una tabla: Una es insertar una fila por vez, y la otra es insertar filas múltiples por vez. Primero
observemos como podemos INSÉRER datos a través de una fila por vez:

La sintaxis para insertar datos en una tabla mediante una fila por vez es la siguiente:
INSERT INTO "nombre_tabla" ("columna1", "columna2", ...)
VALUES ("valor1", "valor2", ...);

Suponiendo que tenemos una taba con la siguiente estructura,

Tabla Store_Information
Nombre de Columna Tip de Datos
Store_Name char(50)
Sales Float

7
Txn_Date Datetime

y ahora deseamos insertar una fila adicional en la tabla que represente los datos de ventas para Los Ángeles el 10 de enero de 1999. En ese día, este negocio tenía $900
dólares estadounidenses en ventas. Por lo tanto, utilizaremos la siguiente escritura SQL:
INSERT INTO Store_Information (Store_Name, Sales, Txn_Date)
VALUES ('Los Angeles', 900, '10-Jan-1999');

El segundo tipo de INSERT INTO nos permite insertar filas múltiples en una tabla. A diferencia del ejemplo anterior, donde insertamos una única fila al especificar sus valores
para todas las columnas, ahora utilizamos la instrucción SELECT para especificar los datos que deseamos insertar en la tabla. Si está pensando si esto significa que está
utilizando información de otra tabla, está en lo correcto. La sintaxis es la siguiente:
INSERT INTO "tabla1" ("columna1", "columna2", ...)
SELECT "columna3", "columna4", ...
FROM "tabla2";

Note que esta es la forma más simple. La instrucción entera puede contener fácilmente cláusulas WHERE, GROUP BY, y HAVING, así como también uniones y alias.

Entonces por ejemplo, si deseamos tener una tabla Store_Information, que recolecte la información de ventas para el año 1998, y ya conoce en donde reside la fuente de
datos en tabala Sales_Information, ingresaremos:
INSERT INTO Store_Information (Store_Name, Sales, Txn_Date)
SELECT Store_Name, Sales, Txn_Date
FROM Sales_Information
WHERE Year (Txn_Date) = 1998;

Aquí hemos utilizado la sintaxis de Servidor SQL para extraer la información anual por medio de una fecha. Otras bases de datos relacionales pueden tener sintaxis diferentes.
Por ejemplo, en Oracle, utilizará TO_CHAR (Txn_Date, 'yyyy') = 1998.
SQL > Manipulación de Tabla > Update

Una vez que hay datos en la tabla, podríamos tener la necesidad de modificar los mismos. Para hacerlo, utilizamos el comando UPDATE. La sintaxis para esto es,
UPDATE "nombre_tabla"
SET "columna_1" = [nuevo valor]
WHERE "condición";

Por ejemplo, digamos que actualmente tenemos la tabla a continuación:

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Los Angeles 300 08-Jan-1999

8
Boston 700 08-Jan-1999

y notamos que las ventas para Los Angeles el 08/01/1999 es realmente de 500€ en vez de 300€ dólares estadounidenses, y que esa entrada en particular necesita actualizarse.
Para hacerlo, utilizamos el siguiente SQL:
UPDATE Store_Information
SET Sales = 500
WHERE Store_Name = 'Los Angeles'
AND Txn_Date = '08-Jan-1999';

La tabla resultante ser vería

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Los Angeles 500 08-Jan-1999
Boston 700 08-Jan-1999

En este caso, hay sólo una fila que satisface la condición en la cláusula WHERE. Si hay múltiples filas que satisfacen la condición, todas ellas se modificarán.

También es posible UPDATE múltiples columnas al mismo tiempo. La sintaxis en este caso se vería como la siguiente:
UPDATE "nombre_tabla"
SET colonne 1 = [[valor1], colonne 2 = [valor2]
WHERE "condición";

SQL > Manipulación de Tabla > Delete From

A veces podemos desear deshacernos de los registros de una tabla. Para ello, utilizamos el comando DELETE FROM. La sintaxis para esto es,
DELETE FROM "nombre_tabla"
WHERE "condición";

Es más fácil utilizar un ejemplo. Por ejemplo, digamos que actualmente tenemos la siguiente tabla:

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999

9
Los Angeles 300 08-Jan-1999
Boston 700 08-Jan-1999

y decidimos no mantener ninguna información sobre Los Ángeles en esta tabla. Para lograrlo, ingresamos el siguiente SQL:
DELETE FROM Store_Information
WHERE Store_Name = 'Los Angeles';

Ahora el contenido de la tabla se vería,

Tabla Store_Information
Store_Name Sales Txn_Date
San Diego 250 07-Jan-1999
Boston 700 08-Jan-1999

SQL > Comandos SQL > Select

¿Para qué utilizamos los comandos SQL? El uso común es la selección de datos desde tablas ubicadas en una base de datos. Inmediatamente, vemos dos palabras claves:
necesitamos SELECT la información FROM una tabla. (Note que la tabla es un contenedor que reside en la base de datos donde se almacena la información. Para obtener más
información acerca de cómo manipular tablas, consulte la Sección Manipulación de Tabla). Por lo tanto tenemos la estructura SQL más básica:
SELECT "nombre_columna" FROM "nombre_tabla";

Para ilustrar el ejemplo anterior, suponga que tenemos la siguiente tabla:

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Los Angeles 300 08-Jan-1999
Boston 700 08-Jan-1999

Podemos utilizar esta tabla como ejemplo a lo largo de la guía de referencia (esta tabla aparecerá en todas las secciones). Para seleccionar todos los negocios en esta tabla,
ingresamos,
SELECT Store_Name FROM Store_Information;

Resultado:

10
Store_Name
Los Angeles
San Diego
Los Angeles
Boston

Pueden seleccionarse los nombres de columnas múltiples, así como también los nombres de tablas múltiples.

SQL > Comandos SQL > Distinct

La palabra clave SELECT nos permite tomar toda la información de una columna (o columnas) en una tabla. Esto, obviamente, significa necesariamente que habrá
redundancias. ¿Qué sucedería si sólo deseamos seleccionar cada elemento DISTINCT? Esto es fácil de realizar en SQL. Todo lo que necesitamos hacer es
agregar DISTINCT luego de SELECT. La sintaxis es la siguiente:
SELECT DISTINCT "nombre_columna"
FROM "nombre_tabla";

Por ejemplo, para seleccionar todos los negocios distintos en la Tabla Store_Information,

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Los Angeles 300 08-Jan-1999
Boston 700 08-Jan-1999

Ingresamos,
SELECT DISTINCT store_name FROM Store_Information;

Resultado:
Store_Name
Los Angeles
San Diego
Boston

SQL > Comandos SQL > Where

Luego, podríamos desear seleccionar condicionalmente los datos de una tabla. Por ejemplo, podríamos desear sólo recuperar los negocios con ventas mayores a 1.000€
dólares estadounidenses. Para ello, utilizamos la palabra clave WHERE. La sintaxis es la siguiente:
11
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "condición";

Por ejemplo, para seleccionar todos los negocios con ventas mayores a 1000 dólares estadounidenses en la Tabla Store_Information,

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Los Angeles 300 08-Jan-1999
Boston 700 08-Jan-1999

Ingresamos,
SELECT Store_Name
FROM Store_Information
WHERE Sales > 1000;

Resultado:
Store_Name
Los Angeles

SQL > Comandos SQL > And Or

En la sección anterior, hemos visto que la palabra clave WHERE también puede utilizarse para seleccionar datos condicionalmente desde una tabla. Esta condición puede ser
una condición simple (como la que se presenta en la sección anterior), o puede ser una condición compuesta. Las condiciones compuestas están formadas por múltiples
condiciones simples conectadas por AND u OR. No hay límites en el número de condiciones simples que pueden presentarse en una sola instrucción SQL.

La sintaxis de una condición compuesta es la siguiente:

SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "condición simple"
{[AND|OR] "condición simple"}+;

{}+ significa que la expresión dentro de las llaves ocurrirá una o más veces. Note que AND u OR pueden utilizarse indistintamente. Además, podemos utilizar el símbolo
paréntesis ( ) para indicar el orden de la condición.

Por ejemplo, podemos desear seleccionar todos los negocios con ventas mayores a 1000€ dólares estadounidenses o todos los negocios con ventas menores a 500€ dólares
estadounidenses pero mayores a 275€ dólares estadounidenses en la TablaStore_Information,
12
Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
San Francisco 300 08-Jan-1999
Boston 700 08-Jan-1999

Ingresamos,
SELECT Store_Name
FROM Store_Information
WHERE Sales > 1000
OR (Sales < 500 AND Sales > 275);

Resultado:
Store_Name
Los Angeles
San Francisco

SQL > Comandos SQL > In

En SQL, hay dos usos de la palabra clave IN, y esta sección introduce aquél relacionado con la cláusula WHERE. Cuando se lo utiliza en este contexto, sabemos exactamente el
valor de los valores regresados que deseamos ver para al menos una de las columnas. La sintaxis para el uso de la palabra clave IN es la siguiente:
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "nombre_columna" IN (''valor1', ''valor2', ...);

El número de valores en los paréntesis pueden ser uno o más, con cada valor separado por comas. Los valores pueden ser números o caracteres. Si hay sólo un valor dentro del
paréntesis, este comando es equivalente a
WHERE "nombre_columna" = 'valor1'

Por ejemplo, podríamos desear seleccionar todos los registros para los negocios de Los Ángeles y San Diego en la TablaStore_Information,

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
San Francisco 300 08-Jan-1999

13
Boston 700 08-Jan-1999

Ingresamos,
SELECT *
FROM Store_Information
WHERE Store_Name IN ('Los Angeles', 'San Diego');

Resultado:
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999

SQL > Comandos SQL > Between

Mientras que la palabra clave IN ayuda a las personas a limitar el criterio de selección para uno o más valores discretos, la palabra clave BETWEEN permite la selección de un
rango. La sintaxis para la cláusula BETWEEN es la siguiente:
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "nombre_columna" BETWEEN 'valor1' AND 'valor2';

Esto seleccionará todas las filas cuya columna tenga un valor entre 'valor1' y 'valor2'.

Por ejemplo, podríamos desear seleccionar la visualización de toda la información de ventas entre el 06 de enero de 1999, y el 10 de enero de 1999, en la
Tabla Store_Information,

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
San Francisco 300 08-Jan-1999
Boston 700 08-Jan-1999

Ingresamos,
SELECT *
FROM Store_Information
WHERE Txn_Date BETWEEN '06-Jan-1999' AND '10-Jan-1999';

Tenga en cuenta que la fecha puede almacenarse en diferentes formatos según las diferentes bases de datos. Esta guía de referencia simplemente elige uno de los formatos.

14
Resultado:
Store_Name Sales Txn_Date
San Diego 250 07-Jan-1999
San Francisco 300 08-Jan-1999
Boston 700 08-Jan-1999

SQL > Comandos SQL > Like

LIKE es otra palabra clave que se utiliza en la cláusula WHERE. Básicamente, LIKE le permite hacer una búsqueda basada en un patrón en vez de especificar exactamente lo que
se desea (como en IN) o determinar un rango (como en BETWEEN). La sintaxis es la siguiente:
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "nombre_columna" LIKE {patrón};

{patrón} generalmente consiste en comodines. Aquí hay algunos ejemplos:

 'A_Z': Toda línea que comience con 'A', otro carácter y termine con 'Z'. Por ejemplo, 'ABZ' y 'A2Z' deberían satisfacer la condición, mientras 'AKKZ' no debería (debido a
que hay dos caracteres entre A y Z en vez de uno).
 'ABC%': Todas las líneas que comienzan con 'ABC'. Por ejemplo, 'ABCD' y 'ABCABC' ambas deberían satisfacer la condición.
 '%XYZ': Todas las líneas que terminan con 'XYZ'. Por ejemplo, 'WXYZ' y 'ZZXYZ' ambas deberían satisfacer la condición.
 '%AN%': : Todas las líneas que contienen el patrón 'AN' en cualquier lado. Por ejemplo, 'LOS ANGELES' y 'SAN FRANCISCO' ambos deberían satisfacer la condición.

Digamos que tenemos la siguiente tabla:

Tabla Store_Information
Store_Name Sales Txn_Date
LOS ANGELES 1500 05-Jan-1999
SAN DIEGO 250 07-Jan-1999
SAN FRANCISCO 300 08-Jan-1999
BOSTON 700 08-Jan-1999

Deseamos encontrar todos los negocios cuyos nombres contengan ‘AN’. Para hacerlo, ingresamos,
SELECT *
FROM Store_Information
WHERE Store_Name LIKE '%AN%';

Resultado:
Store_Name Sales Txn_Date

15
LOS ANGELES 1500 05-Jan-1999
SAN DIEGO 250 07-Jan-1999
SAN FRANCISCO 300 08-Jan-1999

SQL > Comandos SQL > Order By

Hasta ahora, hemos visto cómo obtener datos de una tabla utilizando los comandos SELECT y WHERE. Con frecuencia, sin embargo, necesitamos enumerar el resultado en un
orden particular. Esto podría ser en orden ascendente, en orden descendente, o podría basarse en valores numéricos o de texto. En tales casos, podemos utilizar la palabra
clave ORDER BY para alcanzar nuestra meta.

La sintaxis para una instrucción ORDER BY es la siguiente:

SELECT "nombre_columna"
FROM "nombre_tabla"
[WHERE "condición"]
ORDER BY "nombre_columna" [ASC, DESC];

[ ] significa que la instrucción WHERE es opcional. Sin embargo, si existe una cláusula WHERE, viene antes de la cláusula ORDER BYASC significa que los resultados se
mostrarán en orden ascendente, y DESC significa que los resultados se mostrarán en orden descendente. Si no se especifica ninguno, la configuración predeterminada es ASC.

Es posible ordenar por más de una columna. En este caso, la cláusula ORDER BY anterior se convierte en
ORDER BY "nombre1_columna" [ASC, DESC], "nombre2_columna" [ASC, DESC]

Suponiendo que elegimos un orden ascendente para ambas columnas, el resultado se clasificará en orden ascendente según la columna 1. Si hay una relación para el valor de
la columna 1, se clasificará en orden ascendente según la columna 2.

Por ejemplo, podríamos desear enumerar los contenidos de la Tabla Store_Information según la suma en dólares, en orden descendente:

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
San Francisco 300 08-Jan-1999
Boston 700 08-Jan-1999

Ingresamos,
SELECT Store_Name, Sales, Txn_Date
FROM Store_Information
ORDER BY Sales DESC;

16
Resultado:
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
Boston 700 08-Jan-1999
San Francisco 300 08-Jan-1999
San Diego 250 07-Jan-1999

Además del nombre de la columna, podríamos utilizar la posición de la columna (según la consulta SQL) para indicar en qué columna deseamos aplicar la cláusula ORDER BY.
La primera columna es 1, y la segunda columna es 2, y así sucesivamente. En el ejemplo anterior, alcanzaremos los mismos resultados con el siguiente comando:
SELECT Store_Name, Sales, Txn_Date
FROM Store_Information
ORDER BY 2 DESC;

SQL > Comandos SQL > Fonciones

Ya que hemos comenzado trabajando con números, la siguiente pregunta natural a realizarse es si es posible hacer cálculos matemáticos con aquellos números, tales como
sumas, o sacar un promedio. ¡La respuesta es sí! SQL tiene varias funciones aritméticas, y estas son:

 AVG
 COUNT
 MAX
 MIN
 SUM

La sintaxis para el uso de funciones es,

SELECT "tipo de función"("nombre_columna")
FROM "nombre_tabla";

Por ejemplo, si deseamos obtener la sumatoria de todas las ventas de la siguiente tabla,

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Los Angeles 300 08-Jan-1999
Boston 700 08-Jan-1999

ingresaríamos

17
SELECT SUM(Sales) FROM Store_Information;

Resultado:
SUM(Sales)
2750

2750 dólares estadounidenses representa la suma de todas las entradas de Ventas: 1500 + 250 + 300 + 700.

Además de utilizar dichas funciones, también es posible utilizar SQL para realizar tareas simples como suma (+) y resta (-). Para ingresar datos del tipo caracter, hay también
varias funciones de cadenas disponibles, tales como funciones de concatenación, reducción y subcadena. Los diferentes proveedores RDBMS tienen diferentes
implementaciones de funciones de cadenas, y es mejor consultar las referencias para sus RDBMS a fin de ver cómo se utilizan estas funciones.
SQL > Comandos SQL > Count

Otra función aritmética es COUNT. Esto nos permite COUNT el número de filas en una tabla determinada. La sintaxis es,
SELECT COUNT("nombre_columna")
FROM "nombre_columna";

Por ejemplo, si deseamos encontrar el número de entradas de negocios en nuestra tabla,

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Los Angeles 300 08-Jan-1999
Boston 700 08-Jan-1999
ingresamos,
SELECT COUNT (Store_Name)
FROM Store_Information;

Resultado:
COUNT (Store_Name)
4
COUNT y DISTINCT pueden utilizarse juntos en una instrucción para determinar el número de las distintas entradas en una tabla. Por ejemplo, si deseamos saber el número de
los distintos negocios, ingresaríamos,
SELECT COUNT (DISTINCT Store_Name)
FROM Store_Information;

Resultado:

18
COUNT (DISTINCT Store_Name)
3
SQL > Comandos SQL > Group By

Ahora regresamos a las funciones de agregados. ¿Recuerda que utilizamos la palabra clave SUM para calcular las ventas totales para todos los negocios? ¿Y si quisiéramos
calcular el total de ventas para cada negocio? Entonces, necesitamos hacer dos cosas: Primero, necesitamos asegurarnos de que hayamos seleccionado el nombre del negocio
así como también las ventas totales. Segundo, debemos asegurarnos de que todas las sumas de las ventas estén GROUP BY negocios. La sintaxis SQL correspondiente es,
SELECT "nombre1_columna", SUM("nombre2_columna")
FROM "nombre_tabla"
GROUP BY "nombre1-columna";

Ilustremos utilizando la siguiente tabla,

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Los Angeles 300 08-Jan-1999
Boston 700 08-Jan-1999
Deseamos saber las ventas totales para cada negocio. Para hacerlo, ingresaríamos,
SELECT Store_Name, SUM(Sales)
FROM Store_Information
GROUP BY Store_Name;

Resultado:
Store_Name SUM(Sales)
Los Angeles 1800
San Diego 250
Boston 700
La palabra clave GROUP BY se utiliza cuando estamos seleccionado columnas múltiples desde una tabla (o tablas) y aparece al menos un operador aritmético en la
instrucción SELECT. Cuando esto sucede, necesitamos GROUP BY todas las otras columnas seleccionadas,es decir, todas las columnas excepto aquella(s) que se operan por un
operador aritmético.

SQL > Comandos SQL > Having

Otra cosa que la gente puede querer hacer es limitar el resultado según la suma correspondiente (o cualquier otra función de agregado). Por ejemplo, podríamos desear ver
sólo los negocios con ventas mayores a 1 500 €, dólares. En vez de utilizar la cláusulaWHERE en la instrucción SQL, a pesar de que necesitemos utilizar la cláusula HAVING, que

19
se reserva para funciones de agregados. La cláusula HAVING se coloca generalmente cerca del fin de la instrucción SQL, y la instrucción SQL con la cláusula HAVING. puede o
no incluir la cláusula GROUP BY sintaxis para HAVING es,
SELECT "nombre1_columna", SUM("nombre2_columna")
FROM "nombre_tabla"
GROUP BY "nombre1_columna"
HAVING (condición de función aritmética);

Nota: La cláusula GROUP BY es opcional.

En nuestro ejemplo, tabla Store_Information,

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Los Angeles 300 08-Jan-1999
Boston 700 08-Jan-1999

ingresaríamos,
SELECT Store_Name, SUM(Sales)
FROM Store_Information
GROUP BY Store_Name
HAVING SUM(Sales) > 1500;

Resultado:
Store_Name SUM(Sales)
Los Angeles 1800

SQL > Comandos SQL > Alias

Nos concentraremos ahora en el uso de alias. Hay dos tipos de alias que se utilizan con mayor frecuencia. Alias de columna y alias de tabla.

Resumiendo, los alias de columna existen para ayudar en la organización del resultado. En el ejemplo anterior, cualquiera sea el momento en que vemos las ventas totales, se
enumeran como SUM(Sales). Mientras esto es comprensible, podemos ver casos donde el título de la columna pueden complicarse (especialmente si incluye varias
operaciones aritméticas). El uso de un alias de columna haría el resultado mucho más legible.

El segundo tipo de alias es el alias de tabla. Esto se alcanza al colocar un alias directamente luego del nombre de tabla en la cláusulaFROM. Esto es conveniente cuando desea
obtener información de dos tablas separadas (el término técnico es 'realizar uniones'). La ventaja de utiliza un alias de tablas cuando realizamos uniones es rápidamente
aparente cuando hablamos de uniones.
20
Antes de comenzar con las uniones, miremos la sintaxis tanto para el alias de columna como de tabla:
SELECT "alias_tabla"."nombre1_columna" "alias_columna"
FROM "nombre_tabla" "alias_tabla";

Brevemente, ambos tipos de alias se colocan directamente después del elemento por el cual generan el alias, separados por un espacio en blanco. Nuevamente utilizamos
nuestra tabla, Store_Information,

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Los Angeles 300 08-Jan-1999
Boston 700 08-Jan-1999

Utilizamos el mismo ejemplo que en la sección SQL GROUP BY, salvo que hemos colocado tanto el alias de columna como el alias de tabla:
SELECT A1.Store_Name Store, SUM([Link]) "Total Sales"
FROM Store_Information A1
GROUP BY A1.Store_Name;

Resultado:
Store Total Sales
Los Angeles 1800
San Diego 250
Boston 700

Note la diferencia en el resultado: los títulos de las columnas ahora son diferentes. Ese es el resultado de utilizar el alias de columna. Note que en vez de “Sum(Sales)” de algún
modo enigmático, ahora tenemos “Total Sales”, que es más comprensible, como título de columna. La ventaja de utilizar un alias de tablas no es fácil de ver en este ejemplo.
Sin embargo, se tornará evidente en la siguiente sección.
SQL > Comandos SQL > Join

Ahora miremos las uniones. Para realizar uniones en SQL se requieren mucho de los elementos que ya hemos presentado. Digamos que tenemos las siguientes dos tablas:

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Los Angeles 300 08-Jan-1999
21
Boston 700 08-Jan-1999
Tabla Geography
Region_Name Store_Name
East Boston
East New York
West Los Angeles
West San Diego
y queremos saber las ventas por región. Vemos que la tabla Geography incluye información sobre regiones y negocios, y la tablaStore_Information contiene información de
ventas para cada negocio. Para obtener la información de ventas por región, debemos combinar la información de las dos tablas. Al examinar las dos tablas, encontramos que
están enlazadas a través del campo común “nombre_negocio” Primero presentaremos la instrucción SQL y explicaremos el uso de cada segmento después:
SELECT A1.Region_Name REGION, SUM([Link]) SALES
FROM Geography A1, Store_Information A2
WHERE A1.Store_Name = A2.Store_Name
GROUP BY A1.Region_Name;

Resultado:
REGION SALES
East 700
West 2050
Las primeras dos líneas le indican a SQL que seleccione dos campos, el primero es el campo "Region_Name" de la tabla Geography(denominado REGION), y el segundo es la
suma del campo "Sales" de la tabla Store_Information (denominado SALES). Note como se utilizan los alias de tabla aquí: Geography se denomina A1, e Store_Information se
denomina A2. Sin los alias, la primera línea sería
SELECT Geography.region_name REGION, SUM(Store_Information.Sales) SALES

que es mucho más problemática. En esencia, los alias de tabla facilitan el entendimiento de la totalidad de la instrucción SQL, especialmente cuando se incluyen tablas
múltiples.

Luego, pongamos nuestra atención en la línea 2, la instrucción WHERE. Aquí es donde se especifica la condición de la unión. En este caso, queremos asegurarnos que el
contenido en "Store_Name" en la tabla Geography concuerde con la tabla Store_Information, y la forma de hacerlo es igualarlos. Esta instrucción WHERE es esencial para
asegurarse de que obtenga el resultado correcto. Sin la correcta instrucción WHERE se producirá una Unión Cartesiana. Las uniones cartesianas darán por resultado que de la
consulta se arroje toda combinación posible de las dos tablas (o cualquiera que sea el número de tablas en la instrucción FROM). En este caso, una unión cartesiana resultaría
en un total de 4x4 = Se presenta un resultado de16 filas.
SQL > Comandos SQL > Outer Join

Anteriormente, hemos visto una unión izquierda, o interna, donde seleccionamos filas comunes a las tablas que participan en la unión. ¿Qué sucede en los casos donde
estamos interesados en la selección de elementos en una tabla sin importar si se encuentran presentes en la segunda tabla? Ahora necesitaremos utilizar el comando SQL
OUTER JOIN.

22
La sintaxis para realizar una unión externa en SQL depende de la base de datos. Por ejemplo, en Oracle, colocaremos un "(+)" en la cláusula WHERE del otro lado de la tabla
para la que queremos incluir todas las filas.

Digamos que tenemos las siguientes dos tablas:

Tabla Store_Information
Store_Name Sales Txn_Date
Los Angeles 1500 05-Jan-1999
San Diego 250 07-Jan-1999
Los Angeles 300 08-Jan-1999
Boston 700 08-Jan-1999

Tabla Geography
Region_Name Store_Name
East Boston
East New York
West Los Angeles
West San Diego

y queremos saber la suma de las ventas de todos los negocios. Si realizamos una unión regular, no podríamos obtener lo que deseamos debido a que habríamos omitido “New
York" ya que no aparece en la tabla Store_Information. Por lo tanto, necesitamos realizar una unión externa respecto de las dos tablas anteriores:
SELECT A1.Store_Name, SUM([Link]) SALES
FROM Geography A1, Store_Information A2
WHERE A1.Store_Name = A2.Store_Name (+)
GROUP BY A1.Store_Name;

Note que en este caso, estamos utilizando la sintaxis Oracle para unión externa.

Resultado:
Store_Name SALES
Boston 700
New York
Los Angeles 1800
San Diego 250

23
Nota: Se devuelve NULL cuando no hay coincidencia en la segunda tabla. En este caso, “New York" no aparece en la tablaStore_Information, por lo tanto su columna "SALES"
correspondiente es NULL.
SQL > Comandos SQL > Concatenar Funcion

Algunas veces es necesario combinar en forma conjunta (concatenar) los resultados de varios campos diferentes. Cada base de datos brinda una forma para realizar esto:

 MySQL: CONCAT( )
 Oracle: CONCAT( ), ||
 SQL Server: +

La sintaxis para CONCAT( ) es la siguiente:

CONCAT (cad1, cad2, cad3, ...)

Concatenar cad1, cad2, cad3, y cualquier otra cadena juntas. Por favor note que la función CONCAT( ) de Oracle sólo permite dos argumentos – sólo dos cadenas pueden
colocarse juntas al mismo tiempo utilizando esta función. Sin embargo, es posible concatenar más de dos cadenas al mismo tiempo en Oracle utilizando '||'.

Observemos algunos ejemplos. Supongamos que tenemos la siguiente tabla:

Tabla Geography
Region_Name Store_Name
East Boston
East New York
West Los Angeles
West San Diego
Ejemplo 1

MySQL/Oracle:
SELECT CONCAT (Region_Name, Store_Name) FROM Geography
WHERE Store_Name = 'Boston';

Resultado:
'EastBoston'

Ejemplo 2

Oracle:
SELECT Region_Name || ' ' || Store_Name FROM Geography
WHERE Store_Name = 'Boston';

24
Resultado:
'East Boston'

Ejemplo 3

SQL Server:
SELECT Region_Name + ' ' + Store_Name FROM Geography
WHERE Store_Name = 'Boston';

Resultado:
'East Boston'

SQL > SQL Sintaxis

En esta página, enumeramos la sintaxis SQL para cada uno de los comandos SQL en esta guía de referencia. Para obtener explicaciones detalladas para cada sintaxis SQL, por
favor diríjase a la sección individual haciendo clic en la palabra clave.

El propósito de esta página es brindar una página de referencia rápida para la sintaxis SQL. Le sugerimos que agregue esta página a favoritos ahora presionando Control-D para
que pueda tener esta página de sintaxis a mano.

Select
SELECT "nom de colonne" FROM "nombre_tabla";

Distinct
SELECT DISTINCT "nombre_columna"
FROM "nombre_tabla";

Where
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "condition";

And/Or
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "condición simple"
{[AND|OR] "condición simple"}+;

25
In
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "nombre_columna" IN ('valor1', 'valor2', ...);

Between
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "nombre_columna" BETWEEN 'valor1' AND 'valor2';

Like
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "nombre_columna" LIKE {patrón};

Order By
SELECT "nombre_columna"
FROM "nombre_tabla"
[WHERE "condición"]
ORDER BY "nombre_columna" [ASC, DESC];

Count
SELECT COUNT("nombre_columna")
FROM "nombre_tabla";

Group By
SELECT "nombre_columna 1", SUM("nombre_columna 2")
FROM "nombre_tabla"
GROUP BY "nombre_columna 1";

Having
SELECT "nombre_columna 1", SUM("nombre_columna 2")
FROM "nombre_tabla"
GROUP BY "nombre_columna 1"
HAVING (condición de función aritmética);

Create Table
CREATE TABLE "nombre_tabla"
("columna 1" "tipo_de_datos_para_columna_1",

26
"columna 2" "tipo_de_datos_para_columna_2",
... );

Drop Table
DROP TABLE "nombre_tabla";

Truncate Table
TRUNCATE TABLE "nombre_tabla";

Insert Into
INSERT INTO "nombre_tabla" ("colonne 1", "colonne 2", ...)
VALUES ("valor 1", "valor 2", ...);

Update
UPDATE "nombre_tabla"
SET "colonne 1" = [nuevo valor]
WHERE "condición";

Delete From
DELETE FROM "nombre_tabla"
WHERE "condición";

27
Ejercicio: Desarrolle la siguiente Bases de Datos con en nombre de Ventas.

28