Documentos de Académico
Documentos de Profesional
Documentos de Cultura
Diciembre, 2011.
Guía Rápida SQL
CONTENIDO
INTRODUCCION ....................................................................................................................... 4
SQL IN .................................................................................................................................................... 8
SQL INTERSECT..................................................................................................................................... 26
Página 2
Guía Rápida SQL
SQL CASE.............................................................................................................................................. 30
SQL UPDATE......................................................................................................................................... 44
Página 3
Guía Rápida SQL
INTRODUCCION
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:
Página 4
Guía Rápida SQL
COMANDOS SQL
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. Por lo tanto tenemos la estructura SQL más básica:
Tabla Store_Information
Resultado:
store_name
Los Angeles
San Diego
Los Angeles
Boston
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 los elementos que son distintos. Esto es fácil de
realizar en SQL. Todo lo que necesitamos hacer es agregar DISTINCT luego de SELECT. La
sintaxis es la siguiente:
Página 5
Guía Rápida SQL
Por ejemplo, para seleccionar todos los negocios distintos en la Tabla Store_Information,
Tabla Store_Information
Ingresamos,
Resultado:
store_name
Los Angeles
San Diego
Boston
SQL WHERE
Si se desea condicionalmente los datos de una tabla. Por ejemplo, podríamos desear sólo
recuperar los negocios con ventas mayores a 1000 USD. Para ello, utilizamos la palabra clave
WHERE. La sintaxis es la siguiente:
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "condición"
Por ejemplo, para seleccionar todos los negocios con ventas mayores a 1000 USD dólares
estadounidenses en la Tabla Store_Information,
Tabla Store_Information
Página 6
Guía Rápida SQL
Ingresamos,
SELECT store_name
FROM Store_Information
WHERE Sales > 1000
Resultado:
store_name
Los Angeles
SQL AND, OR
La palabra clave WHERE también puede utilizarse para seleccionar datos condicionalmente
desde una tabla. Esta condición puede ser una condición simple, o puede ser una condición
compuesta. Las condiciones compuestas están formadas por múltiples condiciones simples
conectadas por AND u OR.
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 USD
o todos los negocios con ventas menores a 500 USD pero mayores a 275 USD en la Tabla
Store_Information,
Tabla Store_Information
Ingresamos,
SELECT store_name
FROM Store_Information
WHERE Sales > 1000
OR (Sales < 500 AND Sales > 275)
Página 7
Guía Rápida SQL
Resultado:
store_name
Los Angeles
San Francisco
SQL IN
El uso de la palabra clave IN, está relacionado con la cláusula WHERE. Cuando se 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
Por ejemplo, podríamos desear seleccionar todos los registros para los negocios de Los
Ángeles y San Diego en la Tabla Store_Information,
Tabla Store_Information
Ingresamos,
SELECT *
FROM Store_Information
WHERE store_name IN ('Los Angeles', 'San Diego')
Resultado:
Página 8
Guía Rápida SQL
SQL BETWEEN
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'.
Tabla Store_Information
Ingresamos,
SELECT *
FROM Store_Information
WHERE Date BETWEEN '06-Jan-1999' AND '10-Jan-1999'
Resultado:
SQL LIKE
LIKE es otra palabra clave que se utiliza en la cláusula WHERE. Básicamente, LIKE 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}
Página 9
Guía Rápida SQL
'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.
Tabla Store_Information
Deseamos encontrar todos los negocios cuyos nombres contengan ‘AN’. Para hacerlo,
ingresamos,
SELECT *
FROM Store_Information
WHERE store_name LIKE '%AN%'
Resultado:
SQL ORDER BY
Con frecuencia, se necesita 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, se utiliza la palabra clave ORDER BY para alcanzar nuestra meta.
Página 10
Guía Rápida SQL
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 BY ASC 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
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
Ingresamos,
Resultado:
Página 11
Guía Rápida SQL
SQL FUNCIONES
- AVG
- COUNT
- MAX
- MIN
- SUM
Por ejemplo, si deseamos obtener la sumatoria de todas las ventas de la siguiente tabla,
Tabla Store_Information
Ingresaríamos
Resultado:
SUM(Sales)
2750 USD
2 750 USD 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 (-).
Página 12
Guía Rápida SQL
Otra función aritmética es COUNT. Esto nos permite contar el número de filas en una tabla
determinada. La sintaxis es,
SELECT COUNT("nombre_columna")
FROM "nombre_columna"
Tabla Store_Information
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,
Resultado:
Count(DISTINCT store_name)
3
SQL GROUP BY
Regresamos a las funciones de agregados. Ya se utilizó 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:
Página 13
Guía Rápida SQL
Segundo, debemos asegurarnos de que todas las sumas de las ventas estén GROUP
BY negocios.
Tabla Store_Information
Deseamos saber las ventas totales para cada negocio. Por lo que la sintaxis correcta es,
Resultado:
store_name SUM(Sales)
Los Angeles 1800 USD
San Diego 250 USD
Boston> 700 USD
SQL HAVING
Para limitar el resultado de cualquier otra función de agregado se utiliza la palabra reservada
HAVING. Por ejemplo, podríamos desear ver sólo los negocios con ventas mayores a 1 500
USD. En vez de utilizar la cláusula WHERE en la instrucción SQL, a pesar de que necesitemos
utilizar la cláusula HAVING, que 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,
Página 14
Guía Rápida SQL
Tabla Store_Information
Ingresaríamos,
Resultado:
store_name SUM(Sales)
Los Angeles 1800 USD
SQL 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áusula FROM. 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.
Antes de comenzar con las uniones, miremos la sintaxis tanto para el alias de columna como
de tabla:
Página 15
Guía Rápida SQL
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
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:
Resultado:
SQL JOIN
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
Página 16
Guía Rápida SQL
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 tabla Store_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”.
Resultado:
REGIÓN SALES
East 700 USD
West 2050 USD
Las primeras dos líneas le indican a SQL que seleccione dos campos, el primero es el campo
"nombre_región" de la tabla Geography (denominado REGIÓN), 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í: Geografía se denomina A1, e Información_Negocio se denomina A2. Sin
los alias, la primera línea sería
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.
Página 17
Guía Rápida SQL
Ya se ha visto una unión por la 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.
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.
Tabla Store_Information
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 “Nueva 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:
Note que en este caso, estamos utilizando la sintaxis Oracle para unión externa.
Resultado:
store_name SALES
Boston 700 USD
New York
Página 18
Guía Rápida SQL
Nota: Se devuelve NULL cuando no hay coincidencia en la segunda tabla. En este caso,
“Nueva York" no aparece en la tabla Store_Information, por lo tanto su columna "SALES"
correspondiente es NULL.
SQL Concatenar
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: +
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 '||'.
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';
Página 19
Guía Rápida SQL
Resultado :
'East Boston'
Ejemplo 3:
SQL Server:
SELECT region_name + ' ' + store_name FROM Geography
WHERE store_name = 'Boston';
Resultado :
'East Boston'
SQL SUBSTRING
La función de subcadena en SQL se utiliza para tomar una parte de los datos almacenados.
Esta función tiene diferentes nombres según las diferentes bases de datos:
Los usos más frecuentes son los siguientes (utilizaremos SUBSTR() aquí):
SUBSTR(str,pos): Selecciona todos los caracteres de <str> comenzando con posición <pos>.
Note que esta sintaxis no es compatible en SQL Server.
Tabla Geography
region_name store_name
East Boston
East New York
West Los Angeles
West San Diego
Ejemplo 1 :
SELECT SUBSTR(store_name, 3)
FROM Geography
WHERE store_name = 'Los Angeles';
Resultado :
Página 20
Guía Rápida SQL
's Angeles'
Ejemplo 2 :
SELECT SUBSTR(store_name,2,4)
FROM Geography
WHERE store_name = 'San Diego';
Resultado :
'an D'
SQL TRIM
La función TRIM en SQL se utiliza para eliminar un prefijo o sufijo determinado de una cadena.
El patrón más común a eliminarse son los espacios en blanco. Esta función tiene diferentes
nombres según las diferentes bases de datos:
Ejemplo 1:
Resultado:
'Sample'
Ejemplo 2:
Resultado:
'Sample '
Ejemplo 3:
Página 21
Guía Rápida SQL
Resultado:
' Sample'
Página 22
Guía Rápida SQL
SQL Avanzado
SQL UNION
El comando SQL UNION es combinar los resultados de dos consultas juntas. En este sentido,
UNION es parecido a JOIN, ya que los dos se utilizan para información relacionada en
múltiples tablas. Una restricción de UNION es que todas las columnas correspondientes
necesitan ser del mismo tipo de datos. También, cuando utilizamos UNION, sólo se
seleccionan valores distintos (similar a SELECT DISTINCT).
La sintaxis es la siguiente:
[Instrucción SQL 1]
UNION
[Instrucción SQL 2]
Tabla Store_Information
Tabla Internet_Sales
Date Sales
Página 23
Guía Rápida SQL
y deseamos saber de todas las fechas donde hay una operación de venta. Para hacerlo,
utilizamos la siguiente instrucción SQL:
Resultado:
Date
05-Jan-1999
07-Jan-1999
08-Jan-1999
10-Jan-1999
11-Jan-1999
12-Jan-1999
Por favor note que si ingresamos " SELECT DISTINCT Date" para cada o ambas instrucciones
SQL, obtendremos el mismo conjunto de resultados.
El propósito del Comando SQL UNION ALL es también combinar los resultados de dos
consultas juntas. La diferencia entre UNION ALL y UNION es que, mientras UNION sólo
selecciona valores distintos, UNION ALL selecciona todos los valores.
[Instrucción SQL 1]
UNION ALL
[Instrucción SQL 2]
Utilicemos el mismo ejemplo de la sección anterior para ilustrar la diferencia. Supongamos que
tenemos las siguientes dos tablas,
Tabla Store_Information
Página 24
Guía Rápida SQL
Tabla Internet_Sales
Date Sales
y deseamos encontrar las fechas en donde se realizó una operación de venta en un negocio
como así también las fechas donde hay una venta a través de Internet. Para hacerlo, utilizamos
la siguiente instrucción SQL:
Resultado:
Date
05-Jan-1999
07-Jan-1999
08-Jan-1999
08-Jan-1999
07-Jan-1999
10-Jan-1999
11-Jan-1999
Página 25
Guía Rápida SQL
12-Jan-1999
SQL INTERSECT
La sintaxis es la siguiente:
[Instrucción SQL 1]
INTERSECT
[Instrucción SQL 2]
Tabla Store_Information
Tabla Internet_Sales
Date Sales
y deseamos encontrar todas las fechas donde hay ventas tanto en el negocio como en Internet.
Para hacerlo, utilizamos la siguiente instrucción SQL:
Página 26
Guía Rápida SQL
Resultado:
Date
07-Jan-1999
Por favor note que el comando INTERSECT sólo arrojará valores distintivos.
SQL MINUS
MINUS opera en dos instrucciones SQL. Toma todos los resultados de la primera instrucción
SQL, y luego sustrae aquellos que se encuentran presentes en la segunda instrucción SQL
para obtener una respuesta final. Si la segunda instrucción SQL incluye resultados que no
están presentes en la primera instrucción SQL, dichos resultados se ignoran.
La sintaxis es la siguiente:
[Instrucción SQL 1]
MINUS
[Instrucción SQL 2]
Tabla Store_Information
Tabla Internet_Sales
Date Sales
07-Jan-1999 250 USD
10-Jan-1999 535 USD
11-Jan-1999 320 USD
12-Jan-1999 750 USD
Página 27
Guía Rápida SQL
y deseamos encontrar todas las fechas donde hay ventas en el negocio, pero no aquellas
realizadas por Internet. Para hacerlo, utilizamos la siguiente instrucción SQL:
Resultado:
Date
05-Jan-1999
08-Jan-1999
Por favor note que el comando MINUS sólo arrojará valores distintos.
SQL Subconsulta
Es posible incorporar una instrucción SQL dentro de otra. Cuando esto se hace en las
instrucciones WHERE o HAVING, tenemos una construcción de subconsulta.
La sintaxis es la siguiente:
SELECT "nombre1_columna"
FROM "nombre1_tabla"
WHERE "nombre2_columna" [Operador de Comparación]
(SELECT "nombre3_columna"
FROM "nombre2_tabla"
WHERE [Condición])
[Operador de Comparación] podrían ser operadores de igualdad tales como =, >, <, >=, <=.
También puede ser un operador textual como "LIKE". La parte en rojo se considera como la
"consulta interna", mientras que la parte en verde se considera como la "consulta externa".
Table Store_Information
Página 28
Guía Rápida SQL
Table Geography
region_name store_name
East Boston
East New York
West Los Angeles
West San Diego
Si se requiere tener el importe de las ventas de las tiendas que se encuentren en la región
Oeste, se tiene la siguiente sentencia SQL:
Resultado:
SUM(Sales)
2050
SQL EXISTS
EXISTS es un operador que simplemente verifica si la consulta interna arroja alguna fila. Si lo
hace, entonces la consulta externa procede. De no hacerlo, la consulta externa no se ejecuta, y
la totalidad de la instrucción SQL no arroja nada.
SELECT "nombre1_columna"
FROM "nombre1_tabla"
WHERE EXISTS
(SELECT *
FROM "nombre2_tabla"
WHERE [Condición])
Por favor note que en vez de *, puede seleccionar una o más columnas en la consulta interna.
El efecto será idéntico.
Tabla Store_Information
Página 29
Guía Rápida SQL
Tabla Geography
region_name store_name
East Boston
East New York
West Los Angeles
West San Diego
La siguiente consulta SQL muestra la información de las ventas solo de aquelas tiendas que se
encuentren asignadas a una región :
SUM(Sales)
2750
Al principio, esto puede parecer confuso, debido a que la subsequencia incluye la condición
[region_name = 'West'], aun así la consulta sumó los negocios para todas las regiones. Si
observamos de cerca, encontramos que debido a que la subconsulta arroja más de 0 filas, la
condición EXISTS es verdadera, y la condición colocada dentro de la consulta interna no
influencia la forma en que se ejecuta la consulta externa.
SQL CASE
CASE se utiliza para brindar un tipo de lógica "si-entonces-otro" para SQL. Su sintaxis es:
Página 30
Guía Rápida SQL
"condición" puede ser un valor estático o una expresión. La cláusula ELSE es opcional.
Tabla Store_Information
si deseamos multiplicar las sumas de ventas de 'Los Angeles' por 2 y las sumas de ventas de
'San Diego' por 1,5, ingresamos,
Resultado:
Página 31
Guía Rápida SQL
MANIPULACION DE TABLAS
CREACION TABLAS
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 cuáles 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.
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.
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).
Entonces, si debemos crear una tabla para el cliente tal como se especifica anteriormente,
ingresaríamos
Página 32
Guía Rápida SQL
SQL CONSTRAINT
Las 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ón ALTER
TABLE.
- NOT NULL
- UNIQUE
- CHECK
- Clave primaria
- Clave externa
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.
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.
Página 33
Guía Rápida SQL
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.
CHECK
La restricción CHECK asegura que todos los valores en una columna cumplan ciertas
condiciones.
PRIMARY KEY
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).
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,
Last_Name varchar(30),
First_Name varchar(30));
Página 34
Guía Rápida SQL
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.
Una foreign key es un campo (o campos) que señala la primary key de otra tabla. El propósito
de la foreign key 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 ÓRDENES que 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 foreign key 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 un
CUSTOMER 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.
Tabla CUSTOMER
Tabla ORDERS
Página 35
Guía Rápida SQL
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);
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);
SQL Server:
ALTER TABLE ORDERS
ADD FOREIGN KEY (customer_sid) REFERENCES CUSTOMER(SID);
Las vistas pueden considerarse como tablas virtuales. Generalmente hablando, una tabla tiene
un conjunto de definiciones, y almacena datos físicamente. Una vista también tiene un conjunto
de definiciones, que se construye en la parte superior de la(s) tabla(s) u otra(s) vista(s), y no
almacena datos físicamente.
Página 36
Guía Rápida SQL
La “Instrucción SQL” puede ser cualquiera de las instrucciones SQL que hemos descripto en
esta guía de referencia.
Utilicemos un ejemplo simple para ilustrar. Supongamos que tenemos la siguiente tabla:
Tabla Customer
(First_Name char(50),
Last_Name char(50),
Address char(50),
City char(50),
Country char(25),
Birth_Date date)
y deseamos crear una vista denominada V_Customer que contiene sólo las columnas
First_Name, Last_Name y País de esta tabla, ingresaríamos
View V_Customer
(First_Name char(50),
Last_Name char(50),
Country char(25))
Podemos utilizar también una vista para aplicar uniones a dos tablas. En este caso, los
usuarios sólo ven una vista en vez de dos tablas, y la instrucción SQL que los usuarios
necesitan emitir se vuelve mucho más simple. Digamos que tenemos las siguientes dos tablas:
Tabla Store_Information
Tabla Geography
region_name store_name
East Boston
East New York
West Los Angeles
West San Diego
y deseamos construir una vista que tenga ventas organizadas según la región. Colocaríamos la
siguiente instrucción SQL:
Página 37
Guía Rápida SQL
Esto nos brinda una vista, V_REGION_SALES, que se ha definido para las ventas de los
negocios según los registros de la región. Si deseamos saber el contenido de esta vista,
ingresamos,
Resultado:
REGION SALES
East 700 USD
West 2050 USD
Los índices nos ayudan a obtener datos de las tablas en forma más rápida. Sin un índice, el
sistema de base de datos lee a través de toda la tabla (este proceso se denomina “escaneo de
tabla”) para localizar la información deseada. Con el índice correcto en su lugar, el sistema de
base de datos puede entonces primero dirigirse al índice para encontrar de dónde obtener los
datos, y luego dirigirse a dichas ubicaciones para obtener los datos necesarios. Esto es mucho
más rápido.
Por lo tanto, generalmente se recomienda crear índices en tablas. Un índice puede cubrir una o
más columnas. La sintaxis general para la creación de un índice es:
Tabla Customer
(First_Name char(50),
Last_Name char(50),
Address char(50),
City char(50),
Country char(25),
Birth_Date date)
Página 38
Guía Rápida SQL
No hay una regla estricta respecto de cómo nombrar un índice. El método generalmente
aceptado es colocar un prefijo, tal como “IDX_”, antes del nombre de un índice para evitar la
confusión con otros objetos de la base de datos. También es una buena idea brindar
información sobre qué tabla y columna(s) se utilizará el índice.
La sintaxis exacta para CREATE INDEX puede ser distinta según las diferentes bases de
datos. Debería consultar con su manual de referencia de base de datos para obtener la sintaxis
precisa.
Una vez que se crea la tabla en la base de datos, hay muchas ocasiones donde uno puede
desear cambiar la estructura de la tabla. Los casos típicos incluyen los siguientes:
Por favor note que lo anterior no es una lista exhaustiva. Hay otras instancias donde ALTER
TABLE se utiliza para cambiar la estructura de la tabla, tales como cambiar la especificación de
la clave primaria o agregar una restricción única para una columna.
[modificar especificación] depende del tipo de modificación que deseamos realizar. Para los
usos mencionados anteriormente, las instrucciones [modificar especificación] son:
Tabla customer
First_Name char(50)
Last_Name char(50)
Página 39
Guía Rápida SQL
Address char(50)
City char(50)
Country char(25)
Birth_Date date
Primero, deseamos agregar una columna denominada “Gender” a esta tabla. Para hacerlo,
ingresamos,
Table customer
First_Name char(50)
Last_Name char(50)
Address char(50)
City char(50)
Country char(25)
Birth_Date date
Gender char(1)
Table customer
First_Name char(50)
Página 40
Guía Rápida SQL
Last_Name char(50)
Addr char(50)
City char(50)
Country char(25)
Birth_Date Date
Gender char(1)
Luego, lo que queremos es cambiar el tipo de datos para “Addr” a 30 caracteres. Para hacerlo,
ingresamos,
Table customer
First_Name char(50)
Last_Name char(50)
Addr char(30)
City char(50)
Country char(25)
Birth_Date date
Gender char(1)
Table customer
Página 41
Guía Rápida SQL
First_Name char(50)
Last_Name char(50)
Addr char(30)
City char(50)
Country char(25)
Birth_Date date
Para eliminar una tabla en la base de datos por alguna razón, SQL nos permite hacerlo,
utilizando el comando DROP TABLE. La sintaxis para DROP TABLE es
Entonces, si deseamos eliminar una tabla denominada cliente que creamos en la sección
CREATE TABLE, simplemente ingresamos
Para eliminar los datos en una tabla. Una forma de hacer esto es con DROP TABLE, pero ¿Si
deseamos simplemente deshacernos de los datos pero no de la tabla, podemos utilizar el
comando TRUNCATE TABLE. La sintaxis para TRUNCATE TABLE es
Entonces, si deseamos truncar una tabla denominada cliente que creamos en SQL CREATE
TABLE, simplemente ingresamos
Página 42
Guía Rápida SQL
Para ingresar filas de datos en alguna tabla, se utiliza la instrucción INSERT. En SQL, hay
básicamente dos formas para insertar datos en una tabla: Una es insertar una fila por vez, y la
otra es insertar filas múltiples por vez.
La sintaxis para insertar datos en una tabla mediante una fila por vez es la siguiente:
Tabla Store_Information
store_name char(50)
Sales float
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 USD en ventas.
Por lo tanto, utilizaremos la siguiente escritura SQL:
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:
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 table, ingresaremos:
Página 43
Guía Rápida SQL
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 (date,'yyyy')=1998.
SQL UPDATE
UPDATE "nombre_tabla"
SET "columna_1" = [nuevo valor]
WHERE {condición}
Tabla Store_Information
y notamos que las ventas para Los Angeles el 08/01/1999 es realmente de 500 USD en vez de
300 USD, 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 Date = "08-Jan-1999"
Página 44
Guía Rápida SQL
Tabla Store_Information
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}
A veces podemos desear deshacernos de los registros de una tabla. Para ello, utilizamos el
comando DELETE FROM. La sintaxis para esto es,
Es más fácil utilizar un ejemplo. Por ejemplo, digamos que actualmente tenemos la siguiente
tabla:
Tabla Store_Information
Página 45
Guía Rápida SQL
y decidimos no mantener ninguna información sobre Los Ángeles en esta tabla. Para lograrlo,
ingresamos el siguiente SQL:
Tabla Store_Information
Página 46
Guía Rápida SQL
SQL SINTAXIS
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"}+
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"
Página 47
Guía Rápida SQL
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",
"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", ...)
valorS ("valor 1", "valor 2", ...)
Update
UPDATE "nombre_tabla"
SET "colonne 1" = [nuevo valor]
WHERE {condition}
Delete From
DELETE FROM "nombre_tabla"
WHERE {condición}
Página 48