Antologia de taller de base de datos 1 26

ITSA Ingeniería en Sistemas Computacionales Quinto Semestre Ago 12 – Ene 13 Pág. 1

Compilado por MTIJHR

SCA-1025

Antología de la Materia de Taller

de Base de Datos

Compilación Hecha por:

MTIJHR

Ingeniería

en Sistemas

Computacio

nales



OBJETIVO GENERAL DEL CURSO (competencias

específicas a desarrollar en el curso)

Crear y manipular bases de datos

utilizando distintos Gestores de Bases

de Datos considerando elementos de

integridad y seguridad para el tratamiento

de la información en distintas plataformas.

COMPETENCIAS PREVIAS

Comprender los conceptos básicos de las bases de datos.

Definir el objeto de un problema para resolverse con el modelado de una base de datos.

Construir modelos de bases de datos.

Aplicar técnicas UML para el modelado de bases de datos a través de una herramienta.

Aplicar operaciones básicas SQL.

Construir estructuras de bases de datos a partir de un modelo Entidad – Asociación.

Implementar restricciones de integridad.

Diseñar esquemas de bases de datos relacionales bajo estándares.

Crear esquemas de bases de datos en un SGBD.

Manipular bases de datos a través de un SGBD.

Conocer distintas plataformas y SGBD.

TEMARIO



Unidad Temas Subtemas

1 Instalación y

configuración del sistema

gestor de bases de datos

en distintas plataformas

1.1 Requerimientos del SGBD

1.2 Instalación del SGBD

1.3 Configuración del SGBD

2 Lenguaje de definición de

datos(DDL)

2.1 Creación del esquema de la base de datos

2.2 Actualización, modificación y eliminación del

esquema de la base de datos.

3 Lenguaje de

manipulación de

datos(DML)

3.1 Inserción, eliminación y modificación de registros

3.2 Consultas de registros

3.2.1 Recuperación de datos

3.2.2 Restricción y ordenación de datos

3.2.3 Informes de datos agregados mediante funciones

de grupo

3.2.4 Visualización de datos de varias tablas

3.2.5 Subconsultas

3.2.6 Operadores set

4 Seguridad 4.1 Tipos de usuario

4.2 Creación de usuarios

4.3 Privilegios a usuarios

4.4 Roles

4.5 Vistas

5 Transacciones 5.1 Conceptos básicos

5.2 Propiedades de las transacciones

5.3 Grados de consistencia

5.4 Niveles de aislamiento

5.5 Commit y rollback

6 SQL procedural 6.1 Procedimientos almacenados

6.2 Disparadores

7 Conectividad de Bases de

Datos

7.1 ODBC

7.2 ADO.NET

7.3 JDBC

7.4 Conectividad desde un lenguaje huésped

7.5 Conectividad en dispositivos móviles



Unidad UNO:

Instalación y configuración del

sistema gestor de bases de datos.

Competencia específica a desarrollar:

Instalar y configurar diferentes

SGBD en distintas plataformas.

Actividades de Aprendizaje:

Buscar y seleccionar en distintas fuentes de información los requisitos y características de distintos SGBD.

Realizar un cuadro comparativo donde se agregue la información encontrada acerca de los distintos SGBD

agregando la opinión personal acerca de las ventajas y desventajas de cada uno de ellos.

Instalar y configurar diversos SGBD en diferentes plataformas.

Verificar el correcto funcionamiento del SGBD instalado.

Elaborar reporte de las prácticas e integrarlo al portafolio de evidencias.

Presentación de resultados por parte del alumno.



Un Sistema Gestor de Bases de Datos (SGBD) o DBMA (DataBase Management System) es una colección de

programas cuyo objetivo es servir de interfaz entre la base de datos, el usuario y las aplicaciones. Se compone de un lenguaje

de definición de datos, de un lenguaje de manipulación de datos y de un lenguaje de consulta. Un SGBD permiten definir los

datos a distintos niveles de abstracción y manipular dichos datos, garantizando la seguridad e integridad de los mismos.

Algunos ejemplos de SGBD son Oracle, DB2, PostgreSQL, MySQL, MS SQL Server, etc.

Un SGBD debe permitir:

• Definir una base de datos: especificar tipos, estructuras y restricciones de datos.

• Construir la base de datos: guardar los datos en algún medio controlado por el mismo SGBD

• Manipular la base de datos: realizar consultas, actualizarla, generar informes.

Las características de un Sistema Gestor de Base de Datos SGBD son:

• Abstracción de la información. Los SGBD ahorran a los usuarios detalles acerca del almacenamiento físico de los datos. Da

lo mismo si una base de datos ocupa uno o cientos de archivos, este hecho se hace transparente al usuario. Así, se definen

varios niveles de abstracción.

• Independencia. La independencia de los datos consiste en la capacidad de modificar el esquema (físico o lógico) de una

base de datos sin tener que realizar cambios en las aplicaciones que se sirven de ella.

• Redundancia mínima. Un buen diseño de una base de datos logrará evitar la aparición de información repetida o

redundante. De entrada, lo ideal es lograr una redundancia nula; no obstante, en algunos casos la complejidad de los cálculos

hace necesaria la aparición de redundancias.

• Consistencia. En aquellos casos en los que no se ha logrado esta redundancia nula, será necesario vigilar que aquella

información que aparece repetida se actualice de forma coherente, es decir, que todos los datos repetidos se actualicen de

forma simultánea.

• Seguridad. La información almacenada en una base de datos puede llegar a tener un gran valor. Los SGBD deben

garantizar que esta información se encuentra segurizada frente a usuarios malintencionados, que intenten leer información

privilegiada; frente a ataques que deseen manipular o destruir la información; o simplemente ante las torpezas de algún

usuario autorizado pero despistado. Normalmente, los SGBD disponen de un complejo sistema de permisos a usuarios y

grupos de usuarios, que permiten otorgar diversas categorías de permisos.

• Integridad. Se trata de adoptar las medidas necesarias para garantizar la validez de los datos almacenados. Es decir, se trata

de proteger los datos ante fallos de hardware, datos introducidos por usuarios descuidados, o cualquier otra circunstancia

capaz de corromper la información almacenada.

• Respaldo y recuperación. Los SGBD deben proporcionar una forma eficiente de realizar copias de respaldo de la

información almacenada en ellos, y de restaurar a partir de estas copias los datos que se hayan podido perder.

• Control de la concurrencia. En la mayoría de entornos (excepto quizás el doméstico), lo más habitual es que sean muchas

las personas que acceden a una base de datos, bien para recuperar información, bien para almacenarla. Y es también

frecuente que dichos accesos se realicen de forma simultánea. Así pues, un SGBD debe controlar este acceso concurrente a la

información, que podría derivar en inconsistencias.



1.1 Requerimientos del SGBD

Requisitos antes de instalar Oracle 9i

En la actualidad ya no es dable que se trabaje con equipos inferiores a Pentium Dual Core entonces la instalación de Oracle

requiere estos requisitos mínimos:

Windows 2000 con service pack 1 o Windows XP Professional o Windows 2003 Server

Protocolo TCP/IP o TCP/IP con SSL

1 GB de memoria RAM

Al menos 2 GB de memoria virtual mínima y 4 GB de máxima

VGA de 32 bit colores

1 GB en el disco duro del sistema (normalmente C) y otras 3 GB más en ese mismo disco para el software de

