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

• 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

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Antologia de taller de base de datos 1 26

Similar to Antologia de taller de base de datos 1 26 (20)

Recently uploaded

Recently uploaded (20)

Antologia de taller de base de datos 1 26