• Author / Uploaded
• Eugene Wright

• Categories
• SQL
• Tabla (base de datos)
• Modelo de datos
• Gestión de datos
• Modelado científico

Citation preview

Alumnos: Bravo García Emmanuel. De Luna Martín Eutiquio. Puebla Valencia Jesús. Ramírez Gervacio Daniel. Velasco Velázquez Germán. Profesora: María Teresa De León. “Unidad 6 Lenguaje SQL”

Ingeniería En sistemas computacionales (i.s.c)

Contenido 6.1 Introducción al lenguaje SQL......................................................................................................... 1 6.2 Definición de datos ....................................................................................................................... 3 6.3 Estructura básica de las consultas................................................................................................. 4 Predicados y conectores ..................................................................................................................... 6 Comparación de conjuntos ................................................................................................................. 8 6.4 Operaciones sobre conjuntos ....................................................................................................... 9 UNION ................................................................................................................................................. 9 EXCEPT............................................................................................................................................... 10 INTERSECT ......................................................................................................................................... 10 6.5 Funciones de agregación ............................................................................................................. 12 6.6 Valores nulos SQL ........................................................................................................................ 14 6.7 Consultas anidadas ...................................................................................................................... 17 6.8 Consultas complejas .................................................................................................................... 18 El producto cartesiano ...................................................................................................................... 20 El INNER JOIN .................................................................................................................................... 21 6.9 Vistas ........................................................................................................................................... 24 Creación de vistas.............................................................................................................................. 24 6.10 Modificación de las bases de datos........................................................................................... 27 BORRADO .......................................................................................................................................... 27 Uso de funciones de agregación en una sub consulta de borrado. .................................................. 28 INSERCIÓN ......................................................................................................................................... 28 Conclusiones Personales ................................................................................................................... 31

6.1 Introducción al lenguaje SQL El SQL es el lenguaje estándar ANSI/ISO de definición, manipulación y control de bases de datos relacionales. Es un lenguaje declarativo: sólo hay que indicar qué se quiere hacer. En cambio, en los lenguajes procedimentales es necesario especificar cómo hay que hacer cualquier acción sobre la base de datos. El SQL es un lenguaje muy parecido al lenguaje natural; concretamente, se parece al inglés, y es muy expresivo. Por estas razones, y como lenguaje estándar, el SQL es un lenguaje con el que se puede acceder a todos los sistemas relacionales comerciales. Empezamos con una breve explicación de la forma en que el SQL ha llegado a ser el lenguaje estándar de las bases de datos relacionales: Al principio de los años setenta, los laboratorios de investigación Santa Teresa de IBM empezaron a trabajar en el proyecto System R. El objetivo de este proyecto era implementar un prototipo de SGBD relacional; por lo tanto, también necesitaban investigar en el campo de los lenguajes de bases de datos relacionales. A mediados de los años setenta, el proyecto de IBM dio como resultado un primer lenguaje denominado SEQUEL (Structured English Query Language), que por razones legales se denominó más adelante SQL (Structured Query Language). Al final de la década de los setenta y al principio de la de los ochenta, una vez finalizado el proyecto System R, IBM y otras empresas empezaron a utilizar el SQL en sus SGBD relacionales, con lo que este lenguaje adquirió una gran popularidad. En 1982, ANSI (American National Standards Institute) encargó a uno de sus comités (X3H2) la definición de un lenguaje de bases de datos relacionales. Este comité, después de evaluar diferentes lenguajes, y ante la aceptación comercial del SQL, eligió un lenguaje estándar que estaba basado en éste prácticamente en su totalidad. El SQL se convirtió oficialmente en el lenguaje estándar de ANSI en el año 1986, y de ISO (International Standards Organization) en 1987. También ha sido adoptado como lenguaje estándar por FIPS (Federal Information Processing Standard), Unix X/Open y SAA (Systems Application Architecture) de IBM. En el año 1989, el estándar fue objeto de una revisión y una ampliación que dieron lugar al lenguaje que se conoce con el nombre de SQL1 o SQL89. En el año 1992 el estándar volvió a ser revisado y ampliado considerablemente para cubrir carencias de la versión anterior. Esta nueva versión del SQL, que se conoce con el nombre de SQL2 o SQL92. Aunque aparezca sólo la sigla SQL, siempre nos estaremos refiriendo al SQL92, ya que éste tiene como subconjunto el SQL89; por lo tanto, todo lo que era válido en el caso del SQL89 lo continuará siendo en el SQL92. 1