Administrador y otras herramientas de Oracle.

Además se requiere 2,85 GB en el disco que albergará la carpeta raíz de Oracle, el llamado Oracle Home, 1 GB más si

se usa el Oracle Management Server y otros 2,35 GB más si se usa el Oracle Internet Directory. Las herramientas de

administrador requieren 750 MB y las de ejecución (Runtime) otras 3 GB.

Además hay que tener en cuenta que los tamaños de disco indicados sólo son válidos si se usan discos duros con el

sistema NTFS, si es FAT32 hay que doblar el tamaño

(llegando a las 13 GB con instalación absoluta).

Se requiere también un navegador web. Especialmente Internet Explorer 5 o superior o Netscape 4.7 o superior (o

cualquiera compatible

1.2 Instalación del SGBD

INSTALACIÓN DE ORACLE 9i EN WINDOWS

• Introduciremos el CD de instalación se pueden descargar

gratuitamente (siempre que no sea con fines lucrativos)

desde la propia web de oracle: www.oracle.com

Tras seleccionar la ruta de los ficheros de oracle

pulsaremos en Siguiente

http://www.oracle.com/



• A continuación seleccionaremos el tipo de instalación que

deseemos:

En nuestro caso, puesto que crearemos la base de

datos en el servidor donde estamos realizando la

instalación seleccionaremos Oracle9i Database 9.2.0.1.0 . Si

ya disponemos de un servidor de Oracle con las

correspondientes bases de datos a las que queramos

acceder será suficiente con seleccionar la opción Oracle9i

Client 9.2.0.1.0 , en este caso la instalación es bastante más

simple, pues sólo es necesario especificar la IP o el nombre

de red del servidor de Oracle así como el nombre (sid) de

la base de datos a la que queramos acceder.

• Seleccionaremos el tipo de instalación que queramos

realizar:

En nuestro caso, seleccionaremos Enterprise

Edition.

Si queremos realizar una instalación más avanzada

(especificando manualmente las opciones a instalar)

seleccionaremos Personalizado , en este caso aparecería

una ventana como esta:



• Seleccionaremos la siguiente opción dependiendo del uso

que le queramos dar a nuestra base de datos, normalmente

es para Uso General . Si no queremos crear una base de

datos en el proceso de instalación (se puede crear en otro

momento) seleccionaremos Sólo software:

• Seleccionaremos el puerto para Oracle MTS Service,

normalmente se suele seleccionar el puerto por defecto

2030 . Este parámetro es muy importante pues, si

decidimos cambiar el puerto por defecto, cuando

queramos que un cliente se conecte al servidor deberemos

especificar el puerto que hayamos seleccionado en este

punto de la instalación:

• Especificaremos el nombre de la base de datos (con un

máximo de 8 caracteres):

Nota: el SID es el identificador interno que utilizará Oracle para referenciar a nuestra base de datos, se puede elegir uno

diferente al del nombre de la Base de Datos, aunque se suele utilizar el mismo.



• En este punto de la instalación seleccionaremos la

ubicación de los archivos de la base de datos que la

instalación creará. Oracle recomienda que la ubicación de

los archivos de la base de datos esté en un disco físico

distinto al de los archivos de la instalación (software de

Oracle). También recomienda que los archivos de Redo Log

estén multiplexados (varias copias, esto se configura en la

consola de administración de Oracle) y en diferentes discos

físicos. Lógicamente es lo recomendable por Oracle y sólo

se configura así cuando se trata de una Base de Datos que

tendrá múltiples accesos concurrentes (al mismo tiempo) y

con un volumen de datos importante, pues el desembolso

económico en harware para la correcta instalación de

Oracle puede ser importante. En nuestro caso, instalaremos

los archivos de la base de datos en un segundo disco duro

instalado exclusivamente para Oracle. A pesar de todo no

hay ningún problema por instalar la base de datos en el

mismo disco duro que el software de Oracle. Si nuestra

organización dispone, por ejemplo, de unos 20 usuarios

conectados a Oracle no habría una pérdida del rendimiento

por instalarla en el mismo disco duro. Por supuesto esto es

orientativo pues dependerá también del volumen de datos

que necesite cada usuario así como de otros factores (rpm

del disco duro, características del servidor de Oracle

(procesadores, memoria RAM, …), velocidad de la red local,

tipo de conexión que realice el software de nuestra

empresa que acceda a Oracle (el acceso nativo sin

necesidad de utilizar controladores ODBC incrementa

considerablemente el rendimiento frente a accesos

mediante controladores ODBC que no dejan de ser una

pasarela entre el software y Oracle):

• Seleccionaremos el juego de caracteres que vayamos a

utilizar, si dejamos el juego de caracteres por defecto

Oracle utilizará el juego de caracteres que tengamos

configurado en nuestro sistema operativo, es la opción

recomendada. Este parámetro sólo sería importante en el

caso en que queramos exportar nuestra base de datos a

otro servidor de Oracle, en este caso será importante que

el juego de caracteres del servidor que recibirá los datos

coincida con el que los exportó. Si no coinciden podrían

aparecer erróneamente caracteres como “€” alojados en

nuestra base de datos:



• Como último paso de la preinstalación nos aparecerá una

ventana con el software que se va a instalar, tras

comprobar que es correcto pulsaremos en Instalar :

• Tras la instalación de Oracle y la creación de la base de

datos aparecerá una ventana indicando que el proceso de

instalación ha finalizado:

En esta ventana nos indica que ha finalizado el proceso de instalación y que podemos acceder desde cualquier otro

PC de la red introduciendo en el navegador de Internet:

http://nombre_o_IP_del_servidor_oracle:7778

El acceso vía Internet está permitido pues al seleccionar la instalación Enterprise Edition se instala e inicia por defecto

Oracle http Server (servidor web de Oracle).

Si al intentar acceder a la Consola de Oracle Enterprise Manager nos aparece este error:



Deberemos configurar el Listener manualmente, para ello accederemos a Inicio – Programas – Oracle – OraHome92 –

Configuration and Migration Tools – Net Configuration Assistant :

Seleccionamos Configuración de Listener y a continuación Volver a Configurar:

Nos aparecerá el Listener que el programa de instalación de Oracle crea automáticamente:



Seleccionamos el protocolo a utilizar (TCP):

Seleccionamos el puerto a utilizar, por defecto 1521:

Con esto habremos vuelto a actualizar el Listener:



Si el error ORA-12541: TNS: no hay ningún listener continúa apareciendo deberemos seguir los pasos que se indican en el

punto 1 del anexo.

1.3 Configuración del SGBD

CONFIGURACIÓN DE USUARIO PARA ACCESO VÍA HTTP A LOS PROCEDIMIENTOS PL-SQL ALMACENADOS

Si tenemos iniciado el Servidor http de Oracle podremos acceder desde cualquier equipo de la red local y, también,

desde cualquier parte del mundo (siempre que tengamos configurado el router con el puerto 7778 redirigido a la IP local del

Servidor de Oracle). Es suficiente con poner en el navegador de Internet: http://IP_Servidor_Oracle:7778, nos aparecerá una

ventana como esta



Desde aquí podremos configurar los usuarios que tendrán acceso a través de Internet a Oracle, así como los

procedimientos que se ejecutarán en el inicio.

ANEXO

1.- ALGUNOS ERRORES AL INICIAR ORACLE Y SU SOLUCIÓN

• Al iniciar la Enterprise Manager Console o al intentar conectarme a la Base de Datos de Oracle aparece el siguiente error:

TNSLSNR.EXE ha detectado un problema y debe cerrarse.

Más información: szAppName: TNSLSNR.EXE szAppVer: 0.0.0.0 szModName: orantcp9.dll

Y tras pulsar en Cerrar el servicio OracleOraHome92TNSListener se detiene.

Solución:

Accedemos al Regedit, desde el botón Inicio – Ejecutar ponemos regedit y pulsamos en Aceptar : buscamos la siguiente clave:

HKEY_LOCAL_MACHINE/SOFTWARE/ORACLE/HOME0

E insertamos una nueva entrada de tipo Valor de cadena expandible con el valor TRUE :

USE_SHARED_SOCKET=TRUE

Una vez añadida esta clave reiniciaremos el sistema. En teoría ya debería haberse solucionado el problema.

Si el problema sigue produciéndose tras reiniciar, será conveniente comprobar el fichero WinsockXPFix.exe



• El espacio en disco no para de decrecer, hasta quedarse sin espacio. Este problema es producido por el Servidor HTTP de

Oracle Basado en Apache , cuando dicho servidor encuentra algún problema con el Listener (como el descrito en el punto 1),

lo informa escribiendo en el log que crea a tal efecto. Dicho fichero de log va creciendo desproporcionadamente hasta dejar

el disco duro sin espacio. La línea del fichero de log podría ser como esta:

[warn] FastCGI: server "c:/oracle/ora92/bin/isqlplus" can't be restarted:exceeded max restarts

Solución:

Para solucionar este problema, en primer lugar deberemos detener el servicio OracleOraHome92HTTPServer y

deshabilitarlo para que no se vuelva a iniciar, al menos, hasta que solucionemos el problema, a continuación eliminaremos el

fichero de log de Apache ubicado en:

C:/oracle/ora92/Apache/Apache/logs

Eliminaremos el fichero error_log , si no nos deja eliminarlo será porque el servicio no se ha detenido correctamente,

con lo cual deberíamos deshabilitar dicho servicio y reiniciar el equipo.

Con esto hemos solucionado el problema parcialmente pues, aunque ya no vamos a tener problemas con el espacio

en disco, el servidor de Apache estará deshabilitado, con lo cual no podremos acceder a Oracle vía Internet.

Para poder iniciar el servicio de Apache sin que deje el disco sin espacio editaremos el fichero:

C:/oracle/ora92/Apache/Apache/conf/httpd.conf

Y modificaremos la línea LogLevel warn por LogLevel error . De esta forma evitaremos que el log se llene de warning

y sólo se guardarán los errores. Una vez guardado el fichero httpd.conf podremos volver a iniciar el servicio

OracleOraHome92HTTPServer.

• Al intentar conectar a Oracle aparece el error "TNS-12535: TNS:timeout de la operación" ó "ORA-12535:

TNS:operation timed out". Dicho error se puede comprobar en el directorio de instalación de Oracle:

C:/oracle/ora92/bin/sqlnet.log

Solución:

Normalmente es debido a un fallo de conexión de red con el servidor. Si, tras comprobar que la red funciona

adecuadamenete, el problema sigue apareciendo se puede deber también a la intervención de un cortafuegos (tanto

hardware como software). Por ejemplo, si tenemos instalado Oracle Server en un PC con Windows XP, el cortafuegos software

que éste incorpora inpedirá el acceso a la Base de Datos Oracle desde otros PCs. Para solucionarlo deberemos configurar

adecuadamente en cortafuegos abriendo los puertos que utiliza Oracle, tales como el 1521.

2.- INICIAR / PARAR / PROBAR LA BASE DE DATOS MANUALMENTE

Para iniciar una base de datos de Oracle manualmente seguiremos los siguientes pasos:

Desde la línea de comandos (consola de MS-DOS) pondremos:

Sqlplus /nolog

(para conectarnos a SQLPlus que es la consola de Oracle para MS-DOS, útil para realizar tareas de mantenimiento de la Base

de Datos, tales como reparación, apagado manual, inicio manual, …).

Connect / as sysdba

(para conectarnos a Oracle como administradores, al no poner nombre de usuario delante de “/” se asume el usuario del

sistema operativo (éste ha de ser administrador))



Select status from v$instance

(con esta consulta comprobamos que la base de datos no está iniciada, para ello deberá devolver un valor distinto a

STARTED)

Select database_status from v$instance

startup nomount

(con esta sentencia iniciaremos la base de datos sin montar, puede ser útil para reparar algún datafile dañado o para realizar

tareas que no se podrían llevar a cabo con la base de datos montada)

shutdown immediate

(cierra la base de datos, incluso aunque haya usuarios conectados)

startup

(inicia y monta la base de datos, la deja lista para ser usada)

alter user hr identified by hr account unlock

(esta instrucción sirve para desbloquear un usuario bloqueado y cambiarle la contraseña, en este caso hemos desbloqueado

un usuario que Oracle crea por defecto, llamado hr y le hemos asignado la contraseña hr)

connect hr/hr

(nos conectamos con el usuario hr para hacer una Select y comprobar que funciona correctamente)

select * from employees

(hacemos una consulta de selección para que nos muestre el contenido de la tabla employees que Oracle crea

automáticamente en la instalación)

Para realizar este manual se utilizó:

Oracle9i Database 9.2.0.1.0.

Microsoft Windows XP.

Nota: este manual no tiene por qué ser la mejor forma de instalar Oracle, es una de las muchas configuraciones que se

pueden realizar.



Unidad DOS: Lenguaje de

definición de datos(DDL)


Implementar esquemas de

bases de datos a través

de SQL en un SGBD.


Interpretar modelos de bases de datos.

Crear el esquema de una base de datos en base a un modelo E-A.

Modificar el esquema de la base de datos verificando la implicación de dichos cambios.

Realizar la eliminación del esquema de la base de datos.

Desarrollar prácticas para implementar esquemas bases de datos en diferentes plataformas.

Elaborar reportes de las prácticas e integrarlos al portafolio de evidencias.

Presentación de resultados por parte del alumno.



DDL (Data Definition Language) Lenguaje de definición de datos. Es el lenguaje que se usa para crear bases de datos

y tablas, y para modificar sus estructuras, así como los permisos y privilegios. Este lenguaje trabaja sobre unas tablas

especiales llamadas diccionario de datos.

El esquema de una base de datos (en inglés, Database Schema) describe la estructura de una Base de datos, en un

lenguaje formal soportado por un Sistema administrador de Base de datos (DBMS). En una Base de datos Relacional, el

Esquema define sus tablas, sus campos en cada tabla y las relaciones entre cada campo y cada tabla.

El esquema es generalmente almacenado en un Diccionario de Datos. Aunque generalmente el esquema es definido

en un lenguaje de Base de datos, el término se usa a menudo para referirse a una representación gráfica de la estructura de

base de datos

SQL engloba ambos lenguajes DDL+DML, ya que ambos forman parte del conjunto de sentencias de SQL.

2.1 Creación del esquema de la base de datos

SOBRE LAS BASES DE DATOS

INTRUCCION EXPLICACIÓN CREATE DATABASE prueba; Para crear una base de datos SHOW DATABASES; Para mostrar las bases de datos existentes USE prueba; Para seleccionar una base de datos o ponerla en uso select database(); Para conocer la Base de datos actualmente seleccionada

La sentencia CREATE TABLE que sirve para crear tablas, tiene la siguiente sintaxis básica:

CREATE [TEMPORARY] TABLE [IF NO EXISTS] nombre_tabla

( definición de columnas,…)

[ opciones de tabla ]

[ [IGNORE | REPLACE] ] sentencia de selección.

La parte de la sentencia CREATE TABLE definición de columnas tiene la siguiente sintaxis:

{ nombrer_columna tipo_de_datos

[ NOT NULL | NULL ] [DEFAULT valor_predeterminado ]

[ AUTO_INCREMENT ] [ PRIMARY KEY ] [ referencia ]

PRIMARY KEY ( columna_indice )

KEY [ nombre_indice ] (columna_indice )

INDEX [ nombre_indice ] (columna_indice )

UNIQUE [ INDEX ] [ nombre_indice ] (columna_indice )

[ CONSTRAINT nombre ] FOREING KEY [ nombre_indice ] (columna_indice ) [ referencia ]

CHECK ( expresión) }

La parte de la sentencia CREATE TABLE referencia tiene la siguiente sintaxis:

REFERENCES nombre_tabla [ ( columnas_indice) ]

[ ON DELETE {RESTRICT | CASCADE | SET NULL | NO ACTION | SET DEFAULT } ]

[ ON UPDATE {RESTRICT | CASCADE | SET NULL | NO ACTION | SET DEFAULT } ]

[ MATCH FULL | MATCH PARTIAL

TEMPORARY indica que la tabla que se crea solamente existe hasta que finalice la conexión del índice actual. IF NOT EXISTS

provoca que no se cree la tabla si existe otra con el mismo nombre y que no haya errores. mysql> CREATE TABLE gente (nombre VARCHAR(40), fecha DATE);



Podemos consultar cuántas tablas y qué nombres tienen en una base de datos, usando la sentencia SHOW TABLES mysql> SHOW TABLES;

+------------------+

| Tables_in_prueba |

+------------------+

| gente |

+------------------+

La sintaxis para definir columnas es:

nombre_col tipo [NOT NULL | NULL] [DEFAULT valor_por_defecto] [AUTO_INCREMENT] [[PRIMARY] KEY]

[COMMENT 'string'] [definición_referencia]

Valores nulos: Al definir cada columna podemos decidir si podrá o no contener valores nulos. La opción por defecto

es que se permitan valores nulos, NULL, y para que no se permitan, se usa NOT NULL. Por ejemplo:

mysql>CREATE TABLE ciudad1(nombre CHAR(20) NOT NULL, poblacion INT NULL);

Valores por defecto: Para cada columna también se puede definir, opcionalmente, un valor por defecto. El valor por

defecto se asignará de forma automática a una columna cuando no se especifique un valor determinado al añadir filas.

Si una columna puede tener un valor nulo, y no se especifica un valor por defecto, se usará NULL como valor por defecto. En

el ejemplo anterior, el valor por defecto para poblacion es NULL. Por ejemplo, si queremos que el valor por defecto para

población sea 5000, podemos crear la tabla como:

mysql>CREATE TABLE ciudad2(nombre CHAR(20) NOT NULL, poblacion INT NULL DEFAULT 5000);

Claves primaria: También se puede definir una clave primaria sobre una columna, usando la palabra clave KEY o

PRIMARY KEY.

mysql> CREATE TABLE ciudad3 (nombre CHAR(20) NOT NULL PRIMARY KEY, poblacion INT NULL DEFAULT 5000);

mysql> CREATE TABLE ciudad3 (nombre CHAR(20) NOT NULL, poblacion INT NULL DEFAULT 5000, PRIMARY

KEY(nombre));

Usar NOT NULL PRIMARY KEY equivale a PRIMARY KEY, NOT NULL KEY o sencillamente KEY.

Columnas autoincrementadas: En MySQL tenemos la posibilidad de crear una columna autoincrementada, aunque

esta columna sólo puede ser de tipo entero.

Si al insertar una fila se omite el valor de la columna autoincrementada o si se inserta un valor nulo para esa columna, su valor

se calcula automáticamente, tomando el valor más alto de esa columna y sumándole una unidad. Esto permite crear, de una

forma sencilla, una columna con un valor único para cada fila de la tabla.

Generalmente, estas columnas se usan como claves primarias 'artificiales'. MySQL está optimizado para usar valores

enteros como claves primarias, de modo que la combinación de clave primaria, que sea entera y autoincrementada es ideal

para usarla como clave primaria artificial:

mysql> CREATE TABLE ciudad5 (clave INT AUTO_INCREMENT PRIMARY KEY, nombre CHAR(20) NOT NULL,poblacion

INT NULL DEFAULT 5000);

Comentario: Adicionalmente, al crear la tabla, podemos añadir un comentario a cada columna. Este comentario sirve como

información adicional sobre alguna característica especial de la columna, y entra en el apartado de documentación de la base

de datos:



mysql> CREATE TABLE ciudad6(clave INT AUTO_INCREMENT PRIMARY KEY COMMENT 'Clave principal',nombre

CHAR(50) NOT NULL, poblacion INT NULL DEFAULT 5000);

mysql> show full columns from ciudad6;

2.2 Actualización, modificación y eliminación del esquema de la base de datos.

Además de los comandos: Create database, use, create table, show database y show tables, también son DLL‟s: ALTER TABLE y

DROP

SOBRE LAS MODIFICACION DE LAS TABLAS Y COLUMNAS

INTRUCCION EXPLICACIÓN

ALTER TABLE ejemplo ENGINE = InnoDB;

Cambiar el tipo de motor (engine) de la tabla 'ejemplo'

ALTER TABLE personas RENAME usuarios;

Cambia el nombre de la tabla 'personas' a 'usuarios'

ALTER TABLE ejemplo

AUTO_INCREMENT=1000;

En la tabla 'ejemplo' cualquiera que sea la columna que tenga

'AUTO_INCREMENT' en sus propiedades (solo puede haber una), los

nuevos registros comenzarán a partir de '1000' o cualquier número

indicado, no es posible utilizar un valor ya existente.

OPERACIONES CON DROP

ALTER TABLE ejemplo DROP nombre; Elimina la columna 'nombre' de la tabla 'ejemplo'.

ALTER TABLE ejemplo DROP nombre, DROP

paterno;

Elimina más de una columna.

DROP INDEX nombre on clientes; Elimina el índice „nombre' de la tabla “clientes”

ALTER TABLE ejemplo DROP PRIMARY KEY; Elimina la llave primaria de la tabla 'ejemplo'

ALTER TABLE ejemplo DROP FOREIGN KEY

id_foreign key;

Elimina de la tabla 'ejemplo' la llave foranea 'id_foreign key'.

DROP TABLE alumnos; Elimina la tabla llamada “alumnos”

DROP DATABASE video; Elimina la base de datos llamada “video”

OPERACIONES CON CHANGE Y MODIFY

ALTER TABLE ejemplo CHANGE monto

cantidad FLOAT(8,2);

Cambia el nombre de la columna 'monto' al nuevo nombre 'cantidad'

con la definición del tipo de datos.

ALTER TABLE ejemplo CHANGE cantidad

cantidad FLOAT(10,2);

Cambia solo el tipo de datos de la columna, conservando el mismo

nombre.

ALTER TABLE ejemplo MODIFY cantidad

FLOAT(10,2);

Cambia solo el tipo de datos de la columna, conservando el mismo

nombre. (Igual que el anterior)

ALTER TABLE ejemplo MODIFY cantidad

FLOAT(6,2) NOT NULL;

Cambia el tipo de datos de la columna 'cantidad' y especifica que no

admite nulos.

ALTER TABLE ejemplo MODIFY paterno

VARCHAR(30)

Modifica el tamaño de la columna 'paterno'.

OPERACIONES CON ADD

ALTER TABLE ejemplo ADD fecha DATE;

Añade una columna llamada 'fecha' del tipo 'DATE' al final de todas

las demás existentes.

ALTER TABLE ejemplo ADD

INDEX(categoria);

Añade un índice a la columna 'categoria'.

ALTER TABLE ejemplo ADD

INDEX(categoria), ADD PRIMARY KEY(clave);

Añade un índice a la columna 'categoria' y además crea la llave

primaria en la columna 'clave'.



ALTER TABLE ejemplo ADD UNIQUE(email); Añade a la columna 'email' un índice del tipo único, no puede haber

dos iguales.

ALTER TABLE ejemplo ADD consecutivo

BIGINT AUTO_INCREMENT, ADD

INDEX(consecutivo);

Añade la columna 'consecutivo' con la característica de auto

incremento y además genera un índice sobre la misma.

ALTER TABLE ejemplo ADD materno

VARCHAR(20) AFTER paterno;

Añade la columna 'materno' después de la columna 'paterno'.

ALTER TABLE ejemplo ADD id INT FIRST;

Añade la columna 'id' en primer lugar con respecto a las existentes.

ALTER TABLE usuarios ADD FOREIGN KEY(id

fk) REFERENCES entradas(id_pk)

Añade un 'Foreign key' en la columna 'id fk' de la tabla 'usuarios' que

apunta a la columna 'id_pk' de la tabla 'entradas'.

alter table ejemplo drop campo1, add

campo2, change campo3

campo4 int(8);

Varias operaciones a la vez mediante la instrucción alter table

ALTER table alumno

MODIFY COLUMN apaterno

varchar(30)

AFTER amaterno;

Cambiar el orden de las columnas

Restricciones a columnas:

a) Para una llave primaria: constraint actores_codact_pk primary key(codact)

constraint actuacion_codactcodpel_pk primary key(codact,

codpel)

b) Para una llave foránea: constraint peliculas_coddir_fk foreign key(coddir)

references directores(coddir)

c) Para una columna unica Constraint alumnos_email_uq unique(email)

