Este documento describe la evolución del lenguaje SQL y sus características. Comienza explicando los orígenes de SQL como un lenguaje para bases de datos relacionales y su evolución a través de varios estándares como SQL-86, SQL-92 y SQL-2003. Luego describe las características generales de SQL y los diferentes tipos de lenguajes como DDL para definir datos, DML para manipular datos e inserciones avanzadas de múltiples filas.

1. UNIVERSIDADVERACRUZANA
FACULTADDEADMINISTRACIÓN
LIC.SISTEMAS COMPUTACIONALES ADMINISTRATIVOS
CATEDRÁTICO
DR.CARLOSARTURO TORRESGASTELÚ
TEMA:
EVOLUCIÓN DELANSISQL
EQUIPO 3:
BAIZABAL LAGUNES KARINA
HERNÁNDEZ PAXTIAN GABRIELA
EXPERIENCIA EDUCATIVA
BASEDEDATOS

2. ÍNDICE.
ÍNDICE...........................................................................................Error! Bookmark not defined.
INTRODUCCIÓN......................................................................................................................... 3
SQL........................................................................................................................................... 4
ORÍGENES Y EVOLUCIÓN............................................................................................................ 4
CARACTERÍSTICAS GENERALES DEL SQL. ..................................................................................... 6
OPTIMIZACIÓN.......................................................................................................................... 6
LENGUAJE DE DEFINICIÓN DE DATOS (DDL) ................................................................................ 6
CREATE................................................................................................................................. 7
ALTER ................................................................................................................................... 7
DROP.................................................................................................................................... 8
TRUNCATE ............................................................................................................................ 8
LENGUAJE DE MANIPULACIÓN DE DATOS DML (DATA MANIPULATION LANGUAJE)....................... 8
INSERT.................................................................................................................................. 9
FORMAS AVANZADAS................................................................................................................ 9
INSERCIONES EN MÚLTIPLES FILAS ......................................................................................... 9
COPIA DE FILAS DE OTRAS TABLAS.........................................................................................11
DELETE.................................................................................................................................12
RECUPERACIÓN DE CLAVE.........................................................................................................12
DISPARADORES........................................................................................................................13
ÉSTANDARES ANSI SQL.............................................................................................................13
SQL-89.................................................................................................................................13
SQL-92.................................................................................................................................14
SQL 3 ...................................................................................................................................22
CONCLUSIÓN. ..........................................................................................................................24
BIBLIOGRAFÍA. .........................................................................................................................24

3. INTRODUCCIÓN.
El lenguaje de consulta estructurado (SQL) es un lenguaje de base de datos
normalizado, utilizado por los diferentes motores de bases de datos para realizar
determinadas operaciones sobre los datos o sobre la estructura de los mismos.
Pero como sucede con cualquier sistema de normalización hay excepciones para
casi todo; de hecho, cada motor de bases de datos tiene sus peculiaridades y lo
hace diferente de otro motor, por lo tanto, el lenguaje SQL normalizado (ANSI) no
nos servirá para resolver todos los problemas, aunque si se puede asegurar que
cualquier sentencia escrita en ANSI será interpretable por cualquier motor de
datos

4. SQL.
El lenguaje de consulta estructurado o SQL (por sus siglas en inglés Structured
Query Language) es un lenguaje declarativo de acceso a bases de datos
relacionales que permite especificar diversos tipos de operaciones en éstas. Una
de sus características es el manejo del álgebra y el cálculo relacional permitiendo
efectuar consultas con el fin de recuperar -de una forma sencilla- información de
interés de una base de datos, así como también hacer cambios sobre ella. Es un
lenguaje informático de cuarta generación (4GL).
.
ORÍGENES Y EVOLUCIÓN.
Los orígenes del SQL están ligados a los de las bases de datos relacionales. En
1970 E. F. Codd propone el modelo relacional y asociado a éste un sublenguaje
de acceso a los datos basado en el cálculo de predicados. Basándose en estas
ideas, los laboratorios de IBM definen el lenguaje SEQUEL (Structured English
Query Language) que más tarde sería ampliamente implementado por el sistema
de gestión de bases de datos experimental System R, desarrollado en 1977
también por IBM. Sin embargo, fue Oracle quien lo introdujo por primera vez en
1979 en un programa comercial.
El SEQUEL terminaría siendo el predecesor de SQL, siendo éste una versión
evolucionada del primero. El SQL pasa a ser el lenguaje por excelencia de los
diversos sistemas de gestión de bases de datos relacionales surgidos en los años
siguientes y es por fin estandarizado en 1986 por el ANSI, dando lugar a la
primera versión estándar de este lenguaje, el "SQL-86" o "SQL1". Al año siguiente
este estándar es también adoptado por la ISO.
Sin embargo, este primer estándar no cubre todas las necesidades de los
desarrolladores e incluye funcionalidades de definición de almacenamiento que se
consideraron suprimir. Así que en 1992 se lanza un nuevo estándar ampliado y
revisado del SQL llamado "SQL-92" o "SQL2".
En la actualidad el SQL es el estándar de facto de la inmensa mayoría de los
SGBD comerciales. Y, aunque la diversidad de añadidos particulares que incluyen
las distintas implementaciones comerciales del lenguaje es amplia, el soporte al
estándar SQL-92 es general y muy amplio.
El ANSI SQL sufrió varias revisiones y agregados a lo largo del tiempo:

5. Año Nombre Alias Comentarios
1986 SQL-86 SQL-87 Primera publicación hecha por ANSI. Confirmada
por ISO en 1987.
1989 SQL-89 Revisión menor.
1992 SQL-92 SQL2 Revisión mayor.
1999 SQL:1999 SQL2000 Se agregaron expresiones regulares, consultas
recursivas (para relaciones jerárquicas), triggers y
algunas características orientadas a objetos.
2003 SQL:2003 Introduce algunas características de XML, cambios
en las funciones, estandarización del objeto
sequence y de las columnas auto numéricas. (Ver
Eisenberg et al.: SQL:2003 Has Been Published.)
2006 SQL:2006 ISO/IEC 9075-14:2006 Define las maneras en las
cuales el SQL se puede utilizar conjuntamente con
XML. Define maneras importar y guardar datos
XML en una base de datos SQL, manipulándolos
dentro de la base de datos y publicando el XML y
los datos SQL convencionales en forma XML.
Además, proporciona facilidades que permiten a las
aplicaciones integrar dentro de su código SQL el
uso de XQuery, lenguaje de consulta XML
publicado por el W3C (World Wide Web
Consortium) para acceso concurrente a datos
ordinarios SQL y documentos XML.
2008 SQL:2008 Permite el uso de la cláusula ORDER BY fuera de
las definiciones de los cursores. Incluye los
disparadores del tipo INSTEAD OF. Añade la
sentencia TRUNCATE.

6. CARACTERÍSTICAS GENERALES DEL SQL.
El SQL es un lenguaje de acceso a bases de datos que explota la flexibilidad y
potencia de los sistemas relacionales permitiendo gran variedad de operaciones
en éstos últimos.
Es un lenguaje declarativo de "alto nivel" o "de no procedimiento", que gracias a
su fuerte base teórica y su orientación al manejo de conjuntos de registros, y no a
registros individuales, permite una alta productividad en codificación y la
orientación a objetos. De esta forma una sola sentencia puede equivaler a uno o
más programas que se utilizarían en un lenguaje de bajo nivel orientado a
registros.
OPTIMIZACIÓN.
Como ya se dijo arriba, y suele ser común en los lenguajes de acceso a bases de
datos de alto nivel, el SQL es un lenguaje declarativo. O sea, que especifica qué
es lo que se quiere y no cómo conseguirlo, por lo que una sentencia no establece
explícitamente un orden de ejecución.
El orden de ejecución interno de una sentencia puede afectar gravemente a la
eficiencia del SGBD, por lo que se hace necesario que éste lleve a cabo una
optimización antes de su ejecución. Muchas veces, el uso de índices acelera una
instrucción de consulta, pero ralentiza la actualización de los datos. Dependiendo
del uso de la aplicación, se priorizará el acceso indexado o una rápida
actualización de la información. La optimización difiere sensiblemente en cada
motor de base de datos y depende de muchos factores.
Existe una ampliación de SQL conocida como FSQL (Fuzzy SQL, SQL difuso) que
permite el acceso a bases de datos difusas, usando la lógica difusa. Este lenguaje
ha sido implementado a nivel experimental y está evolucionando rápidamente.
LENGUAJE DE DEFINICIÓN DE DATOS (DDL)
El lenguaje de definición de datos (en inglés Data Definition Language, o DDL), es
el que se encarga de la modificación de la estructura de los objetos de la base de
datos. Existen cuatro operaciones básicas: CREATE, ALTER, DROP y
TRUNCATE.

7. CREATE
Este comando crea un objeto dentro de la base de datos. Puede ser una tabla,
vista, índice, trigger, función, procedimiento o cualquier otro objeto que el motor de
la base de datos soporte.
Ejemplo (crear una tabla)
CREATE TABLE 'TABLA_NOMBRE' (
'CAMPO_1' INT,
'CAMPO_2' STRING
FOR Example:
IF you don't eat...you well be eating.
)
Ejemplo (crear una función)
CREATE OR REPLACE FUNCTION 'NOMBRE FUNCION'('PARAMETROS')
RETURNS 'TIPO RETORNO' AS
$BODY$
begin
'INSTRUCCIÓN SQL'
--por Ejemplo:
DELETE FROM con_empleado WHERE id_empleado = ANY (ids);
end;
$BODY$
LANGUAGE 'plpgsql';
ALTER
Este comando permite modificar la estructura de un objeto. Se pueden
agregar/quitar campos a una tabla, modificar el tipo de un campo, agregar/quitar
índices a una tabla, modificar un trigger, etc.
Ejemplo (agregar columna a una tabla)
ALTER TABLE 'TABLA_NOMBRE' (
ADD NUEVO_CAMPO INT UNSIGNED meel
)