De hecho, se pueden distinguir tres niveles dentro del SQL92: El nivel introductorio (entry), que incluye el SQL89 y las definiciones de clave primaria y clave foránea al crear una tabla. El concepto de clave primaria y su importancia en una relación o tabla se ha visto en la unidad “El modelo relacional y el álgebra relacional”. El nivel intermedio (intermediate), que, además del SQL89, añade algunas ampliaciones del SQL92. El nivel completo (full), que ya tiene todas las ampliaciones del SQL92. El modelo relacional tiene como estructura de almacenamiento de los datos las relaciones. La intensión o esquema de una relación consiste en el nombre que hemos dado a la relación y un conjunto de atributos. La extensión de una relación es un conjunto de tuplas. Hablaremos de tablas en lugar de relaciones. Hablaremos de columnas en lugar de atributos. Hablaremos de filas en lugar de tuplas. Sin embargo, a pesar de que la nomenclatura utilizada sea diferente, los conceptos son los mismos. Para utilizar SQL desde un lenguaje de programación necesitaremos sentencias especiales que nos permitan distinguir entre las instrucciones del lenguaje de programación y las sentencias de SQL. La idea es que trabajando básicamente con un lenguaje de programación anfitrión se puede cobijar SQL como si fuese un huésped. Por este motivo, este tipo de SQL se conoce con el nombre de SQL hospedado. Para trabajar con SQL hospedado necesitamos un precompilador que separe las sentencias del lenguaje de programación de las del lenguaje de bases de datos. Una alternativa a esta forma de trabajar son las rutinas SQL/CLI* (SQL/Call-Level Interface), que resolviendo también el problema de acceder a SQL desde un lenguaje de programación, no necesitan precompilador.

2

6.2 Definición de datos El DDL, lenguaje de definición de datos. Es la parte del SQL que más varía de un sistema a otro ya que esa área tiene que ver con cómo se organizan internamente los datos y eso, cada sistema lo hace de una manera u otra. Un lenguaje de definición de datos (Data Definition Language, DDL por sus siglas en inglés) es un lenguaje proporcionado por el sistema de gestión de base de datos que permite a los usuarios de la misma llevar a cabo las tareas de definición de las estructuras que almacenarán los datos así como de los procedimientos o funciones que permitan consultarlos. Un Data Definition Language o Lenguaje de descripción de datos (DDL) es un lenguaje de programación para definir estructuras de datos. El término DDL fue introducido por primera vez en relación con el modelo de base de datos CODASYL, donde el esquema de la base de datos ha sido escrito en un lenguaje de descripción de datos que describe los registros, los campos, y "conjuntos" que conforman el usuario modelo de datos. Más tarde fue usado para referirse a un subconjunto de SQL, pero ahora se utiliza en un sentido genérico para referirse a cualquier lenguaje formal para describir datos o estructuras de información, como los esquemas XML. A diferencia de muchos lenguajes de descripción de datos, SQL utiliza una colección de verbos imperativo cuyo efecto es modificar el esquema de la base de datos, añadiendo, cambiando o eliminando las definiciones de tablas y otros objetos. Estas declaraciones se pueden mezclar libremente con otras sentencias SQL, por lo que el DDL no es realmente una lengua independiente. La declaración más común es CREATE TABLE, que se utiliza para Crear una tabla nueva. El lenguaje de programación SQL, el más difundido entre los gestores de bases de datos, admite las siguientes sentencias de definición: CREATE (crear), DROP (borrar) y ALTER (actualizar, modificar), cada una de las cuales se puede aplicar a las tablas, vistas, procedimientos almacenados y triggers de la base de datos.

3

6.3 Estructura básica de las consultas La estructura básica de una expresión para consulta SQL consta de tres cláusulas: SELECT FROM WHERE La cláusula SELECT se usa para listar los atributos que se desean en el resultado de una consulta, es un modo literal de decir “seleccionar” La cláusula FROM lista las relaciones que se van a examinar en la evaluación de la expresión es un modo literal de decir “de” La cláusula WHERE costa de un predicado que implica atributos de las relaciones que aparecen en la cláusula FROM. Es un modo literal de decir “donde” Una consulta básica en SQL tiene la forma: (seleccionar, de, donde) SELECT A1, A2, A3 FROM r1,r2, r3 WHERE A1=’Federico’ ; Donde A1 = atributo o campo de la tabla, si se pone * o la palabra ALL se seleccionará todo. r1 = relación ( Tabla ) A1=’Federico’ = predicado o condición Ejemplo 2: Seleccionar todos los nombres de las personas que tengan el apellido MARQUESI de la tabla persona SELECT nombre FROM persona WHERE apellido = " MARQUESI";

4