d) Chequeo de columnas(integridad de dominios) Constraint alumnos_edad_ck check(edad between 5 and 20)

Constraint alumnos_nombremayus_ck

check(nombre=upper(nombre))

Constraint alumnos_curso_ck check(curso IN (1,2,3))

Constraint alumnos_sexo_ck check (sexo in (‘Hombre’, ‘mujer’))

Integridad referencial: Una clave secundaria (externa o foránea) en una base de datos relacional enlaza cada fila de

la tabla hijo que contiene la clave foránea con la fila de la tabla padre que contiene el valor de clave primaria correspondiente.

Problemas de integridad referencial

Existen cuatro tipos de actualizaciones de bases de datos que pueden corromper la integridad referencial de las

relaciones padre/hijo de una base de datos.

1. La inserción de una nueva fila hijo:

2. La actualización de la clave foránea en una fila hijo:

3. La supresión de una fila padre:

4. La actualización de la clave primaria en una fila padre:

N O T A

Las restricciones de integridad referencial

aseguran que las relaciones entre entidades en

la base de datos se preserven durante las

actualizaciones. En particular, la integridad

referencial debe incluir reglas que indiquen

cómo manejar la supresión de filas que son

referenciadas mediante otras filas.

T A R E A:

Investigue en que consiste cada una de

