Antologia de Taller de Base de Datos 1-26

35  19  Descargar (0)

Texto completo

(1)

SCA-1025

Antología de la Materia de Taller

de Base de Datos

Compilación Hecha por:

MTIJHR

Ingeniería

en Sistemas

Computacio

nales

(2)

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

C

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

D

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

C

onstruir modelos de bases de datos.

A

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

A

plicar operaciones básicas SQL.

C

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

I

mplementar restricciones de integridad.

D

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

C

rear esquemas de bases de datos en un SGBD.

M

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

C

onocer distintas plataformas y SGBD.

(3)

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

(4)

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.

(5)

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.

(6)

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

(7)

• 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:

(8)

• 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.

(9)

• 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:

(10)

• 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).

(11)

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:

(12)

Seleccionamos el protocolo a utilizar (TCP):

Seleccionamos el puerto a utilizar, por defecto 1521:

(13)

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

(14)

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

(15)

• 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, …).

(16)

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

(17)

Unidad DOS: Lenguaje de

definición de datos(DDL)

Competencia específica a desarrollar:

Implementar esquemas de

bases de datos a través

de SQL en un SGBD

.

Actividades de Aprendizaje:

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.

(18)

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.

(19)

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

(20)

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'.

(21)

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.

(22)

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);

mysql> INSERT INTO venta VALUES(3,2,81);

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:

mysql> INSERT INTO venta VALUES(2,3,39);

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:

(23)

Query OK, 1 row affected (0.05 sec) mysql> INSERT INTO venta VALUES(2,3,39); 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 `ejemplares` ( `codejem` varchar(6) NOT NULL DEFAULT '', `estado` varchar(30) DEFAULT NULL,

`codpel` varchar(6) DEFAULT NULL, PRIMARY KEY (`codejem`),

KEY `codpel` (`codpel`),

CONSTRAINT `ejemplares_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).

(24)

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; mysql> SELECT * FROM venta;

+---+---+---+ | id_factura | id_cliente | cantidad | +---+---+---+ | 1 | 1 | 23 | | 3 | 2 | 81 | +---+---+---+

(25)

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:

mysql> SELECT * FROM venta;

+---+---+---+ | id_factura | id_cliente | cantidad | +---+---+---+ | 1 | 1 | 23 | | 3 | 2 | 81 | +---+---+---+

mysql> UPDATE cliente SET id_cliente=10 WHERE id_cliente=1; mysql> SELECT * FROM venta;

+---+---+---+ | id_factura | id_cliente | cantidad | +---+---+---+ | 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

(26)

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;

(27)

Unidad TRES: Lenguaje de

manipulación de datos(DML)

Competencia específica a desarrollar:

Manipular

bases de datos a través

de un SGBD

.

Actividades de Aprendizaje:

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.

(28)

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');

mysql> SELECT * FROM ciudad5; +---+---+---+ | clave | nombre | poblacion | +---+---+---+ | 1 | Madrid | 7000000 | | 2 | París | 9000000 | | 3 | Berlín | 3500000 | +---+---+---+

(29)

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; mysql> SELECT * FROM ciudad5;

+---+---+---+ | clave | nombre | poblacion | +---+---+---+ | 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); mysql> SELECT * FROM ciudad3;

+---+---+ | nombre | poblacion | +---+---+ | Madrid | 7200000 | | París | 9000000 | +---+---+

(30)

mysql> INSERT INTO ciudad3 (nombre, poblacion) VALUES -> ('París', 9100000)

-> ON DUPLICATE KEY UPDATE poblacion=poblacion; mysql> SELECT * FROM ciudad3;

+---+---+ | nombre | poblacion | +---+---+ | Madrid | 7200000 | | París | 9000000 | +---+---+

mysql> INSERT INTO ciudad3 (nombre, poblacion) VALUES -> ('París', 9100000)

-> ON DUPLICATE KEY UPDATE poblacion=0; mysql> SELECT * FROM ciudad3;

+---+---+ | nombre | poblacion | +---+---+ | 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; mysql> SELECT * FROM ciudad3;

+---+---+ | nombre | poblacion | +---+---+ | 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; mysql> SELECT * FROM ciudad5;

(31)

| clave | nombre | poblacion | +---+---+---+ | 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'; mysql> SELECT * FROM ciudad5;

+---+---+---+ | clave | nombre | poblacion | +---+---+---+ | 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; mysql> SELECT * FROM ciudad5;

+---+---+---+ | clave | nombre | poblacion | +---+---+---+ | 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:

(32)

+---+---+ | 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; mysql> SELECT * FROM gente;

+---+---+ | 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; mysql> SELECT * FROM ciudad5;

+---+---+---+ | clave | nombre | poblacion | +---+---+---+ | 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:

(33)

mysql> SELECT * FROM ciudad5; +---+---+---+ | clave | nombre | poblacion | +---+---+---+ | 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

(34)

Unidad CUATRO: Seguridad

Competencia específica a desarrollar:

Definir e implementar

esquemas de seguridad

a través de un SGBD

.

Actividades de Aprendizaje:

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

(35)

Figure

Actualización...

Referencias

  1. : www.oracle.com