El resultado de una consulta es por supuesto otra relación. Si se omite la cláusula WHERE, el predicado P es verdadero. La lista A1, A2,..., An puede sustituirse por un asterisco (*) para seleccionar todos los atributos de todas las relaciones que aparecen en la cláusula FROM, aunque no es conveniente elegir esta ultima opción salvo que sea necesario pues desperdiciamos mucho tiempo en obtenerlo Alias: Es posible renombrar los atributos y las relaciones, a veces por conveniencia y otras veces por ser necesario, para esto usamos la cláusula AS como en el siguiente ejemplo. Ejemplo 2.2 SELECT P.nombre AS [PRIMER NOMBRE] FROM persona P WHERE apellido = "MARQUESI"

En este ejemplo cabe destacar un par de cosas. Cuando nos referimos a un atributo como es el caso de nombre, podemos referirnos a este usando la relación (o el alias en este ejemplo) a la que pertenece el atributo seguido de un punto seguido del atributo , a veces esta notación será necesaria para eliminar ambigüedades. Los corchetes los usamos cuando usamos espacios en blancos o el carácter (–) en el nombre de atributo o alias. Usar alias en los atributos nos permite cambiar el nombre de los atributos de la respuesta a la consulta. Cuando asociamos un alias con una relación decimos que creamos una variable de tupla. Estas variables de tuplas se definen en la cláusula FROM después del nombre de la relación. En las consultas que contienen subconsultas, se aplica una regla de ámbito a las variables de tupla. En una subconsulta está permitido usar solo variables de tupla definidas en la misma subconsulta o en cualquier consulta que tenga la subconsulta.

5

Predicados y conectores Los conectores lógicos en SQL son: AND OR NOT La lógica de estos conectores es igual que en cualquier lenguaje de programación y sirven para unir predicados. Las operaciones aritméticas en SQL son: + (Suma) - (Resta) * (Multiplicación) / (División) También incluye el operador de comparación BETWEEN, que se utiliza para valores comprendidos “entre” Ejemplo: Encontrar todos los nombres y dni de las personas cuyos dni sea mayor que 26 millones y menor a 28 millones SELECT nombre, dni FROM persona WHERE dni BETWEEN 26000000 and 28000000 Análogamente podemos usar el operador de comparación NOT BETWEEN. SQL también incluye un operador de selección para comparaciones de cadena de caracteres. Los modelos se describen usando los caracteres especiales: El carácter (%) es igual a cualquier sub cadena. El operador (_) es igual a cualquier carácter. Estos modelos se expresan usando el operador de comparación LIKE. Un error muy frecuente es tratar de utilizar los modelos mediante el operador de igualdad (=) lo cual es un error de sintaxis. Ejemplo: encontrar los nombres que comiencen con la letra p o el nombre tenga exactamente 6 caracteres de la relación persona SELECT nombre. FROM persona. WHERE (nombre LIKE "P%") OR (nombre LIKE "_ _ _ _ _ _") 6

SQL incluye las operaciones de conjuntos UNION, INTERSECT, MINUS, que operan sobre relaciones y corresponden a las operaciones del álgebra unión, intersección y resta de conjuntos respectivamente. Para realizar esta operación de conjuntos debemos tener sumo cuidado que las relaciones tengan las mismas estructuras. Incorporemos ahora una nueva relación, llamada jugadores que representa las personas que juegan al fútbol, sus atributos serán DNI, puesto y nro_camiseta. Supongamos que esta nueva tabla está conformada de la siguiente manera Ejemplo: Obtener todos los nombres de la relación persona cuyos apellidos sean Marquesi o Serrat. SELECT nombre FROM PERSONA WHERE apellido = "MARQUESI" UNION SELECT nombre FROM PERSONA WHERE apellido = "SERRAT" Obtener todos los DNI de los que juegan al fútbol y, además, están en la lista de la relación persona SELECT dni FROM persona INTERSECT SELECT dni FROM jugadores Por omisión, la operación de union elimina las tuplas duplicadas. Para retener duplicados se debe escribir UNION ALL en lugar de UNION. El conector IN prueba si se es miembro de un conjunto, donde el conjunto es una colección de valores producidos en lo general por una cláusula SELECT. Análogamente el conector NOT IN prueba la no pertenencia al conjunto Ejemplo: Encontrar los nombres de las personas que juegan al fútbol y, además, se encuentran en la relación persona SELECT nombre, apellido FROM persona WHERE dni IN (SELECT dni FROM jugadores) 7

Es posible probar la pertenencia de una relación arbitraria SQL usa la notación de elementos para representar una tupla de elementos de n que contiene los valores v1,v2,...,vn.

Comparación de conjuntos En conjuntos la frase > se representa en SQL por (>SOME), también podría entenderse esto como >, su sintaxis es igual que la del conector IN. SQL también permite las comparaciones (>SOME), (=SOME) (>=SOME), (ALL), que corresponde a la frase >. Al igual que el operador SOME, puede escribirse (>ALL), (=ALL) (>=ALL), (