actualizaciones.



Claves foráneas en MySQL

Estrictamente hablando, para que un campo sea una clave foránea, éste necesita ser definido como tal al momento

de crear una tabla. Se pueden definir claves foráneas en cualquier tipo de tabla de MySQL, pero únicamente tienen sentido

cuando se usan tablas del tipo InnoDB.

Para trabajar con claves foráneas, necesitamos hacer lo siguiente:

1. Crear ambas tablas del tipo InnoDB.

2. Usar la sintaxis FOREIGN KEY(campo_fk) REFERENCES nombre_tabla (nombre_campo)

3. Crear un índice en el campo que ha sido declarado clave foránea.

4. Definir el campo foráneo del mismo tipo, al campo que hará referencia (la llave primaria de la tabla padre)

5. No necesariamente la llave foránea se llamará igual

EJEMPLO 01. Definiendo llaves foráneas en el momento de la creación de la tabla

CREATE TABLE cliente(id_cliente INT NOT NULL, nombre VARCHAR(30), PRIMARY KEY (id_cliente)) TYPE =

INNODB;

CREATE TABLE venta(id_factura INT NOT NULL,id_cliente INT NOT NULL,cantidad INT,PRIMARY

KEY(id_factura), FOREIGN KEY (id_cliente) REFERENCES cliente(id_cliente)) TYPE = INNODB;

