Escolar Documentos
Profissional Documentos
Cultura Documentos
CONTENIDO
CONTENIDO.................................................................................................................................................................... 2
UNIDAD 1 ...................................................................................................................................................................... 4
INTRODUCCIÓN AL SISTEMA MANEJADOR DE BASE DE DATOS (DBMS) .......................................................... 4
1.1 CONCEPTOS ....................................................................................................................................................... 7
1.2 CARACTERÍSTICAS DE UN DBMS .......................................................................................................................... 8
UNIDAD 2 ...................................................................................................................................................................... 9
LENGUAJE DE DEFINICIÓN DE DATOS .................................................................................................................. 9
2.1 CREACIÓN DE BASE DE DATOS ...................................................................................................................... 10
2.2 CREACIÓN DE TABLAS .................................................................................................................................... 11
2.2.1 INTEGRIDAD ............................................................................................................................................ 12
2.2.2 INTEGRIDAD REFERENCIAL DECLARATIVA ......................................................................................... 13
2.2.3 CREACIÓN DE ÍNDICES ........................................................................................................................... 14
UNIDAD 3 .................................................................................................................................................................... 15
CONSULTAS Y LENGUAJE DE MANIPULACIÓN DE DATOS................................................................................. 15
3.1 INSTRUCCIONES INSERT, UPDATE, DELETE ................................................................................................ 15
3.2 CONSULTAS BÁSICAS SELECT, WHERE Y FUNCIONES A NIVEL DE REGISTRO..................................................... 18
3.3 CONSULTAS SOBRE MÚLTIPLES TABLAS ..................................................................................................... 19
3.3.1 SUBCONSULTAS ........................................................................................................................................ 20
3.3.2 OPERADORES JOIN .................................................................................................................................. 20
3.4 AGREGACIÓN GROUP BY, HAVING ................................................................................................................. 22
4.1 PROPIEDAD DE UNA TRANSACCIÓN ............................................................................................................. 27
4.2 GRADOS DE CONSISTENCIA ........................................................................................................................... 28
4.3 NIVELES DE AISLAMIENTO ............................................................................................................................ 29
4.4 INSTRUCCIONES COMMIT Y ROLLBACK ....................................................................................................... 30
UNIDAD 5 .................................................................................................................................................................... 31
VISTAS .................................................................................................................................................................... 31
5.1 DEFINICIÓN Y OBJETIVO DE LAS VISTAS ...................................................................................................... 32
5.2 INSTRUCCIONES PARA LA ADMINISTRACIÓN DE VISTAS........................................................................... 33
UNIDAD 6 .................................................................................................................................................................... 33
SEGURIDAD ............................................................................................................................................................ 33
6.1 ESQUEMAS DE AUTORIZACIÓN ..................................................................................................................... 34
6.2 INSTRUCCIONES GRANT Y REVOKE.................................................................................................................... 35
UNIDAD 7 ..................................................................................................................................................................... 36
INTRODUCCIÓN AL SQL PROCEDURAL ............................................................................................................... 36
7.1 PROCEDIMIENTOS ALMACENADOS .............................................................................................................. 37
7.2 DISPARADORES (TRIGGERS).......................................................................................................................... 38
BIBLIOGRAFÍA ............................................................................................................................................................ 38
3
INTRODUCCIÓN
UNIDAD 1
INTRODUCCIÓN AL SISTEMA MANEJADOR DE BASE DE DATOS
(DBMS)
El sistema manejador de bases de datos es la porción más importante del software de un
sistema de base de datos. Un DBMS es una colección de numerosas rutinas de software
interrelacionadas, cada una de las cuales es responsable de alguna tarea específica.
Las funciones principales de un DBMS son:
Los Sistemas Gestores de Bases de Datos son un tipo de software muy específico, dedicado a
servir de interfaz entre las bases de datos y las aplicaciones que la utilizan. Se compone de un
lenguaje de definición de datos, de un lenguaje de manipulación de datos y de un lenguaje de
consulta. En los textos que tratan este tema, o temas relacionados, se mencionan los términos
SGBD y DBMS, siendo ambos equivalentes, y acrónimos, respectivamente, de Sistema Gestor
Motor ò Núcleo DBMS: recibe los requerimientos lógicos de E/S y los convierte en operaciones
de lectura y escritura.
Lógicos: son cualquier tipo de consulta requerimiento de lectura con ingreso de datos
(requerimiento de estructura) es ayudado por el Sistema Operativo para convertir estos
requerimientos lógicos en físicos que actúan sobre dispositivos de almacenamiento.
1.1 CONCEPTOS
Un sistema de administración de bases de datos DBMS (Database Management System, por
sus siglas en inglés) es un sistema basado en computador (software) que maneja una base de
datos, o una colección de bases de datos o archivos. La persona que administra un D0BMS es
conocida como el DBA (Database Administrator, por sus siglas en ingles). Esta compuesto por:
Permitir a los usuarios acceder y manipular la base de datos proveyendo métodos para
construir sistemas de procesamiento de datos para aplicaciones que requieran acceso
a los datos.
Proveer a los administradores las herramientas que les permitan ejecutar tareas de
mantenimiento y administración de los datos.
MANTENIMIENTO DE LA INTEGRIDAD
La integridad de los datos es la que garantiza la precisión o exactitud de la información
contenida en una base de datos. Los datos interrelacionados deben siempre representar
información correcta a los usuarios.
SEGURIDAD
La disponibilidad de los datos puede ser restringida a ciertos usuarios. Según los privilegios
que posea cada usuario de la base de datos, podrá acceder a mayor información que otros.
VELOCIDAD
Los sistemas DBMS modernos poseen altas velocidades de respuesta y proceso.
UNIDAD 2
LENGUAJE DE DEFINICIÓN DE DATOS
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.
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, DROP y ALTER, cada una de las cuales
se puede aplicar a las tablas, vistas, procedimientos almacenados y triggers de la base de
datos.
Otras que se incluyen dentro del DDL, pero que su existencia depende de la implementación
del estándar SQL que lleve a cabo el gestor de base de datos son GRANT y REVOKE, los cuales
sirven para otorgar permisos o quitarlos, ya sea a usuarios específicos o a un rol creado dentro
de la base de datos.
Una vez finalizado el diseño de una base de datos y escogido un SGBD para su implementación,
el primer paso consiste en especificar el esquema conceptual y el esquema interno de la base
de datos, y la correspondencia entre ambos. En muchos SGBD no se mantiene una separación
estricta de niveles, por lo que el administrador de la base de datos y los diseñadores utilizan el
mismo lenguaje para definir ambos esquemas, es el lenguaje de definición de datos (LDD). El
SGBD posee un compilador de LDD cuya función consiste en procesar las sentencias del
lenguaje para identificar las descripciones de los distintos elementos de los esquemas y
almacenar la descripción del esquema en el catálogo o diccionario de datos.
10
Una base de datos en un sistema relacional está compuesta por un conjunto de tablas, que
corresponden a las relaciones del modelo relacional. En la terminología usada en SQL no se
alude a las relaciones, del mismo modo que no se usa el término atributo, pero sí la palabra
columna, y no se habla de tupla, sino de línea. A continuación se usarán indistintamente
ambas terminologías, por lo que tabla estará en lugar de relación, columna en el de atributo y
línea en el de tupla, y viceversa. Antes de poder proceder a la creación de las tablas,
normalmente hay que crear la base de datos, lo que a menudo significa definir un espacio de
nombres separado para cada conjunto de tablas. De esta manera, para una DBMS se pueden
gestionar diferentes bases de datos independientes al mismo tiempo sin que se den conflictos
con los nombres que se usan en cada una de ellas.
Para crear una base de datos por ejemplo en Mysql debes de utilizar la instrucción CREATE
DATABASE nombre_base_datos que es similar en los otros manejadores de bases de datos
La sintaxis empleada por PostgreSQL, pero también por las DBMS más difundidas, es la
siguiente:
En general, la mayoría de las bases de datos poseen potentes editores de bases que permiten
la creación rápida y sencilla de cualquier tipo de tabla con cualquier tipo de formato.
Sin embargo, una vez la base de datos está alojada en el servidor, puede darse el caso de que
queramos introducir una nueva tabla ya sea con carácter temporal (para gestionar un carrito
de compra por ejemplo) o bien permanente por necesidades concretas de nuestra aplicación.
En estos casos, podemos, a partir de una sentencia SQL, crear la tabla con el formato que
deseemos lo cual nos puede ahorrar más de un quebradero de cabeza.
Este tipo de sentencias son especialmente útiles para bases de datos como Mysql, las cuales
trabajan directamente con comandos SQL y no por medio de editores.
Para crear una tabla debemos especificar diversos datos: El nombre que le queremos asignar,
los nombres de los campos y sus características. Además, puede ser necesario especificar
cuáles de estos campos van a ser índices y de qué tipo van a serlo.
La sintaxis de creación puede variar ligeramente de una base de datos a otra ya que los tipos
de campo aceptados no están completamente estandarizados.
Tras la creación de la base de datos el siguiente paso que se debe realizar es la creación de la
tabla, o tablas, que almacenarán la información. Los datos de los clientes, de los pedidos, de
los socios, etc.…
Esta información será la que gestionen todos los demás objetos de la base de datos (consultas,
formularios, etc.), por lo que es muy importante planificar bien la estructura que van a tener
los datos (como van a estar dispuestos en la tabla, de que naturaleza o tipo va a ser cada uno,
en que orden estarán colocados, etc…), con el fin de poder dar respuesta a todas las
cuestiones que se puedan plantear sobre el manejo de dicha información.
Para crear una tabla debemos especificar diversos datos: El nombre que le queremos asignar,
los nombres de los campos y sus características. Además, puede ser necesario especificar
cuáles de estos campos van a ser índices y de qué tipo van a serlo.
La sintaxis de creación puede variar ligeramente de una base de datos a otra ya que los tipos
de campo aceptados no están completamente estandarizados.
Sintaxis
2.2.1 INTEGRIDAD
El término integridad de datos se refiere a la corrección y completitud de los datos en una base
de datos. Cuando los contenidos se modifican con sentencias INSERT, DELETE o UPDATE, la
integridad de los datos almacenados puede perderse de muchas maneras diferentes. Pueden
añadirse datos no válidos a la base de datos, tales como un pedido que especifica un producto
no existente.
Pueden modificarse datos existentes tomando un valor incorrecto, como por ejemplo si se
reasigna un vendedor a una oficina no existente. Los cambios en la base de datos pueden
perderse debido a un error del sistema o a un fallo en el suministro de energía. Los cambios
pueden ser aplicados parcialmente, como por ejemplo si se añade un pedido de un producto
sin ajustar la cantidad disponible para vender.
Una de las funciones importantes de un DBMS relacional es preservar la integridad de sus
datos almacenados en la mayor medida posible.
Datos Requeridos: establece que una columna tenga un valor no NULL. Se define efectuando la
declaración de una columna es NOT NULL cuando la tabla que contiene las columnas se crea
por primera vez, como parte de la sentencia CREATE TABLE.
Chequeo de Validez: cuando se crea una tabla cada columna tiene un tipo de datos y el
DBMS asegura que solamente los datos del tipo especificado sean ingresados en la
tabla.
Integridad de entidad: establece que la clave primaria de una tabla debe tener un valor
único para cada fila de la tabla; si no, la base de datos perderá su integridad. Se
especifica en la sentencia CREATE TABLE. El DBMS comprueba automáticamente la
unicidad del valor de la clave primaria con cada sentencia INSERT Y UPDATE. Un
intento de insertar o actualizar una fila con un valor de la clave primaria ya existente
fallará.
Integridad referencial: asegura la integridad entre las claves ajenas y primarias
(relaciones padre/hijo). Existen cuatro actualizaciones de la base de datos que pueden
corromper la integridad referencial:
La integridad de los datos es la propiedad que asegura que información dada es correcta, al
cumplir ciertas aserciones.
Las restricciones de integridad aseguran que la información contenida en una base de datos es
correcta.
Las restricciones de integridad son propiedades de la base de datos que se deben satisfacer en
cualquier momento.
Las restricciones de integridad aseguran que la información contenida en la base de datos
cumple ciertas restricciones para los diferentes estados.
Ejemplo:
Supongamos una base de datos con las entidades Persona y Factura. Toda factura corresponde
a una persona y solamente una. Implica que en todo momento dichos datos sean correctos, sin
repeticiones innecesarias, datos perdidos y relaciones mal resueltas.
Supongamos que una persona se identifica por su atributo DNI (Documento nacional de
identidad). También tendrá otros atributos como el nombre y la dirección. La entidad Factura
debe tener un atributo DNI_cliente que identifique a quién pertenece la factura.
Por sentido común es evidente que todo valor de DNI_cliente debe corresponder con algún
valor existente del atributo DNI de la entidad Persona. Esta es la idea intuitiva de la integridad
referencial.
Integridad referencial débil: si en una tupla de R todos los valores de los atributos de K
tienen un valor que no es el nulo, entonces debe existir una tupla en S que tome esos
mismos valores en los atributos de J;
Integridad referencial parcial: si en una tupla de R algún atributo de K toma el valor
nulo, entonces debe existir una tupla en S que tome en los atributos de J los mismos
valores que los atributos de K con valor no nulo; y
Integridad referencial completa: en una tupla de R todos los atributos de K deben
tener el valor nulo o bien todos tienen un valor que no es el nulo y entonces debe
existir una tupla en S que tome en los atributos de J los mismos valores que toman los
de K.
14
Un índice (o KEY, o INDEX) es un grupo de datos que MySQL asocia con una o varias columnas
de la tabla. En este grupo de datos aparece la relación entre el contenido y el número de fila
donde está ubicado.
Los índices -como los índices de los libros- sirven para agilizar las consultas a las tablas,
evitando que mysql tenga que revisar todos los datos disponibles para devolver el resultado.
Podemos crear el índice a la vez que creamos la tabla, usando la palabra INDEX seguida del
nombre del índice a crear y columnas a indexar (que pueden ser varias):
Los index permiten mayor rápidez en la ejecución de las consultas a la base de datos tipo
SELECT ... WHERE
La regla básica es pues crear tus índices sobre aquellas columnas que vayas a usar con una
cláusula WHERE, y no crearlos con aquellas columnas que vayan a ser objeto de un SELECT:
SELECT texto from tabla_libros WHERE autor = Vazquez; En este ejemplo, la de autor es una
columna buena candidata a un indice; la de texto, no.
Otra regla básica es que son mejores candidatas a indexar aquellas columnas que presentan
muchos valores distintos, mientras que no son buenas candidatas las que tienen muchos
valores idénticos, como por ejemplo sexo (masculino y femenino) porque cada consulta
implicará siempre recorrer prácticamente la mitad del índice.
Tipos de índice
En algunas bases de datos existen diferencias entre KEY e INDEX. No así en MySQL donde son
sinónimos.
Un índice que sí es especial es el llamado PRIMARY KEY. Se trata de un índice diseñado para
consultas especialmente rápidas. Todos sus campos deben ser UNICOS y no admite NULL
Un indice UNIQUE es aquel que no permite almacenar dos valores iguales.
Los indices FULL TEXT permiten realizar búsquedas de palabras. Puedes crear indices FULLTEXT
sobre columnas tipo CHAR, VARCHAR o TEXT.
15
UNIDAD 3
CONSULTAS Y LENGUAJE DE MANIPULACIÓN DE DATOS
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.
En SQL, hay fundamental y 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. Primero observemos como
podemos insertamos 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:
Tabla Store_Information
Column Name Data Type
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 dólares
estadounidenses en ventas. Por lo tanto, utilizaremos la siguiente escritura SQL:
16
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
tabla Sales_Information table,
Ingresaremos:
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.
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}
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:
17
UPDATE Store_Information
SET Sales = 500
WHERE store_name = "Los Angeles"
AND Date = "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}
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
store_name Sales Date
Los Angeles 1500 € 05-Jan-1999
San Diego 250 € 07-Jan-1999
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:
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. Por lo tanto tenemos la estructura SQL más básica:
Tabla Store_Information
store_name Sales 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:
Resultado:
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.
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. Para ello,
utilizamos la palabra clave WHERE. La sintaxis es la siguiente:
SELECT "nombre_columna"
FROM "nombre_tabla"
WHERE "condición"
19
Por ejemplo, para seleccionar todos los negocios con ventas mayores a 1.000€ en la Tabla
Store_Information,
Tabla Store_Information
Ingresamos:
SELECT store_name
FROM Store_Information
WHERE Sales > 1000
Resultado:
store_name
Los Angeles
En una base de datos relacional, la información está distribuida entre diferentes tablas
relacionadas. Las cláusulas obligatorias en unaconsulta son:
Para obtener información de más de una tabla, es necesario identificar las columnas comunes
entre cada par de tablas relacionadas. En la cláusula WHERE se definen las relaciones entre las
tablas listadas en la cláusula FROM. La SELECT puede tener columnas o expresiones de una o
más de estas tablas.
Una JOIN es una consulta que combina filas de dos o más tablas o vistas. Las tablas de la JOIN
deben aparecer en el FROM.
20
3.3.1 SUBCONSULTAS
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])
Una subconsulta es una sentencia select que aparece dentro de otra sentencia select que
llamaremos consulta principal.
Una subconsulta tiene la misma sintaxis que una sentencia select normal exceptuando que
aparece encerrada entre paréntesis, no puede contener la cláusula order by, ni puede ser la
unión de varias sentencias select, además tiene algunas restricciones en cuanto a número de
columnas según el lugar donde aparece en la consulta principal.
A menudo, es necesario, dentro del cuerpo de una subconsulta, hacer referencia al valor de
una columna en la fila actual de la consulta principal, ese nombre de columna se denomina
referencia externa. Una referencia externa es un nombre de columna que estando en la
subconsulta, no se refiere a ninguna columna de las tablas designadas en la from de la
subconsulta sino a una columna de las tablas designadas en la from de la consulta principal.
Ejemplo:
SELECT numemp, nombre, (SELECT MIN(fechapedido) FROM pedidos WHERE rep = numemp)
FROM empleados;
Tabla Store_Information
store_name Sales Date
Los Angeles 1500 € 05-Jan-1999
San Diego 250 € 07-Jan-1999
Los Angeles 300 € 08-Jan-1999
Boston 700 € 08-Jan-1999
21
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 €
West 2050 €
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.
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
“nombre_negocio” en la tabla Geografía concuerde con la tabla Store_Information, y la forma
de hacerlo es igualarlos. Esta instrucción WHEREes 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.
22
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,
Deseamos saber las ventas totales para cada negocio. Para hacerlo, ingresaríamos,
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.
23
La cláusula HAVING permite establecer una condición sobre los grupos de manera que
Sólo se seleccionan aquellos grupos que la cumplen
“listar los profesores y el nº de clases que imparten, pero sólo de aquellos profesores que
Imparten más de 10 clases”
SELECT PROFESOR,COUNT(*)
FROM DOCENCIA
GROUP BY PROFESOR
HAVING COUNT(*)>10;
Otra cosa que las personas pueden 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 €. 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.
Tabla store_information
store_name Sales 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 €
24
Todos los operadores, excepto avg y sum, pueden operar con números y cadenas de
caracteres. La función de agregación se coloca en la línea select. La cláusula group by se utiliza
cuando las funciones de agregación se aplican a un grupo de conjuntos de tuplas, y la cláusula
having se utiliza para poner una condición a los grupos.
Por ejemplo, si deseamos obtener la sumatoria de todas las ventas de la siguiente tabla,
Tabla Store_Information
store_name Sales 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 SUM(Sales) FROM Store_Information
Resultado:
SUM(Sales)
2750 €
2 750 € 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.
25
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"
Tabla Store_Information
store_name Sales 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,
UNIDAD 4
CONTROL DE TRANSACCIONES
Los sistemas que tratan el problema de control de concurrencia permiten que sus usuarios
asuman que cada una de sus aplicaciones se ejecuta atómicamente, como si no existieran
otras aplicaciones ejecutándose concurrentemente.
Esta abstracción de una ejecución atómica y confiable de una aplicación se conoce como una
transacción.
Cada transacción accede a información compartida sin interferir con otras transacciones, y si
una transacción termina normalmente, todos sus efectos son permanentes, en caso contrario
no tiene afecto alguno.
Una transacción es la ejecución de ciertas instrucciones que accedan a una base de datos
compartida. El objetivo del control de concurrencia y recuperación es asegurar que dichas
transacciones se ejecuten atómicamente, es decir:
Cada transacción accede a información compartida sin interferir con otras transacciones, y si
una transacción termina normalmente, todos sus efectos son permanentes, en caso contrario
no tiene afecto alguno.
Una base de datos está en un estado consistente si obedece todas las restricciones de
integridad (significa que cuando un registro en una tabla haga referencia a un registro en otra
tabla, el registro correspondientes debe existir) definidas sobre ella.
Atomicidad Se refiere al hecho de que una transacción se trata como una unidad de
operación. Por lo tanto, o todas las acciones de la transacción se realizan o ninguna de
ellas se lleva a cabo. La atomicidad requiere que si una transacción se interrumpe por
una falla, sus resultados parciales sean anulados.
Consistencia La consistencia de una transacción es simplemente su correctitud. En
otras palabras, una transacción es un programa correcto que lleva a la base de datos
de un estado consistente a otro con la misma característica. Debido a esto, las
transacciones no violan las restricciones de integridad de una base de datos.
Aislamiento Una transacción en ejecución no puede revelar sus resultados a otras
transacciones concurrentes antes de finalizar. Más aún, si varias transacciones se
ejecutan concurrentemente, los resultados deben ser los mismos que si ellas se
hubieran ejecutado de manera secuencial.
Permanencia Es la propiedad de las transacciones que asegura que una vez que una
transacción finaliza exitosamente, sus resultados son permanentes y no pueden ser
borrados de la base de datos por alguna falla posterior. Por lo tanto, los sistemas
manejadores de base de datos aseguran que los resultados de una transacción
sobrevivirán a fallas del sistema. Esta propiedad motiva el aspecto de recuperación de
base de datos, el cual trata sobre cómo recuperar la base de datos a un estado
consistente donde todas las acciones que han finalizado con éxito queden reflejadas
en la base.
En esencia, lo que se persigue con el procesamiento de transacciones es, por una
parte obtener una transparencia adecuada de las acciones concurrentes a una base de
datos y por otra, manejar adecuadamente las fallas que se puedan presentar en una
base de datos. La mayoría de medianas y grandes compañías modernas utilizan el
procesamiento de transacciones para sus sistemas de producción, y es tan
imprescindible que las organizaciones no pueden funcionar en ausencia de él.
Confiabilidad Puesto que los sistemas de base de datos en línea no pueden fallar.
Disponibilidad Debido a que los sistemas de base de datos en línea deben estar
actualizados correctamente todo el tiempo.
Tiempos de Respuesta En sistemas de este tipo, el tiempo de respuesta de las
transacciones no debe ser mayor a doce segundos.
hroughput Los sistemas de base de datos en línea requieren procesar miles de
transacciones por segundo.
Atomicidad En el procesamiento de transacciones no se aceptan resultados parciales.
Permanencia No se permite la eliminación en la base de datos de los efectos de una
transacción que ha culminado con éxito
28
Una transacción que termina con éxito se dice que está comprometida (commited), una
transacción que haya sido comprometida llevará a la base de datos a un nuevo estado
consistente que debe permanecer incluso si hay un fallo en el sistema. En cualquier momento
una transacción sólo puede estar en uno de los siguientes estados.
Las transacciones especifican un nivel de aislamiento que define el grado en que se debe aislar
una transacción de las modificaciones de recursos o datos realizadas por otras transacciones.
Los niveles de aislamiento se describen en cuanto a los efectos secundarios de la
simultaneidad que se permiten, como las lecturas desfasadas o ficticias.
El estándar ANSI/ISO SQL define cuatro niveles de aislamiento transaccional en función de tres
eventos que son permitidos o no dependiendo del nivel de aislamiento. Estos eventos son:
Lectura sucia. Las sentencias SELECT son ejecutadas sin realizar bloqueos, pero podría usarse
una versión anterior de un registro. Por lo tanto, las lecturas no son consistentes al usar este
nivel de aislamiento.
Lectura no repetible. Una transacción vuelve a leer datos que previamente había leído
y encuentra que han sido modificados o eliminados por una transacción cursada.
Lectura fantasma. Una transacción vuelve a ejecutar una consulta, devolviendo un
conjunto de registros que satisfacen una condición de búsqueda y encuentra que otros
registro que satisfacen la condición han sido insertadas por otra transacción cursada.
Los niveles de aislamiento SQL son definidos basados en si ellos permiten a cada uno de los
eventos definidos anteriormente. Es interesante notar que el estándar SQL no impone un
esquema de cierre específico o confiere por mandato comportamientos particulares, pero más
bien describe estos niveles de aislamiento en términos de estos teniendo muchos mecanismos
de cierre/coincidencia, que dependen del evento de lectura.
Niveles de aislamiento:
Comportamiento permitido
Lectura
Nivel de aislamiento
Sucia No repetible Fantasma
Lectura no comprometida Sí Sí Sí
Lectura comprometida No Sí Sí
Lectura repetible No No Sí
Secuenciable No No No
Según el estándar SQL, SQL Server permite todos estos niveles, Oracle sólo permite la lectura
comprometida y secuenciable. Los niveles se pueden establecer en ambos para cada
transacción. Sin embargo esto no es necesariamente cierto.
30
El estándar SQL trataba de establecer los niveles de aislamiento que permitirían a varios
grados de consistencia para querys ejecutadas en cada nivel de aislamiento. Las lecturas
repetibles "REPEATABLE READ" es el nivel de aislamiento que garantiza que un query un
resultado consistente. En la definición SQL estándar, la lectura comprometida "READ
COMMITTED" no regresa resultados consistentes, en la lectura no comprometida "READ
UNCOMMITTED" las sentencias SELECT son ejecutadas sin realizar bloqueos, pero podría
usarse una versión anterior de un registro. Por lo tanto, las lecturas no son consistentes al usar
este nivel de aislamiento.
Una transacción no se puede revertir después de ejecutar una instrucción commit transaction.
COMMIT TRANSACTION
UNIDAD 5
VISTAS
Una vista de base de datos es un resultado de una consulta SQL de una o varias tablas;
también se le puede considerar una tabla virtual.
Las vistas tienen la misma estructura que una tabla: filas y columnas. La única diferencia es que
sólo se almacena de ellas la definición, no los datos. Los datos que se recuperan mediante una
consulta a una vista se presentarán igual que los de una tabla. De hecho, si no se sabe que se
está trabajando con una vista, nada hace suponer que es así. Al igual que sucede con una
tabla, se pueden insertar, actualizar, borrar y seleccionar datos en una vista. Aunque siempre
es posible seleccionar datos de una vista, en algunas condiciones existen restricciones para
realizar el resto de las operaciones sobre vistas.
Una vista se especifica a través de una expresión de consulta (una sentencia SELECT) que la
calcula y que puede realizarse sobre una o más tablas. Sobre un conjunto de tablas
relacionales se puede trabajar con un número cualquiera de vistas.
Una vista en SQL es el resultado de una consulta de varias tablas que te aparece como una sola
tabla.
Una vista es como una ventana a través de la cual se puede consultar o cambiar información
de la tabla a la que está asociada.
Las vistas tienen la misma estructura que una tabla: filas y columnas. La única diferencia es que
sólo se almacena de ellas la definición, no los datos. Los datos que se recuperan mediante una
consulta a una vista se presentarán igual que los de una tabla. De hecho, si no se sabe que se
está trabajando con una vista, nada hace suponer que es así. Al igual que sucede con una
tabla, se pueden insertar, actualizar, borrar y seleccionar datos en una vista. Aunque siempre
es posible seleccionar datos de una vista, en algunas condiciones existen restricciones para
realizar el resto de las operaciones sobre vistas.
Las vistas tienen la misma estructura que una tabla: filas y columnas. La única diferencia es que
sólo se almacena de ellas la definición, no los datos. Los datos que se recuperan mediante una
consulta a una vista se presentarán igual que los de una tabla. De hecho, si no se sabe que se
está trabajando con una vista, nada hace suponer que es así. Al igual que sucede con una
tabla, se pueden insertar, actualizar, borrar y seleccionar datos en una vista. Aunque siempre
es posible seleccionar datos de una vista, en algunas condiciones existen restricciones para
Una vista es esencialmente una consulta almacenada que devuelve un conjunto de resultados
y a la que se le pone un nombre. Una vista es una “tabla virtual”, aparece como una tabla más
del esquema, aunque realmente no lo es.
Sintaxis
AS sentencia_select
UNIDAD 6
SEGURIDAD
La ejecución de una operación en los datos de la base de datos por parte de un usuario está
supeditada a la posesión por parte del usuario de los privilegios necesarios para la operación
concreta ejecutada en el conjunto de datos específico.
En general, los privilegios se asignan del siguiente modo:
Un usuario que crea una tabla o cualquier otro objeto de la base de datos es el
propietario y se le garantizan automáticamente todos los privilegios aplicables a dicho
objeto, con la posibilidad de darles también a otros usuarios dichos privilegios
(privilegio de concesión).
Los privilegios los concede quien tiene el permiso (es decir el propietario del objeto y
quien tiene el privilegio de concesión) mediante la orden GRANT, y los revoca
mediante la orden REVOKE.
En SQL Server nos encontramos con tres niveles o capas en los cuales podemos gestionar la
seguridad. El primero de ellos se encuentra a nivel de servidor, en él podemos gestionar quién
tiene acceso al servidor y quién no, y además gestionamos que roles va a desempeñar. Para
que alguien pueda acceder al servidor debe tener un inicio de sesión (login) asignado, y a éste
se asignaremos los roles o funciones que puede realizar sobre el servidor.
El que alguien tenga acceso al servidor no quiere decir que pueda acceder a las bases de datos
que se encuentran en él. Para ello hay que tener acceso a la siguiente barrera de seguridad,
que es a nivel de base de dato. Para que un login tenga acceso a una base de datos, tenemos
que crear en ella un usuario (user). Deberemos crear un usuario en cada una de las bases de
datos a las que queramos que acceda un login.
34
Análogamente, el que un usuario tenga acceso a una base de datos no quiere decir que tenga
acceso a todo su contenido, ni a cada uno de los objetos que la componen. Para que esto
ocurra tendremos que irle concediendo o denegando permisos sobre cada uno de los objetos
que la componen.
Autorización de índices
Permite creación y borrado de índices
Autorización de recursos
Permite la creación de relaciones nuevas
Autorización de alternación
Permite el añadido o el borrado de atributos de las relaciones
Autorización de eliminación
Permite el borrado de relaciones
35
Los comandos GRANT y REVOKE permiten a los administradores de sistemas crear cuentas de
usuario MySQL y darles permisos y quitarlos de las cuentas.
La información de cuenta de MySQL se almacena en las tablas de la base de datos mysql . Esta
base de datos y el sistema de control de acceso se discuten extensivamente en que puede
consultar para más detalles.
Si las tablas de permisos tienen registros de permisos que contienen nombres de tablas o
bases de datos con mayúsculas y minúsculas y la variable de sistema lower_case_table_names
está activa, REVOKE no puede usarse para quitar los permisos. Es necesario manipular las
tablas de permisos directamente.
Grant permite al creador de un objeto el dar permisos específicos a todos los usuarios (public)
o a un cierto usuario o grupo. Usuarios distintos al creador pueden no tener permisos de
acceso a menos que el creador se los conceda, una vez que el objeto ha sido creado. Una vez
que un usuario tiene privilegios sobre un objeto, tiene posibilidad de ejecutar ese privilegio.
No hay necesidad de conceder privilegios al creador de un objeto; el creador obtiene
automáticamente todos los privilegios, y puede también eliminar el objeto. Privilege los
posibles privilegios son: select acceso a todas las columnas de una tabla/vista específica. Insert
inserta datos en todas las columnas de una tabla específica. Update actualiza todas las
columnas de una tabla específica. Delete elimina filas de una tabla específica.
RULE
Define las reglas de la tabla(vista (cer sentencia CREATE RULE).
ALL
Otorga todos los privilegios-
object
El nombre de un objeto al que se quiere conceder el acceso. Los posibles objetos son: tabla
vista secuencia indice
PUBLIC
Una abreviación para representar a todos los usuarios.
GROUP group
Un grupo al que se otorgan privilegios. En la actual versión, el grupo debe haber sido creado
explícitamente como se describe más adelante.
username
El nombre de un usuario al que se quiere conceder privilegios. PUBLIC es una abreviatura para
representar a todos los usuarios.
CHANGE
Mensaje devuelto se la acción se ha realizado satisfactoriamente.
ERROR: Change Acl: class “object” not found
Mensaje devuelto si el objeto especificado no está disponible o si es imposible dar los
provilegios a grupo o usuarios especificado.
36
UNIDAD 7
INTRODUCCIÓN AL SQL PROCEDURAL
Una sentencia dinámica compuesta es una sentencia que, en realidad, le permite agrupar
varias sentencias de SQL en un bloque lógico atómico pequeño, en el cual puede declarar
variables y elementos para el manejo de condiciones. DB2 compila estas sentencias como una
sola sentencia de SQL, y pueden contener elementos de SQL PL. Dentro de una sentencia
dinámica compuesta, es posible incluir el subconjunto de SQL PL conocido como SQL PL en
línea y tan sólo un pequeño conjunto de sentencias de SQL básicas. Las sentencias dinámicas
compuestas son útiles para crear scripts reducidos que realicen pequeñas unidades de trabajo
lógico con un mínimo flujo de control, pero con un flujo de datos significativo. Si le interesa
una lógica más compleja que requiera parámetros, pase de conjuntos de resultados u otros
elementos de procedimiento más avanzados, pueden convenirle más los procedimientos y las
funciones de SQL.
37
Estos procedimientos, se usan a menudo, pero no siempre, para realizar consultas SQL sobre
los objetos del banco de datos de una manera abstracta, desde el punto de vista del cliente de
la aplicación. Un procedimiento almacenado permite agrupar en forma exclusiva parte de algo
específico que se desee realizar o, mejor dicho, el SQL apropiado para dicha acción.
programas clientes defectuosos o erróneos. De este modo, el motor de base de datos puede
asegurar la integridad de los datos y la consistencia, con la ayuda de procedimientos
almacenados. Algunos afirman que las bases de datos deben ser utilizadas para el
almacenamiento de datos solamente, y que la lógica de negocio sólo debería ser aplicada en la
capa de negocio de código, a través de aplicaciones cliente que deban acceder a los datos. Sin
embargo, el uso de procedimientos almacenados no se opone a la utilización de una capa de
negocio.
Son usados para mejorar la administración de la Base de datos, sin necesidad de contar con
que el usuario ejecute la sentencia de SQL.
Además, pueden generar valores de columnas, previene errores de datos, sincroniza tablas,
modifica valores de una vista, etc.
Permite implementar programas basados en paradigma lógico (sistemas expertos, deducción).
Un trigger es un bloque PL/SQL asociado a una tabla, que se ejecuta cuando una determinada
instrucción en SQL se va a ejecutar sobre dicha tabla.
El modificador FOR EACH ROW indica que el trigger se disparará cada vez que se desee hacer
operaciones sobre una fila de la tabla. Si se acompaña del modificador WHEN, se establece una
restricción; el trigger solo actuará, sobre las filas que satisfagan la restricción.
BIBLIOGRAFÍA
http://www.programatium.com/tutoriales/cursos/oracle/11.htm
http://tallerbd.hostoi.com/index.php?option=com_content&view=article&id=70&Itemid=91
http://sql.1keydata.com/es/sitemap.php
http://www.paginasprodigy.com.mx/evaristopacheco/taller
http://es.wikipedia.org/wiki/