8. DROP
Este comando elimina un objeto de la base de datos. Puede ser una tabla, vista,
índice, trigger, función, procedimiento o cualquier otro objeto que el motor de la
base de datos soporte. Se puede combinar con la sentencia ALTER.
Ejemplo
ALTER TABLE ''TABLA_NOMBRE''
(
DROP COLUMN ''CAMPO_NOMBRE1''
TRUNCATE
Este comando trunca todo el contenido de una tabla. La ventaja sobre el comando
DROP, es que si se quiere borrar todo el contenido de la tabla, es mucho más
rápido, especialmente si la tabla es muy grande. La desventaja es que
TRUNCATE sólo sirve cuando se quiere eliminar absolutamente todos los
registros, ya que no se permite la cláusula WHERE. Si bien, en un principio, esta
sentencia parecería ser DML (Lenguaje de Manipulación de Datos), es en realidad
una DDL, ya que internamente, el comando TRUNCATE borra la tabla y la vuelve
a crear y no ejecuta ninguna transacción.
Ejemplo
TRUNCATE TABLE ''TABLA_NOMBRE1''
LENGUAJE DE MANIPULACIÓN DE DATOS DML (DATA MANIPULATION
LANGUAJE)
Un lenguaje de manipulación de datos (Data Manipulation Language, o DML en
inglés) es un lenguaje proporcionado por el sistema de gestión de base de datos
que permite a los usuarios llevar a cabo las tareas de consulta o manipulación de
los datos, organizados por el modelo de datos adecuado.
El lenguaje de manipulación de datos más popular hoy día es SQL, usado para
recuperar y manipular datos en una base de datos relacional. Otros ejemplos de
DML son los usados por bases de datos IMS/DL1, CODASYL u otras.

9. INSERT
Una sentencia INSERT de SQL agrega uno o más registros a una (y sólo una)
tabla en una base de datos relacional.
Forma básica
INSERT INTO ''tabla'' (''columna1'', [''columna2,... '']) VALUES (''valor1'',
[''valor2,...''])
Las cantidades de columnas y valores deben ser iguales. Si una columna no se
especifica, le será asignado el valor por omisión. Los valores especificados (o
implícitos) por la sentencia INSERT deberán satisfacer todas las restricciones
aplicables. Si ocurre un error de sintaxis o si alguna de las restricciones es violada,
no se agrega la fila y se devuelve un error.
Ejemplo
INSERT INTO agenda_telefonica (nombre, numero) VALUES ('Roberto Jeldrez',
4886850);
Cuando se especifican todos los valores de una tabla, se puede utilizar la
sentencia acortada:
INSERT INTO ''tabla'' VALUES (''valor1'', [''valor2,...''])
Ejemplo (asumiendo que 'nombre' y 'número' son las únicas columnas de la tabla
'agenda_telefonica'):
INSERT INTO agenda_telefonica VALUES ('Roberto Jeldrez', 4886850);
FORMAS AVANZADAS
INSERCIONES EN MÚLTIPLES FILAS
Una característica de SQL (desde SQL-92) es el uso de constructores de filas para
insertar múltiples filas a la vez, con una sola sentencia SQL:
INSERT INTO ''tabla'' (''columna1'', [''columna2,... ''])
VALUES (''valor1a'', [''valor1b,...'']), (''value2a'', [''value2b,...'']),...
Esta característica es soportada por DB2, PostgreSQL (desde la versión 8.2),
MySQL, y H2.

10. Ejemplo (asumiendo que 'nombre' y 'número' son las únicas columnas en la tabla
'agenda_telefonica'):
INSERT INTO agenda_telefonica VALUES ('Roberto Fernández', '4886850'),
('Alejandro Sosa', '4556550');
Que podía haber sido realizado por las sentencias:
INSERT INTO agenda_telefonica VALUES ('Roberto Fernández', '4886850');
INSERT INTO agenda_telefonica VALUES ('Alejandro Sosa', '4556550');
Notar que las sentencias separadas pueden tener semántica diferente
(especialmente con respecto a los triggers), y puede tener diferente rendimiento
que la sentencia de inserción múltiple.
Para insertar varias filas en MS SQL puede utilizar esa construcción:
INSERT INTO phone_book
SELECT 'John Doe', '555-1212'
UNION ALL
SELECT 'Peter Doe', '555-2323';
Tenga en cuenta que no se trata de una sentencia SQL válida de acuerdo con el
estándar SQL (SQL: 2003), debido a la cláusula subselect incompleta.
Para hacer lo mismo en Oracle se usa DUAL TABLE, siempre que se trate de solo
una simple fila:
INSERT INTO phone_book
SELECT 'John Doe', '555-1212' FROM DUAL
UNION ALL
SELECT 'Peter Doe','555-2323' FROM DUAL
Una implementación conforme al estándar de esta lógica se muestra el siguiente
ejemplo, o como se muestra arriba (no aplica en Oracle):
INSERT INTO phone_book
SELECT 'John Doe', '555-1212' FROM LATERAL (VALUES (1)) AS t(c)
UNION ALL
SELECT 'Peter Doe','555-2323' FROM LATERAL (VALUES (1)) AS t(c)

11. COPIA DE FILAS DE OTRAS TABLAS.
Un INSERT también puede utilizarse para recuperar datos de otros, modificarla si
es necesario e insertarla directamente en la tabla. Todo esto se hace en una sola
sentencia SQL que no implica ningún procesamiento intermedio en la aplicación
cliente. Un SUBSELECT se utiliza en lugar de la cláusula VALUES. El
SUBSELECT puede contener JOIN, llamadas a funciones, y puede incluso
consultar en la misma TABLA los datos que se inserta. Lógicamente, el SELECT
se evalúa antes que la operación INSERT esté iniciada. Un ejemplo se da a
continuación.
INSERT INTO phone_book2
SELECT *
FROM phone_book
WHERE name IN ('John Doe', 'Peter Doe')
Una variación es necesaria cuando algunos de los datos de la tabla fuente se está
insertando en la nueva tabla, pero no todo el registro. (O cuando los esquemas de
las tablas no son iguales.)
INSERT INTO phone_book2 ([name], [phone Number] )
SELECT [name], [phone Number]
FROM phone_book
WHERE name IN ('John Doe', 'Peter Doe')
El SELECT produce una tabla (temporal), y el esquema de la tabla temporal debe
coincidir con el esquema de la tabla donde los datos son insertados.
UPDATE
Una sentencia UPDATE de SQL es utilizada para modificar los valores de un
conjunto de registros existentes en una tabla.
Forma básica
UPDATE ''tabla'' SET ''columna1'' = ‘‘valor1’’, ‘‘columna2’’ = ''valor2'',...
WHERE ''columnaN = ''valorN''
Ejemplo:
UPDATE My_table SET field1 = 'updated value' WHERE field2 = 'N';

12. DELETE
Una sentencia DELETE de SQL borra uno o más registros existentes en una tabla,
Forma básica
DELETE FROM ''tabla'' WHERE ''columna1'' = ''valor1''
Ejemplo
DELETE FROM My_table WHERE field2 = 'N';
RECUPERACIÓN DE CLAVE
Los diseñadores de base de datos que usan una clave suplente como la clave
principal para cada tabla, se ejecutará en el ocasional escenario en el que es
necesario recuperar automáticamente la base de datos, generando una clave
primaria de una sentencia SQL INSERT para su uso en otras sentencias SQL. La
mayoría de los sistemas no permiten sentencias SQL INSERT para retornar fila de
datos. Por lo tanto, se hace necesario aplicar una solución en tales escenarios.
Implementaciones comunes incluyen:
Utilizando un procedimiento almacenado especifico de base de datos que genera
la clave suplente, realice la operación INSERT, y finalmente devuelve la clave
generada.
Utilizando una sentencia SELECT específica de base de datos, sobre una tabla
temporal que contiene la última fila insertada. DB2 implementa esta característica
de la siguiente manera:
SELECT *
FROM NEW TABLE (INSERT INTO phone_book VALUES (‘Cristobal
Jeldrez',’0426.817.10.30’)) AS t
Utilizando una sentencia SELECT después de la sentencia INSERT con función
específica de base de datos, que devuelve la clave primaria generada por el
registro insertado más recientemente.
Utilizando una combinación única de elementos del original SQL INSERT en una
posterior sentencia SELECT.
Utilizando un GUID en la sentencia SQL INSERT y la recupera en una sentencia
SELECT.

13. DISPARADORES
Los disparadores, también conocidos como desencadenantes (triggers en inglés)
son definidos sobre la tabla en la que opera la sentencia INSERT, los
desencadenantes son evaluados en el contexto de la operación.
Desencadenantes BEFORE INSERT permiten la modificación de los valores que
se insertará en la tabla. Desencadenantes AFTER INSERT no puede modificar los
datos de ahora en adelante, pero se puede utilizar para iniciar acciones en otras
tablas, por ejemplo para aplicar mecanismos de auditoría.
ÉSTANDARES ANSI SQL
SQL-89
La historia de SQL (Structured Query Language) empieza en 1974 con la
definición, (por parte de Donald Chamberlin) de un lenguaje para la especificación
de las características de las bases de datos que adoptaban el modelo relacional.
Este lenguaje se llamaba SEQUEL (Structured English Query Languaje) y se
implementó en un prototipo llamado SEQUEL-XRM entre 1974 y 1975. Los
experimentos con ese prototipo condujeron, entre 1976 y 1977, a una revisión del
lenguaje (SEQUEL/2), que a partir de ese momento cambió de nombre por
motivos legales, convirtiéndose en SQL.
El prototipo (System R), basado en este lenguaje, se adoptó y utilizó internamente
en IBM y lo adoptaron algunos de sus clientes elegidos. Gracias al éxito de este
sistema, que no estaba todavía comercializado, también otras compañías
empezaron a desarrollar sus productos relacionales basados en SQL. A partir de
1981, IBM comenzó a entregar sus productos relacionales y en 1983 empezó a
vender DB2. En el curso de los años ochenta, numerosas compañías (por ejemplo
Oracle y Sybase) comercializaron productos basados en SQL, que se convierte en
el estándar industrial de hecho por lo que respectan las bases relacionales.
En 1986, el ANSI adoptó SQL (sustancialmente adoptó el dialecto SQL de IBM)
como estándar para los lenguajes relacionales y en 1987 se transformó en
estándar ISO. Esta versión del estándar tenía el nombre de SQL/86. En 1989,
ANSI definió el SQL89, basado en el anterior pero con una serie de mejoras
(definición de claves primarias, integridad de datos, etc.). Una característica
importante definida era la posibilidad de utilizarse a través de dos interfaces
interactivamente o dentro de programas de aplicación.

14. En su primera versión del SQL-89 se tienen tres partes:
Lenguaje de Definición de Datos (LDD). Contiene todas las instrucciones para
definir el esquema de una base de datos, como son: create, alter y drop.
Lenguaje de Manipulación de Datos (LMD). Contiene las instrucciones de
manejo de las tablas como son: select, insert, delete y update, y para control de
recurrencia como commit y rollback.
Lenguaje de Control de Datos (LCD). Contiene aquellas instrucciones para dar y
revocar permisos de acceso a los datos de la base de datos, como son: grant y
revoke.
Todas las instrucciones pueden ir embebidas en programas escritos en otros
lenguajes de programación, como: Cobol, Fortran, Pascal t PL/1.
Todas las sentencias SQL comienzan con un verbo, una palabra clave que
describe lo que la sentencia hace. CREATE, INSERT, DELETE, COMMIT son
verbos típicos. La sentencia continua con una o más cláusulas. Una cláusula
puede especificar los datos sobre los que debe actuar la sentencia, o proporcionar
más detalles acerca de lo que la sentencia debe hacer. Todas las cláusulas
comienzan también con una palabra clave, tal como WHERE, FROM, INTO y
HAVING. Algunas cláusulas son opcionales, otras necesarias. La estructura y
contenido específico varían de una cláusula a otra. Muchas cláusulas contienen
nombres de tablas o columnas; algunas pueden contener palabras claves
adicionales, constantes o expresiones.
SQL-92.
SQL-92 fue desarrollado por el comité técnico NCITS H2 sobre bases de datos.
Este comité desarrolla estándares para la sintaxis y semántica de los lenguajes de
bases de datos. SQL-92 fue diseñado para ser un estándar para los sistemas
manejadores de bases de datos relacionales (RDBMS). Esta basado en SQL-89,
cuya primera versión se conoce como SQL-86. En 1992 aparece SQL2 o SQL92,
la versión hoy en día más difundida ([ISO/IEC 1992] [ANSI 1992] [ISO/IEC 1994]).
Con la aparición de la segunda versión del estándar (SQL2) en 1992,
prácticamente todos los RDBMS, incluso los no relacionales, incluían soporte a
SQL. Hoy en día, SQL se ha convertido en el lenguaje de consulta más utilizado.
SQL (Structured Query Languaje) además de permitirnos consultas en la base de
datos, contiene primitivas de definición de tablas, actualización de la base de
datos, definición de vistas otorgamientos de privilegios, etc. A continuación se
mostrarán aspectos del estándar ANSI de 1992, conocido como SQL-92.

15. Definición de tablas y esquemas.
Definición de Esquemas
La definición de un esquema es simple. Sólo se necesita identificar el comienzo de
la definición con una instrucción CREATE SCHEMA y una cláusula adicional
AUTHORIZATION y a continuación definir cada dominio, tabla, vista y demás en el
esquema.
Por ejemplo:
CREATE SCHEMA EMPRESA_CL
AUTHORIZATION DUEÑO
Definición de dominios
Definición de tablas
Definición de vistas
etc.
El dueño del esquema, o propietario del esquema puede otorgar privilegios de
acceso y actualización de la base de datos definida en el esquema a otros
usuarios del sistema.
Tipos de datos y dominios.
Un dominio es un conjunto del cual toma sus valores una columna de una relación.
Según este concepto, los tipos de datos predefinidos son dominios.
Adicionalmente SQL-92 permite la definición de dominios por parte de los
usuarios.
Numéricos exactos:
Integer Enteros
Small Integer Enteros pequeños
Numérico(p, e) p: precisión: total de números o dígitos en el número
e: escala: cuantos números están a la derecha del punto decimal
Decimal(p, e) p:precisión e: escala

16. Numéricos aproximados:
Estos tipos de datos se utilizan normalmente para cálculos científicos y de
ingeniería.
Cadenas de caracteres:
Los campos de character siempre almacenan n caracteres, aún cuando
tengan que rellenar con blancos a la derecha para completar la longitud n. Los
campos character varying sólo almacenan el número real de caracteres que se
introdujeron (hasta un máximo de n).
Cadenas de bits:
Estos campos se usan para banderas u otras máscaras de bits para el control.
Real
Double precision Doble precisión
Float Flotante
Character(n) Carácter
Character varying(n) Carácter variable
Bit(n)
Bit varying(n)

17. Fechas y horas:
El tipo Date se da en el orden año, mes, día con cuatro dígitos para el año. El
Time se da en horas (0 a 23), minutos, segundos y décimas de segundos. El
Timestamp es la fecha más la hora.
Intervalos:
Un intervalo es la diferencia entre dos fechas (año-mes) o entre dos horas (día-
hora).
Definición de dominios:
Los tipos de datos con restricciones (constrains) y valores por defecto (default
values) se pueden combinar en la definición de dominios. Una definición de
dominio es un tipo de datos especializado que puede estar definido dentro de un
esquema y utilizado en la definición de columnas.
Por ejemplo:
CREATE DOMAIN IDENTIFICADOR NUMERIC (4) DEFAULT 0
CHECK (VALUE IS NOT NULL)
Esta definición dice que un dominio llamado IDENTIFICADOR tiene las
siguientes propiedades:
1. Su tipo de datos es numérico de cuatro dígitos.
2. Su valor por defecto es 0.
3. Nunca puede ser nulo.
Definición de Tablas:
Las tablas se definen en tres pasos:
1. Dar el nombre de la tabla.
2. Definir cada columna, posiblemente incluyendo restricciones de columna.
3. Definir las restricciones de la tabla.

18. Manipulación de datos
Consultas simples
Consultas simples: Una consulta que involucra una sola tabla de la base de datos.
Ejemplo: ¿Quiénes son los fontaneros?
SELECT TRA_NOMBRE
FROM TRABAJADOR
WHERE TRA_OFICIO = 'Fontanero'
Aquí se muestran las tres cláusulas más usadas en SQL: la cláusula
SELECT, la cláusula FROM y la cláusula WHERE. Una buena regla es escribir
cada cláusula en una línea aparte y con sangrías, aunque se puede escribir todo
en la misma línea.
Cláusula SELECT: Señala las columnas que se desean en la consulta
(equivalente a la proyección del álgebra relacional).
Cláusula FROM: Lista las tablas que son referidas por la consulta.
Cláusula WHERE: Nos da la condición para seleccionar las filas de las tablas
indicadas.
La sentencia SQL anterior se procesa por el sistema en el orden FROM,
WHERE, SELECT.
Consultas multi-tablas
Consulta: ¿Cuáles son los oficios de los trabajadores asignados al edificio 435?
SELECT TRA_OFICIO
FROM TRABAJADORES, ASIGNACION
WHERE TRA_ID = ASG_ID_TRABAJADOR
AND ASG_ID_EDIFICIO = 435
En este caso, la cláusula FROM calcula el producto cartesiano de las tablas
indicadas y luego con la cláusula WHERE filtramos las filas interesantes
(aquellas en que TRA_ID es igual a ASG_ID_TRABAJADOR) y luego las que
nos interesan (las asignaciones al edificio 435), y por último SELECT toma la
columna que nos interesa. Ojo que cuando hay problemas de que se repite un
nombre de columna le ponemos como prefijo el nombre de la tabla seguida por
un punto, ejemplo:
TRABAJADORES.TRA_ID, o ASIGNACION.ASG_ID_EDIFICIO.

19. Consulta: Indicar los trabajadores con los nombres de sus supervisores
SELECT A.TRA_NOMBRE, B.TRA_NOMBRE
FROM TRABAJADORES A, TRABAJADORES B
WHERE A.TRA_SUP = B.TRA_ID
En este caso, para resolver la consulta necesitamos dos copias de la tabla, para
ello usamos alias (un nombre alternativo que se le da a una relación) de las tablas
A y B para referirnos a cada copia.
Subconsultas
Subconsulta: Una consulta dentro de una consulta.
Consulta: ¿Cuáles son los oficios de los trabajadores asignados al edificio 435?
SELECT TRA_OFICIO
FROM TRABAJADOR
WHERE TRA_ID IN (
SELECT ASG_ID_TRABAJADOR
FROM ASIGNACION
WHERE ASG_ID_EDIFICIO = 435
)
En el ejemplo la subconsulta es:
(
SELECT ASG_ID_TRABAJADOR
FROM ASIGNACION
WHERE ASG_ID_EDIFICIO = 435
)
EXISTS y NOT EXISTS
Operador EXISTS: Evalúa verdadero si el conjunto resultante es no vacío.
Operador NOT EXISTS: Evalúa verdadero si el conjunto resultante es vacío.
Consulta: ¿Quiénes son los trabajadores que no están asignados al edificio 435?
SELECT TRA_ID, TRA_NOMBRE
FROM TRABAJADOR
WHERE NO EXISTS (
SELECT *
FROM ASIGNACION
WHERE ASG_ID_TRABAJADOR = TRA_ID
AND ASG_ID_EDIFICIO = 435
)

20. Los operadores EXISTS y NOT EXISTS siempre preceden a una subconsulta.
Además esta subconsulta tiene apellido, es una subconsulta correlacionada, es
decir, es una subconsulta cuyos resultados dependen de la fila que se está
examinando por una consulta más externa.
Funciones integradas:
Consulta: ¿Cuáles son la tarifa por hora mayor y menor?
SELECT MAX (TRA_TARIFA_HR), MIN(TRA_TARIFA_HR)
FROM TRABAJADOR
Consulta: ¿Cuál es el promedio de días que los trabajadores están asignados al
edificio 435?
SELECT AVG (ASG_NUM_DIAS)
FROM ASIGNACION
WHERE ASG_ID_EDIFICIO = 435
Consulta: ¿Cuál es el número total de días asignados a fontanería en el edificio
312?
SELECT SUM (ASG_NUM_DIAS)
FROM ASIGNACION, TRABAJADOR
WHERE TRA_ID = ASG_ID_TRABAJADOR
AND TRA_OFICIO = 'Fontanero'
AND ASG_ID_EDIFICIO = 312
Consulta: ¿Cuántos tipos de oficios diferentes hay?
SELECT COUNT (DISTINC TRA_OFICIO)
FROM TRABAJADOR
La palabra clave DISTINCT se usa para que el sistema no cuente el mismo tipo
de oficio más de una vez. Como muestran todos estos ejemplos, si una
función integrada aparece en una cláusula SELECT, entonces nada más que
funciones integradas pueden aparecer en dicha cláusula SELECT. La una
excepción ocurre en combinación con la cláusula GROUP BY.

21. GROUP BY y HAVING
Cláusula GROUP BY: Indica cuáles filas deben agruparse sobre un valor común
de las columna(s) especificada(s).
Cláusula HAVING: Una cláusula que impone condiciones a los grupos.
A diferencia de ORDER BY que se ejecutan sólo para ordenar la salida, GROUP
BY y HAVING permiten generar particiones (grupos de datos) para realizar
operaciones sobre las particiones.
Consulta: Para cada supervisor, ¿Cuál es la tarifa por horas más alta que se le
paga a un trabajador que informe a este supervisor?
SELECT TRA_SUP, MAX (TRA_TARIFA_HR)
FROM TRABAJADOR
GROUP BY TRA_SUP
Consulta: Para cada supervisor que dirige a más de un trabajador, ¿cuál es la
tarifa por horas más alta que se le paga a un trabajador que informe a dicho
supervisor?
SELECT TRA_SUP, MAX (TRA_TARIFA_HR)
FROM TRABAJADOR
GROUP BY TRA_SUP
HAVING COUNT(*) > 1
Noten que la cláusula WHERE aplica a las filas, en cambio la cláusula HAVING a
grupos !!, aunque pueden trabajar juntos WHERE y HAVING.
Consulta: Para cada supervisor que dirige a más de un trabajador, ¿cuál es la
tarifa por horas más alta que se le paga a un electricista que informe a dicho
supervisor?
SELECT TRA_SUP, MAX (TRA_TARIFA_HR)
FROM TRABAJADOR
WHERE TRA_OFICIO = 'Electricista'
GROUP BY TRA_SUP
HAVING COUNT (*) > 1

22. SQL 3
Antecedentes
El lenguaje estándar llamado SQL3, prometió ser un aumento de la
segunda generación de SQL (comúnmente conocido como SQL92, debido al
año de su publicación), SQL3 fue originalmente planeado para su uso en el año
1996, pero tardó 7 años en desarrollarse en vez de los tres o cuatro que se
pensaba iba a tardar.
SQL3 está caracterizado como “SQL orientado a objetos” y es la base de
algunos sistemas de manejo de bases de datos orientadas a objetos
(incluyendo ORACLE, Informix Universal Server, IBM’s DB Universal
Database y Cloudscape, además de otros).
SQL: 1999 envuelve características adicionales que se consideran herencia de
los SQL relacionales, así como también una reestructuración de los documentos
de los estándares con vista a una mayor progresión hacia normas más efectivas.
Proceso de desarrollo de normas:
Las dos organizaciones que se involucraron en la estandarización de SQL, y
por lo tanto en el desarrollo de SQL:1999 son ANSI e ISO. Más
específicamente, la comunidad internacional de trabajos mediante ISO/IEC
JTC1 (Joint Technical Committee 1), un comité formado por la organización
internacional de estandarización junto con la comisión internacional
electrotécnica. La responsabilidad de las JTC1 es desarrollar y mantener la
información relativa a la tecnología. Dentro de JTC1, el subcomité SC32,
cuya función era el intercambio y gestión de datos se formó para la
estandarización de normas relativas a varias bases de datos y metadatos que
habían sido desarrollados por otras organizaciones (tal como el ahora disuelto
SC21). SC32, es a la vez, un número de grupos de trabajo que actualmente
realizan los trabajos técnicos-WG3(lenguajes de bases de datos) es
responsable de las normas de SQL, mientras WG4 está desarrollando el
SQL/MM (SQL multimedia, un departamento de normas que especifiquen las
bibliotecas de tipos usando facilidades de SQL orientado a objetos).
Cuando la primera generación de SQL fue desarrollada (SQL-86 y su aumento
menor SQL-89), casi todo el proceso se hizo en Estados Unidos por X3H2 y otras

23. naciones participaron en su mayor parte en el modo de revisar y criticar el trabajo
propuesto por ANSI.
En el momento que SQL-89 fue publicado, la comunidad internacional hizo por
escrito propuestas para la especificación que al final llegó a ser SQL-92; que no ha
cambiado mientras SQL:1999 está siendo desarrollado.
Contenidos de SQL: 1999
A continuación se van a describir los aspectos nuevos de esta generación en
desarrollo de SQL. Los aspectos pueden ser divididos en “aspectos
relacionales” y “aspectos relacionados con objetos”.
1. Aspectos relacionales
Es más adecuado llamar a esta categoría como “aspectos que relacionan el
papel de SQL en el modelado de datos”. Estos aspectos no están
estrictamente limitados al modelo relacional, pero no están relacionados con la
orientación a objetos.
Estos aspectos se dividen en cinco grupos: nuevos tipos de datos, nuevos
predicados, semántica mejorada, seguridad adicional, la base de datos activa.
Hablaremos de cada uno de los grupos por separado.
2. Orientación a objetos
Además de las características discutidas hasta ahora, SQL: 1999 se caracteriza
porque fue desarrollado principalmente para manejar objetos. Algunas de las
características que están dentro de esta categoría fueron definidas en el estándar
SQL/PSM publicado en 1996 específicamente para llamadas a funciones y
procedimientos desde SQL. SQL: 1999 mejora esta capacidad que llamó
SQL-invoked routines, para añadir una tercera clase de rutina conocida como
método, que luego veremos.

24. CONCLUSIÓN.
Como conclusión podemos decir que SQL (Structured Query Language) es un
lenguaje declarativo de acceso a bases de datos relacionales que permite
especificar diversos tipos de operaciones en éstas.
Los orígenes del SQL están ligados a los de las bases de datos relacionales.
En su primera versión del SQL-89 se tienen tres partes:
Lenguaje de Definición de Datos (LDD). Contiene todas las instrucciones para
definir el esquema de una base de datos, como son: create, alter y drop.
Lenguaje de Manipulación de Datos (LMD). Contiene las instrucciones de manejo
de las tablas como son: select, insert, delete y update, y para control de
recurrencia como commit y rollback.
Lenguaje de Control de Datos (LCD). Contiene aquellas instrucciones para dar y
revocar permisos de acceso a los datos de la base de datos, como son: grant y
revoke.
BIBLIOGRAFÍA.
http://es.wikipedia.org/wiki/SQL
http://fenix.dcaa.unam.mx/servidores/docs/bd/ANSI%20SQL.pdf