La sintaxis completa de una restricción de clave foránea es la siguiente:

[CONSTRAINT símbolo] FOREIGN KEY (nombre_columna, ...)

REFERENCES nombre_tabla (nombre_columna, ...)

[ON DELETE {CASCADE | SET NULL | NO ACTION

| RESTRICT}]

[ON UPDATE {CASCADE | SET NULL | NO ACTION

| RESTRICT}]

NOTA:

Las columnas correspondientes en la clave foránea y en la clave referenciada deben tener tipos de datos

similares para que puedan ser comparadas sin la necesidad de hacer una conversión de tipos. El tamaño y el signo de los

tipos enteros debe ser el mismo. En las columnas de tipo caracter, el tamaño no tiene que ser el mismo necesariamente.

Una vez que hemos creado las tablas, vamos a insertar algunos datos que nos sirvan para demostrar algunos

conceptos importantes: mysql> INSERT INTO cliente VALUES(1,'Juan Penas');

mysql> INSERT INTO cliente VALUES(2,'Pepe el toro');

mysql> INSERT INTO venta VALUES(1,1,23);


En este momento no hay ningún problema, sin embargo, vamos a ver qué sucede cuando intentamos insertar un

registro en la tabla venta que se refiera a un cliente no existente cuyo id_cliente es 3:


ERROR 1216: Cannot add or update a child row: a foreign key constraint fails

El hecho es que MySQL no nos permite insertar este registro, ya que el cliente cuyo id_cliente es 3 no existe. La

restricción de clave foránea asegura que nuestros datos mantienen su integridad. Sin embargo, ¿qué sucede cuando

eliminamos algún registro?. Vamos a agregar un nuevo cliente, y un nuevo registro en la tabla venta, posteriormente

eliminaremos el registro de nuestro tercer cliente:

mysql> INSERT INTO cliente VALUES(3,'Pepe pecas');



Query OK, 1 row affected (0.05 sec)


Query OK, 1 row affected (0.05 sec)

mysql> DELETE FROM cliente WHERE id_cliente=3;

ERROR 1217: Cannot delete or update a parent row: a foreign key constraint fails

Debido a nuestra restricción de clave foránea, MySQL no permite que eliminemos el registro de cliente cuyo id_cliente

es 3, ya que se hace referencia a éste en la tabla venta. De nuevo, se mantiene la integridad de nuestros datos. Sin embargo

existe una forma en la cuál podríamos hacer que la sentencia DELETE se ejecute de cualquier manera, y la veremos

brevemente, pero primero necesitamos saber cómo eliminar (quitar) una clave foránea.

EJEMPLO 02. Añadiendo una llave foránea a una tabla existente, USANDO ALTER

Por ejemplo, la creación de la clave foránea en la tabla venta que se mostró anteriormente pudo haberse hecho de la

siguiente manera con el uso de una sentencia ALTER TABLE:

CREATE TABLE venta

(

id_factura INT NOT NULL,

id_cliente INT NOT NULL,

cantidad INT,

PRIMARY KEY(id_factura),

INDEX (id_cliente)

) TYPE = INNODB;

ALTER TABLE venta ADD FOREIGN KEY(id_cliente) REFERENCES cliente(id_cliente);

Eliminación de una clave foránea

No podemos sólo eliminar una restricción de clave foránea como si fuera un índice ordinario. Veamos que sucede

cuando lo intentamos.

mysql> ALTER TABLE venta DROP FOREIGN KEY;

ERROR 1005: Can't create table '.test#sql-228_4.frm' (errno: 150)

Para eliminar la clave foránea se tiene que especificar el ID que ha sido generado y asignado internamente por

MySQL a la clave foránea. En este caso, se puede usar la sentencia SHOW CREATE TABLE para determinar dicho ID.

mysql> show create table ejemplares;

-----------------------+

| ejemplares | CREATE TABLE èjemplares` (

`codejem` varchar(6) NOT NULL DEFAULT '',

èstado` varchar(30) DEFAULT NULL,

`codpel` varchar(6) DEFAULT NULL,

PRIMARY KEY (`codejem`),

KEY `codpel` (`codpel`),

CONSTRAINT èjemplares_ibfk_1` FOREIGN KEY (`codpel`) REFERENCES `peliculas` (

`codpel`)

) ENGINE=InnoDB DEFAULT CHARSET=latin1 |

+------------+------------------------------------------------------------------

En nuestro ejemplo, la restricción tiene el ID ejemplares_ibfk_1 (es muy probable que este valor sea diferente en cada

caso).

mysql> ALTER TABLE venta DROP FOREIGN KEY ejemplares_ibfk_1;



Eliminación de registros con claves foráneas

Una de las principales bondades de las claves foráneas es que permiten eliminar y actualizar registros en cascada.

Con las restricciones de clave foránea podemos eliminar un registro de la tabla cliente y a la vez eliminar un registro

de la tabla venta usando sólo una sentencia DELETE. Esto es llamado eliminación en cascada, en donde todos los registros

relacionados son eliminados de acuerdo a las relaciones de clave foránea. Una alternativa es no eliminar los registros

relacionados, y poner el valor de la clave foránea a NULL (asumiendo que el campo puede tener un valor nulo). En nuestro

caso, no podemos poner el valor de nuestra clave foránea id_cliente en la tabla venta, ya que se ha definido como NOT NULL.

Las opciones estándar cuando se elimina un registro con clave foránea son:

ON DELETE RESTRICT es la acción predeterminada, y no permite una eliminación si existe un registro asociado,

como se mostró en el ejemplo anterior. ON DELETE NO ACTION hace lo mismo.

ON DELETE SET DEFAULT actualmente no funciona en MySQL - se supone que pone el valor de la clave foránea al

valor por omisión (DEFAULT) que se definió al momento de crear la tabla.

Si se especifica ON DELETE CASCADE, y una fila en la tabla padre es eliminada, entonces se eliminarán las filas de la

tabla hijo cuya clave foránea sea igual al valor de la clave referenciada en la tabla padre. Esta acción siempre ha estado

disponible en MySQL.

Si se especifica ON DELETE SET NULL, las filas en la tabla hijo son actualizadas automáticamente poniendo en las

columnas de la clave foránea el valor NULL. Si se especifica una acción SET NULL, debemos asegurarnos de no declarar las

columnas en la tabla como NOT NULL.

A continuación se muestra un ejemplo de eliminación en cascada: mysql> ALTER TABLE venta ADD FOREIGN KEY(id_cliente)REFERENCES cliente(id_cliente) ON DELETE CASCADE;

Vamos a ver cómo están nuestros registros antes de ejecutar la sentencia DELETE:

mysql> SELECT * FROM cliente;

+------------+--------------+

| id_cliente | nombre |

+------------+--------------+

| 1 | Juan Penas |

| 2 | Pepe el toro |

| 3 | Pepe pecas |

+------------+--------------+

mysql> SELECT * FROM venta;

+------------+------------+----------+

| id_factura | id_cliente | cantidad |

+------------+------------+----------+

| 1 | 1 | 23 |

| 2 | 3 | 39 |

| 3 | 2 | 81 |

+------------+------------+----------+

Ahora eliminaremos a Pepe Pecas de la base de datos:

mysql> DELETE FROM cliente WHERE id_cliente=3;


+------------+------------+----------+


+------------+------------+----------+

| 1 | 1 | 23 |

| 3 | 2 | 81 |

+------------+------------+----------+



mysql> SELECT * FROM cliente;

+------------+--------------+

| id_cliente | nombre |

+------------+--------------+

| 1 | Juan Penas |

| 2 | Pepe el toro |

+------------+--------------+

Con la eliminación en cascada, se ha eliminado el registro de la tabla venta al que estaba relacionado Pepe Pecas.

Actualización de registros con claves foráneas

Estas opciones son muy similares cuando se ejecuta una sentencia UPDATE, en lugar de una sentencia DELETE. Estas

son:

ON UPDATE CASCADE

ON UPDATE SET NULL

ON UPDATE RESTRICT

Vamos a ver un ejemplo, pero antes que nada, tenemos que eliminar la restricción de clave foránea (debemos usar el

ID específico de nuestra tabla). mysql> ALTER TABLE venta DROP FOREIGN KEY 0_26;

mysql> ALTER TABLE venta ADD FOREIGN KEY(id_cliente)REFERENCES cliente(id_cliente) ON DELETE RESTRICT

ON UPDATE CASCADE;

NOTA: Se debe especificar ON DELETE antes de ON UPDATE, ya que de otra manera se recibirá un error al definir la

restricción.

Ahora está lista la clave foránea para una actualización en cascada. Este es el ejemplo:


+------------+------------+----------+


+------------+------------+----------+

| 1 | 1 | 23 |

| 3 | 2 | 81 |

+------------+------------+----------+

mysql> UPDATE cliente SET id_cliente=10 WHERE id_cliente=1;


+------------+------------+----------+


+------------+------------+----------+

| 1 | 10 | 23 |

| 3 | 2 | 81 |

+------------+------------+----------+

En este caso, al actualizar el valor de id_cliente en la tabla cliente, se actualiza de manera automática el valor de la

clave foránea en la tabla venta. Esta es la actualización en cascada.

Un ejemplo más

Observar y estudiar detenidamente el diagrama entidad/relación de la figura que se muestra a continuación.



CREATE TABLE libro (id_libro INT NOT NULL, titulo VARCHAR(100) NULL, precio NUMERIC(5,2) NULL, PRIMARY

KEY(id_libro)) engine=InnoDB;

CREATE TABLE escritor (id_escritor INT NOT NULL, nombre VARCHAR(30) NULL,

apellidos VARCHAR(40) NULL, direccion VARCHAR(100) NULL, PRIMARY KEY(id_escritor)) engine=InnoDB;

CREATE TABLE poema (id_poema INT NOT NULL, id_escritor INT NOT NULL, titulo VARCHAR(50) NULL,

contenido TEXT NULL, PRIMARY KEY(id_poema), INDEX(id_escritor), FOREIGN KEY(id_escritor) REFERENCES

escritor(id_escritor) ON DELETE CASCADE ON UPDATE CASCADE ) Engine=InnoDB;

CREATE TABLE poema_libro (

id_poema INT NOT NULL, id_libro INT NOT NULL, PRIMARY KEY(id_poema, id_libro), INDEX

(id_poema), INDEX(id_libro), FOREIGN KEY(id_poema) REFERENCES poema(id_poema) ON DELETE CASCADE ON

UPDATE CASCADE, FOREIGN KEY(id_libro) REFERENCES libro(id_libro) ON DELETE CASCADE ON UPDATE

CASCADE ) Engine=InnoDB;



Unidad TRES: Lenguaje de

manipulación de datos(DML)


Manipular

bases de datos a través

de un SGBD.


Analizar la base de datos a manipular, basándose en el modelo conceptual o físico de la misma.

Realizar la inserción, modificación y borrado de registros en las tablas de la base de datos verificando la

integridad de los datos.

Diseñar e implementar distintas consultas para la recuperación de datos.

Crear consultas de recuperación de datos con distintas restricciones.

Crear consultas con distintos tipos de agrupación de datos.

Desarrollar prácticas de laboratorio para reafirmar conceptos.

Elaborar reportes de las prácticas e integrarlos al portafolio de evidencias.

Presentar resultados por parte de los alumnos.



3.1 Inserción, eliminación y modificación de registros

Insert

La forma más directa de insertar una fila nueva en una tabla es mediante una sentencia INSERT. En la forma más simple de

esta sentencia debemos indicar la tabla a la que queremos añadir filas, y los valores de cada columna. Las columnas de tipo

cadena o fechas deben estar entre comillas sencillas o dobles, para las columnas numéricas esto no es imprescindible, aunque

también pueden estar entrecomilladas.

mysql> INSERT INTO gente VALUES ('Fulano','1974-04-12');

mysql> INSERT INTO gente VALUES ('Mengano','1978-06-15');

mysql> INSERT INTO gente VALUES('Tulano','2000-12-02'),('Pegano','1993-02-10');

mysql> SELECT * FROM gente;

+---------+------------+

| nombre | fecha |

+---------+------------+

| Fulano | 1974-04-12 |

| Mengano | 1978-06-15 |

| Tulano | 2000-12-02 |

| Pegano | 1993-02-10 |

+---------+------------+

Si no necesitamos asignar un valor concreto para alguna columna, podemos asignarle el valor por defecto indicado para esa

columna cuando se creó la tabla, usando la palabra DEFAULT:

mysql> INSERT INTO ciudad2 VALUES ('Perillo', DEFAULT);

mysql> SELECT * FROM ciudad2;

+---------+-----------+

| nombre | poblacion |

+---------+-----------+

| Perillo | 5000 |

+---------+-----------+

En este caso, como habíamos definido un valor por defecto para población de 5000, se asignará ese valor para la fila

correspondiente a 'Perillo'.

Otra opción consiste en indicar una lista de columnas para las que se van a suministrar valores. A las columnas que no se

nombren en esa lista se les asigna el valor por defecto. Este sistema, además, permite usar cualquier orden en las columnas,

con la ventaja, con respecto a la anterior forma, de que no necesitamos conocer el orden de las columnas en la tabla para

poder insertar datos:

mysql> INSERT INTO ciudad5 (poblacion,nombre) VALUES (7000000, 'Madrid'), (9000000,

'París'), (3500000, 'Berlín');


+-------+--------+-----------+

| clave | nombre | poblacion |

+-------+--------+-----------+

| 1 | Madrid | 7000000 |

| 2 | París | 9000000 |

| 3 | Berlín | 3500000 |

+-------+--------+-----------+



Cuando creamos la tabla "ciudad5" definimos tres columnas: 'clave', 'nombre' y 'poblacion' (por ese orden). Ahora hemos

insertado tres filas, en las que hemos omitido la clave, y hemos alterado el orden de 'nombre' y 'poblacion'. El valor de la

'clave' se calcula automáticamente, ya que lo hemos definido como auto-incrementado.

Existe otra sintaxis alternativa, que consiste en indicar el valor para cada columna:

mysql> INSERT INTO ciudad5 SET nombre='Roma', poblacion=8000000;


+-------+--------+-----------+


+-------+--------+-----------+

| 1 | Madrid | 7000000 |

| 2 | París | 9000000 |

| 3 | Berlín | 3500000 |

| 4 | Roma | 8000000 |

+-------+--------+-----------+

Una vez más, a las columnas para las que no indiquemos valores se les asignarán sus valores por defecto. También podemos

hacer esto usando el valor DEFAULT.

Para las sintaxis que lo permiten, podemos observar que cuando se inserta más de una fila en una única sentencia,

obtenemos un mensaje desde MySQL que indica el número de filas afectadas, el número de filas duplicadas y el número de

avisos. Para que una fila se considere duplicada debe tener el mismo valor que una fila existente para una clave principal o

para una clave única. En tablas en las que no exista clave primaria ni índices de clave única no tiene sentido hablar de filas

duplicadas. Es más, en esas tablas es perfectamente posible que existan filas con los mismos valores para todas las columnas.

Por ejemplo, en mitabla5 tenemos una clave única sobre la columna 'nombre':

mysql> INSERT INTO mitabla5 (id, nombre) VALUES (1, 'Carlos'), (2, 'Felipe'),(3,

'Antonio'),(4, 'Carlos'),(5, 'Juan');

ERROR 1062 (23000): Duplicate entry 'Carlos' for key 1

Si intentamos insertar dos filas con el mismo valor de la clave única se produce un error y la sentencia no se ejecuta. Pero

existe una opción que podemos usar para los casos de claves duplicadas: ON DUPLICATE KEY UPDATE. En este caso podemos

indicar a MySQL qué debe hacer si se intenta insertar una fila que ya existe en la tabla. Las opciones son limitadas: no

podemos insertar la nueva fila, sino únicamente modificar la que ya existe. Por ejemplo, en la tabla 'ciudad3' podemos usar el

último valor de población en caso de repetición:

mysql> INSERT INTO ciudad3 (nombre, poblacion) VALUES('Madrid', 7000000);

mysql> INSERT INTO ciudad3 (nombre, poblacion) VALUES

('París', 9000000),

('Madrid', 7200000)

ON DUPLICATE KEY UPDATE poblacion=VALUES(poblacion);


+--------+-----------+


+--------+-----------+

| Madrid | 7200000 |

| París | 9000000 |

+--------+-----------+

En este ejemplo, la segunda vez que intentamos insertar la fila correspondiente a 'Madrid' se usará el nuevo valor de

población. Si en lugar de VALUES(poblacion) usamos población el nuevo valor de población se ignora. También podemos

usar cualquier expresión:




-> ('París', 9100000)

-> ON DUPLICATE KEY UPDATE poblacion=poblacion;


+--------+-----------+


+--------+-----------+

| Madrid | 7200000 |

| París | 9000000 |

+--------+-----------+


-> ('París', 9100000)

-> ON DUPLICATE KEY UPDATE poblacion=0;


+--------+-----------+


+--------+-----------+

| Madrid | 7200000 |

| París | 0 |

+--------+-----------+

Update

Podemos modificar valores de las filas de una tabla usando la sentencia UPDATE. En su forma más simple, los cambios se

aplican a todas las filas, y a las columnas que especifiquemos.

UPDATE [LOW_PRIORITY] [IGNORE] tbl_name

SET col_name1=expr1 [, col_name2=expr2 ...]

[WHERE where_definition]

[ORDER BY ...]

[LIMIT row_count]

Por ejemplo, podemos aumentar en un 10% la población de todas las ciudades de la tabla ciudad3 usando esta sentencia:

mysql> UPDATE ciudad3 SET poblacion=poblacion*1.10;


+---------+-----------+


+---------+-----------+

| Berlín | 6600000 |

| Londres | 11000000 |

| Madrid | 7920000 |

| París | 10120000 |

| Roma | 10450000 |

+---------+-----------+

Podemos, del mismo modo, actualizar el valor de más de una columna, separándolas en la sección SET mediante comas:

mysql> UPDATE ciudad5 SET clave=clave+10, poblacion=poblacion*0.97;


+-------+--------+-----------+




+-------+--------+-----------+

| 11 | Madrid | 6790000 |

| 12 | París | 8730000 |

| 13 | Berlín | 3395000 |

| 14 | Roma | 7760000 |

+-------+--------+-----------+

En este ejemplo hemos incrementado el valor de la columna 'clave' en 10 y disminuido el de la columna 'poblacion' en un 3%,

para todas las filas.

Pero no tenemos por qué actualizar todas las filas de la tabla. Podemos limitar el número de filas afectadas de varias formas.

La primera es mediante la cláusula WHERE. Usando esta cláusula podemos establecer una condición. Sólo las filas que

cumplan esa condición serán actualizadas:

mysql> UPDATE ciudad5 SET poblacion=poblacion*1.03 WHERE nombre='Roma';


+-------+--------+-----------+


+-------+--------+-----------+

| 11 | Madrid | 6790000 |

| 12 | París | 8730000 |

| 13 | Berlín | 3395000 |

| 14 | Roma | 7992800 |

+-------+--------+-----------+

En este caso sólo hemos aumentado la población de las ciudades cuyo nombre sea 'Roma'. Las condiciones pueden ser más

complejas. Existen muchas funciones y operadores que se pueden aplicar sobre cualquier tipo de columna, y también

podemos usar operadores booleanos como AND u OR.

Otra forma de limitar el número de filas afectadas es usar la cláusula LIMIT. Esta cláusula permite especificar el número de

filas a modificar:

mysql> UPDATE ciudad5 SET clave=clave-10 LIMIT 2;


+-------+--------+-----------+


+-------+--------+-----------+

| 1 | Madrid | 6790000 |

| 2 | París | 8730000 |

| 13 | Berlín | 3395000 |

| 14 | Roma | 7992800 |

+-------+--------+-----------+

En este ejemplo hemos decrementado en 10 unidades la columna clave de las dos primeras filas.Esta cláusula se puede

combinar con WHERE, de modo que sólo las 'n' primeras filas que cumplan una determinada condición se modifiquen.

Sin embargo esto no es lo habitual, ya que, si no existen claves primarias o únicas, el orden de las filas es arbitrario, no tiene

sentido seleccionarlas usando sólo la cláusula LIMIT.

La cláusula LIMIT se suele asociar a la cláusula ORDER BY. Por ejemplo, si queremos modificar la fila con la fecha más antigua

de la tabla 'gente', usaremos esta sentencia:

mysql> UPDATE gente SET fecha="1985-04-12" ORDER BY fecha LIMIT 1;




+---------+------------+

| nombre | fecha |

+---------+------------+

| Fulano | 1985-04-12 |

| Mengano | 1978-06-15 |

| Tulano | 2000-12-02 |

| Pegano | 1993-02-10 |

+---------+------------+

Si queremos modificar la fila con la fecha más reciente, usaremos el orden inverso, es decir, el descendente:

mysql> UPDATE gente SET fecha="2001-12-02" ORDER BY fecha DESC LIMIT 1;


+---------+------------+

| nombre | fecha |

+---------+------------+

| Fulano | 1985-04-12 |

| Mengano | 1978-06-15 |

| Tulano | 2001-12-02 |

| Pegano | 1993-02-10 |

+---------+------------+

Cuando exista una clave primaria o única, se usará ese orden por defecto, si no se especifica una cláusula ORDER BY.

Delete

Para eliminar filas se usa la sentencia DELETE. La sintaxis es muy parecida a la de UPDATE:

DELETE [LOW_PRIORITY] [QUICK] [IGNORE] FROM table_name

[WHERE where_definition]

[ORDER BY ...]

[LIMIT row_count]

La forma más simple es no usar ninguna de las cláusulas opcionales:

mysql> DELETE FROM ciudad3;

De este modo se eliminan todas las filas de la tabla.

Pero es más frecuente que sólo queramos eliminar ciertas filas que cumplan determinadas condiciones. La forma más normal

de hacer esto es usar la cláusula WHERE:

mysql> DELETE FROM ciudad5 WHERE clave=2;


+-------+--------+-----------+


+-------+--------+-----------+

| 1 | Madrid | 6790000 |

| 13 | Berlín | 3395000 |

| 14 | Roma | 7992800 |

+-------+--------+-----------+

También podemos usar las cláusulas LIMIT y ORDER BY del mismo modo que en la sentencia UPDATE, por ejemplo, para

eliminar las dos ciudades con más población:

mysql> DELETE FROM ciudad5 ORDER BY poblacion DESC LIMIT 2;




+-------+--------+-----------+


+-------+--------+-----------+

| 13 | Berlín | 3395000 |

+-------+--------+-----------+

3.2 Consultas de registros

3.2.1 Recuperación de datos

3.2.2 Restricción y ordenación de datos

3.2.3 Informes de datos agregados mediante funciones de grupo

3.2.4 Visualización de datos de varias tablas

3.2.5 Subconsultas

3.2.6 Operadores set



Unidad CUATRO: Seguridad


Definir e implementar

esquemas de seguridad

a través de un SGBD.


Diseñar un esquema de seguridad para una base de datos anteriormente creada.

Crear las “tablas virtuales” necesarias para restringir el acceso a información confidencial o facilitar

consultas complejas.

Aplicar el concepto de autorizaciones a objetos de la base de datos, asignando privilegios sobre objetos.

Analizar y definir las funciones, objetos y tipos de acceso que tendrán los grupos de usuarios.

Desarrollar prácticas para aplicar esquemas de seguridad y restringir el acceso a la información.

Desarrollar ejercicios donde utilice vistas para seguridad y simplificación de consultas.

Elaborar reportes de prácticas e integrarlos al portafolio de evidencias.

Presentar resultados por parte del alumno.

4.1 Tipos de usuario

4.2 Creación de usuarios

4.3 Privilegios a usuarios

4.4 Roles

4.5 Vistas

Antologia de taller de base de datos 1 26

Education

Transcript of Antologia de taller de base de datos 1 26