Desarrollo de software

El texto está diseñado para programadores, analistas o técnicos de sistemas que deseen conocer la mecánica de trabajo de las bases de datos a través del uso de una de ellas en concreto: Microsoft SQL Server 2000. Aspectos que se revisan: 1- Conceptos teóricos sobre Bases de Datos. 2- Diseño y modelización de datos tomando como base el modelo Entidad/Relación 3- Generalidades de SQL Server 2000 4- Lenguaje SQL a través de la implementación del mismo en SQL Server 2000 (Transact SQL) 5- Ejemplos de diseño utilizando una herramienta CASE: Power Designor Se requiere como mínimo tener conocimientos del sistema operativo Windows a nivel de usuario. No es imprescindible, aunque si recomendable, conocer fundamentos de programación.

BASES DE DATOS CON SQL SERVER 2000. TRANSACT SQL
JORGE MORATALLA

ADVERTENCIA LEGAL
Todos los derechos de esta obra están reservados a Grupo EIDOS Consultoría y Documentación Informática, S.L. El editor prohíbe cualquier tipo de fijación, reproducción, transformación, distribución, ya sea mediante venta y/o alquiler y/o préstamo y/o cualquier otra forma de cesión de uso, y/o comunicación pública de la misma, total o parcialmente, por cualquier sistema o en cualquier soporte, ya sea por fotocopia, medio mecánico o electrónico, incluido el tratamiento informático de la misma, en cualquier lugar del universo. El almacenamiento o archivo de esta obra en un ordenador diferente al inicial está expresamente prohibido, así como cualquier otra forma de descarga (downloading), transmisión o puesta a disposición (aún en sistema streaming). La vulneración de cualesquiera de estos derechos podrá ser considerada como una actividad penal tipificada en los artículos 270 y siguientes del Código Penal. La protección de esta obra se extiende al universo, de acuerdo con las leyes y convenios internacionales. Esta obra está destinada exclusivamente para el uso particular del usuario, quedando expresamente prohibido su uso profesional en empresas, centros docentes o cualquier otro, incluyendo a sus empleados de cualquier tipo, colaboradores y/o alumnos. Si Vd. desea autorización para el uso profesional, puede obtenerla enviando un e-mail fmarin@eidos.es o al fax (34)-91-5017824. Si piensa o tiene alguna duda sobre la legalidad de la autorización de la obra, o que la misma ha llegado hasta Vd. vulnerando lo anterior, le agradeceremos que nos lo comunique al e-mail fmarin@eidos.es o al fax (34)-915012824). Esta comunicación será absolutamente confidencial. Colabore contra el fraude. Si usted piensa que esta obra le ha sido de utilidad, pero no se han abonado los derechos correspondientes, no podremos hacer más obras como ésta. © Jorge Moratalla, 2001 © Grupo EIDOS Consultaría y Documentación Informática, S.L., 2000 ISBN 84-88457-24-3

Bases de datos con SQL Server 2000. Transact SQL Jorge Moratalla
Responsable editorial Paco Marín (fmarin@eidos.es) Autoedición Magdalena Marín (mmarin@eidos.es) Jorge Moratalla (jmoratalla@eidos.es) Grupo EIDOS C/ Téllez 30 Oficina 2 28007-Madrid (España) Tel: 91 5013234 Fax: 91 (34) 5017824 www.grupoeidos.com/www.eidos.es www.LaLibreriaDigital.com Coordinación de la edición Antonio Quirós (aquiros@eidos.es)

...................... 17 DISEÑO LÓGICO........................................................Índice ÍNDICE........................................................................................................................ 37 PARTICIONAMIENTO HORIZONTAL DE RELACIONES .............................................. 23 ETAPAS DEL DISEÑO CONCEPTUAL .................................................................................... 10 ARQUITECTURA ANSI/X3/SPARC ............ 9 CONCEPTOS BÁSICOS .......................................................... 21 DISEÑO CONCEPTUAL .................................................. 29 DISEÑO LÓGICO.................................................................................................................................................................................................................................................................................... 15 DISEÑO CONCEPTUAL .......... 5 INTRODUCCIÓN ........................................................................... 23 INTRODUCCIÓN ....................................................... 35 PASO DEL ESQUEMA CONCEPTUAL AL ESQUEMA LÓGICO ESTÁNDAR ......................................................................................................................... 15 FASES DEL DISEÑO ............................................................... 9 DEFINICIÓN DE BASE DE DATOS ..................... 35 INTRODUCCIÓN ......................................................... 38 ........................ 36 ETAPAS EN EL DISEÑO LÓGICO............................................................................. 10 DEL ENFOQUE TRADICIONAL A LOS SISTEMAS DE BASES DE DATOS .................................................................................................................................................................................................................................................... 24 EL MODELO ENTIDAD / RELACIÓN ....................................................................................................................................................................................................................................................................................................................... 12 EL MODELO RELACIONAL .................................... 24 EJEMPLOS PRÁCTICOS DE DISEÑO CONCEPTUAL....................... 17 DISEÑO FÍSICO................................................................................................................................................................................................................................................................................. 12 VISIÓN GENERAL SOBRE EL DISEÑO DE BASES DE DATOS.........................................................................................................................................................................................................................

........................................ 68 CARACTERÍSTICAS DE SEGURIDAD Y CIFRADO DE DATOS ........................ 82 EL ANALIZADOR DE CONSULTAS........................................................................................................ 63 ORÍGENES..................................................................................................................................................................................................................................................................................................... 69 EL MODELO E/R EN SQL-SERVER 2000 ...................................................... 55 DISEÑO FÍSICO ...... 101 ........................................................................................................................................................................................................................... 85 LA BARRA DE HERRAMIENTAS ...... 65 SOPORTE PARA XML ..................................................... 85 LAS OPCIONES DE MENÚ ...................................................................................................................... 101 CREACIÓN Y BORRADO DE ÍNDICES ................... 97 INTRODUCCIÓN ........................................................................................................................................................................................................................................... 59 TÉCNICAS PARA EL AUMENTO DE EFICIENCIA ............................................... 99 MODIFICACIÓN DE TABLAS ...... 97 TIPOS DE DATOS ................................................................ 79 MODIFICACIÓN DEL ESQUEMA ............................................ 44 TEORÍA DE LA NORMALIZACIÓN ........................................................ 75 INTRODUCCIÓN ........................................................................... 45 EJEMPLOS PRÁCTICOS DE NORMALIZACIÓN ..................................................................................... 67 NUEVOS TIPOS DE DATOS ................................................................................................................................................................................... 67 INDEXACIÓN DE VISTAS ...................... 68 INSTALACIÓN DE SQL SERVER 2000 ................................................ 91 EJECUTANDO UNA CONSULTA ................... 58 CONCEPTOS BÁSICOS SOBRE GESTIÓN DE FICHEROS ......................................................................................... 66 PARTICIONAMIENTO HORIZONTAL DE RELACIONES Y GESTIÓN DE VISTAS DISTRIBUIDAS ..................................................... 85 INTRODUCCIÓN ............... 67 SOPORTE PARA VIRTUAL INTERFACE ARCHITECTURE (VIA) ....................................... 58 ORGANIZACIÓN DE FICHEROS .......................................................................PARTICIONAMIENTO VERTICAL DE RELACIONES ................................................ 65 INTRODUCCIÓN ............................................................................. 75 CREAR UN NUEVO DIAGRAMA ................................................................ 49 PROCESO DE DESNORMALIZACIÓN ........................................................................................................... 65 NUEVAS CARACTERÍSTICAS ............................................................................................................. 100 BORRADO DE TABLAS .................................. 64 LO NUEVO EN SQL-SERVER 2000 ............................................................. 64 SQL SERVER E INTERNET ........................................................................................................................................................................................................................ 67 NUEVOS TRIGGERS ....................................................... 41 PARTICIONAMIENTO MIXTO ..................................................................................................................................................................................................................................................... 57 ESTRATEGIAS EN EL DISEÑO FÍSICO ............................................................................................................................................................................................................................................................................................................................ 57 INTRODUCCIÓN .................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................... 68 NUEVAS CARACTERÍSTICAS DE INDEXACIÓN .................................... 67 FUNCIONES DE USUARIO .......................................................................................................................................................................... 63 ¿QUÉ ES SQL SERVER?...................................................................................................................................................................................................... 77 RESTRICCIONES E INTEGRIDAD REFERENCIAL ...................................................................... 68 REGLAS DE INTEGRIDAD REFERENCIAL EN CASCADA .............................................................................................................................................................. 68 SOPORTE PARA CONSULTAS DISTRIBUIDAS ..................................... 59 INTRODUCCIÓN A SQL SERVER ................................................................................................................................................. 92 EL LENGUAJE DE DEFINICIÓN DE DATOS (DDL) .......................................................................... 81 CREAR UNA NUEVA RELACIÓN ..... 97 CREACIÓN DE TABLAS .........................................................................

....................................................................................................................................................................................... 132 VARIABLES GLOBALES............................. 154 LA SENTENCIA UPDATE ...... 140 CARGA DE LA BASE DE DATOS DE EJEMPLO .................. 157 EJEMPLOS................................ 119 LA SENTENCIA INSERT ....... 125 INTRODUCCIÓN ......................................... 166 PROCEDIMIENTOS ALMACENADOS Y TRIGGERS .............................................................................................................................................................................................................. 143 LA SENTENCIA SELECT................................................................. 135 SENTENCIAS CONDICIONALES............................................................................ 107 LA SENTENCIA DROP TABLE ................................................ 103 INTRODUCCIÓN ................................... 112 LA SENTENCIA DROP INDEX............... 169 7 ............................................................................................................................................................ 138 LA SENTENCIA INSERT......................................................................................................................................... 164 LA SENTENCIA TRUNCATE TABLE..................................................................................................................................................................................................................................................................................... 139 INTRODUCCIÓN ............................................................................................................................................................................................................................................. 112 EL LENGUAJE DE MANIPULACIÓN DE DATOS (DML) .......... 118 LA CLÁUSULA HAVING ........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................... 103 LA SENTENCIA CREATE TABLE ......................................... 163 LA INTEGRIDAD REFERENCIAL....................................................................... 119 FUNCIONES ESCALARES PARA SELECT ....... 103 LA SENTENCIA ALTER TABLE .......... 148 EL OPERADOR JOIN ........................................................................................... 139 SINTAXIS ............................................................................................................................................. 137 SENTENCIAS ITERATIVAS ....................................................................... 139 EJEMPLOS..................................................................................................................................................................... 123 OPERADORES BÁSICOS Y CONSIDERACIONES DEL LENGUAJE ..................................................................................................................................................................................................................................................................................................................................................................................................................................................... 127 OPERADOR JOIN ........................................................ 147 LA CLAÚSULA WHERE ......................................................................................................... 169 INTRODUCCIÓN ...................................... 157 LA SENTENCIA DELETE ................. 111 LA SENTENCIA CREATE INDEX.......................EJEMPLOS PRÁCTICOS DE USO DEL DDL..................................................................... 117 LA CLÁUSULA GROUP BY .......... 115 LA SENTENCIA SELECT ..................................................................................................................................................... 151 LA CLAÚSULA GROUP BY ................................................ 115 INTRODUCCIÓN ....................................................................................................................................................................................................................................................................................................................................................................... 149 LAS FUNCIONES DE AGREGADO ............................................. 128 OPERADORES PROPIOS DE TRANSACT SQL ........................................................................................................................................................................... 122 LA SENTENCIA UPDATE ............................................................................................................................................................................................ 115 LA CLÁUSULA WHERE ......................................................................................... 165 EJEMPLOS.................................................. 147 INTRODUCCIÓN ........................................................................................ 123 LA SENTENCIA DELETE ......................................... 125 OPERADOR UNION .............................................................................................................................................................................................................................................................. 125 OPERADOR PROYECCIÓN ..... 163 INTRODUCCIÓN .............................................................................................................. 119 LA CLÁUSULA ORDER BY ............................................................ 157 INTRODUCCIÓN ...............................................................................

....................................................................................................................................................................................................................................................................................................................... 225 ....................................... 219 ATRIBUTOS EXTENDIDOS ................ 219 INDICES ............................................................................................................... 174 EJEMPLOS PRÁCTICOS DE USO DE PROCEDIMIENTOS ALMACENADOS .......... 221 RESTRICCIONES.................................................................. 218 COLUMNAS ............... 180 CONVERSIÓN DE TIPOS............... 215 DISEÑO FÍSICO CON POWER DESIGNOR ................................................................ 217 MODIFICACIÓN DE LAS TABLAS .................................................................................................................................................................................. 195 INTRODUCCIÓN ........ 170 PROCEDIMIENTOS ALMACENADOS DE SISTEMA......................................................... 184 TIPOS DE DESENCADENADORES ............................................................................................................................ 208 CREACIÓN DE RELACIONES ........................................................................................... 194 EJEMPLO PRÁCTICO DE IMPLEMENTACIÓN............................... 184 LIMITACIONES DE LOS TRIGGERS ................................................................................................................................... 195 LENGUAJE DE DEFINICIÓN DE DATOS.............................................................. 185 EJEMPLOS.................................................................................................................... 179 EJECUCIÓN DINÁMICA DE SENTENCIAS: LA INSTRUCCIÓN EXEC ......................................................................................................................................... 203 DISEÑO CONCEPTUAL CON POWER DESIGNOR.................................................................................................. 221 TRIGGERS ................................................................................................................................................................................................ 184 RESOLUCIÓN DIFERIDA DE NOMBRES .................................................................................................................................................................... 182 TRIGGERS EN SQL-SERVER 2000 ........................ 222 EJEMPLO DE DISEÑO CON POWER DESIGNOR............................................... 189 INTRODUCCIÓN .................................................................................................................................................................................. 181 LA SENTENCIA WHILE............................ 183 LAS TABLAS DELETED E INSERTED .................................................................................................................. 177 LA SENTENCIA IF .......................................... 198 PRESENTE Y FUTURO DE LAS BASES DE DATOS ...................................................................................................... 222 CREACIÓN DE VISTAS ..................................................................................................................................................................................................... 193 RECOMENDACIONES .................................................................................................................................................................................................. 177 INTRODUCCIÓN ....................................... 193 MANTENIMIENTO DE VISTAS .................................................................................... 185 SEGURIDAD ................................................................................ 191 DENEGACIÓN DE PERMISOS ......................................................... 217 PASO DEL ESQUEMA CONCEPTUAL AL ESQUEMA FÍSICO ....................................................................................................................................................................................................................................... 213 LA RELACIÓN DE HERENCIA............................................................PARÁMETROS POR REFERENCIA ... 173 TRIGGERS ................................................................................................................................................................................................................................. 207 INTRODUCCIÓN ......................................................................................... 189 REVOCACIÓN DE PRIVILEGIOS ................................................................................................................ 196 LENGUAJE DE MANIPULACIÓN DE DATOS .................................................................. 183 INTRODUCCIÓN ............................................................................................. 177 LA SENTENCIA CASE ...................................................................................... 172 EXTENDED STORED PROCEDURES ........................ 189 CONCESIÓN DE PRIVILEGIOS ............................................................................................................................................................................................... ELSE................................................................................................................................................................ 207 CREACIÓN DE UNA ENTIDAD .......................................................................................................................................

(Conference des Statisticiens Européens. se emplean métodos bien determinados para incluir nuevos datos y para modificar o extraer los datos almacenados". de la mejor manera posible. 1982). 1977). "Colección o depósito de datos. 1975). "Colección no redundante de datos que son compartidos por diferentes sistemas de aplicación". (Flory. Existen varias definiciones para responder a esta pregunta: • "Colección de datos interrelacionados almacenados en conjunto sin redundancias perjudiciales o innecesarias. 1982). 1983). donde los datos están lógicamente relacionados entre sí. que es utilizado por numerosas personas y cuya organización está regida por un modelo de datos". (Martin. debe poder servir para toda una gama de usos y aplicaciones". (Delobel. su finalidad es servir a una aplicación o más. tienen una definición y descripción comunes y están estructurados de una forma particular. "Conjunto estructurado de datos registrados sobre soportes accesibles por ordenador para satisfacer simultáneamente a varios usuarios de forma selectiva y en tiempo oportuno". • • • • . Una base de datos es también un modelo del mundo real y. "Conjunto de datos de la empresa memorizado en un ordenador.Introducción Definición de base de datos La primera pregunta que surge a la hora de comenzar este curso es la siguiente: ¿Qué es una Base de Datos?. como tal. (Howe. los datos se almacenan de modo que resulten independientes de los programas que los usan.

procedimientos y equipos diseñados. operados y mantenidos para recoger. "Colección de datos interrelacionados". Conceptos básicos • Sistema de Gestión de Base de Datos (SGBD): Conjunto de programas que permiten la implantación. ciudad. "Colección o depósito de datos integrados. (Deen. En la actualidad podemos establecer la definición de base de datos como sigue. constituyen el Sistema de Base de Datos. se ha de apoyar en un modelo de datos. Modelo de datos: Conjunto de conceptos que permiten describir. Los datos. Sistema de Información: Colección de personas. provincia y teléfono. pongamos un ejemplo. 1985). almacenados en soporte secundario (no volátil) y con redundancia controlada. "Conjunto de ficheros maestros. • • • • Del enfoque tradicional a los sistemas de bases de datos Para comprender mejor las diferencias entre los sistemas tradicionales basados en ficheros y los sistemas de bases de datos. a distintos niveles de abstracción. deben mantenerse independientes de ellos. comunes y bien determinados. construidos. y otro para la emisión de informes. (Frank. estructurada atendiendo a las relaciones naturales de modo que suministre todos los caminos de acceso necesarios a cada unidad de datos con objeto de poder atender todas las necesidades de los diferentes usuarios". Esquema de una Base de Datos: Estructura de la Base de Datos. 1989). Si además de esto. El SGBD. dirección. (Elsmari y Navathe. 1988). organizados y administrados de una manera flexible de modo que los ficheros puedan ser fácilmente adaptados a nuevas tareas imprevisibles". Los procedimientos de actualización y recuperación. podemos encontrarnos con los siguientes problemas: • Producción de inconsistencias o incoherencias. mientras que una ocurrencia del esquema es distinta en el transcurso del tiempo. registrar. la estructura de una base de datos. acceso y mantenimiento de la base de datos. Ocurrencia del esquema: Conjunto de datos que se encuentran almacenados en el esquema en un momento determinado. 10 . el concepto de base de datos ha ido cambiando a lo largo del tiempo. El esquema no varía mientras no varíe el mundo real que éste describe. y su definición (estructura de la base de datos) única y almacenada junto con los datos. Supóngase que disponemos de un archivo maestro de clientes con la siguiente información: nombre. facilitarán la seguridad del conjunto de los datos". debido a la replica de información (la misma información puede estar almacenada en distintos ficheros). junto con la base de datos y con los usuarios. procesar. almacenar y recuperar esa información. el cual ha de permitir captar las interrelaciones y restricciones existentes en el mundo real. que han de ser compartidos por diferentes usuarios y aplicaciones. • • Como se ha visto. a la cual denominamos esquema.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS • "Colección integrada y generalizada de datos. añadimos dos ficheros. uno para la emisión de facturas.

Algunas de las ventajas que ofrece utilizar un Sistema de Bases de Datos son las siguientes: 1. Coherencia de resultados: Debido a que los datos son almacenados una sola vez. Falta de rentabilidad a corto plazo: Los amplios costes que conlleva la implantación. El cambio en los programas no influye en la disponibilidad de los datos. o ampliaciones de las existentes) como en el lógico (sistemas operativos. así como la modificación de éstos no afecta a la reprogramación de las aplicaciones que los usan. Independencia entre datos y tratamientos. 4. Mejor disponibilidad de datos para los usuarios: Los datos son compartidos por un conjunto de usuarios. la implantación de un sistema de base de datos puede convertirse en una tarea larga y complicada.). 4. así como el coste de adquisición o mantenimiento del SGBD. ya que el control de la información es inherente al propio sistema. con el fin de conseguir una mayor eficiencia. se hace necesario una completa reestructuración de dicho fichero. 2. que la suma de ellos independientemente. cuando no han sido todavía plasmados. se evitan los problemas que puede ocasionar la redundancia. sin mencionar el rediseño del código de la aplicación. 11 . o incluso largo plazo. compiladores.© Grupo EIDOS 1. los Sistemas de Bases Datos no están exentos de inconvenientes. 6. implica una rentabilidad no a corto. 3. Reducción del espacio de almacenamiento: La desaparición (o disminución) de redundancias. 5. unido a las técnicas de compactación. Más adelante veremos cómo se permite una cierta duplicidad de datos. En cambio. Mayor eficiencia en la recogida. siempre que estén autorizados a ello. Instalación costosa: La implantación de un sistema de base de datos puede implicar un coste elevado. aumentando así la eficiencia. Implantación larga y difícil: Debido a las causas mencionadas anteriormente. implica una menor ocupación de almacenamiento secundario. que muchas veces no se ven traducidos en la práctica. creyendo que constituyen ya una realidad. etc. programas. que accede a ellos de forma concurrente. Escasa estandarización: Esto supone una dificultad añadida a los usuarios de la base de datos. en un sistema de gestión de bases de datos. sino a medio. controlada por el sistema y que no afecta a la redundancia lógica. validación e introducción de los datos en el sistema: Al no existir redundancia. para dar cabida a este cambio. 5. Desfase entre teoría y práctica: Los constantes avances teóricos en al ámbito de las bases de datos. Introducción. 3. tanto en el equipo físico (adquisición de nuevas instalaciones. Mayor valor informativo: El conjunto de los datos almacenados en la BD ofrece un mayor valor informativo. Si en este momento se quiere añadir en número de fax. 2. estos problemas no tienen cabida. los datos se recogen y validan una sola vez. A pesar de todas estas ventajas. hacen llevarse a engaño a muchos usuarios. Aquí se detallan los más importantes: 1. • • Malgasto de memoria secundaria (por el mismo motivo).

Cada fila representa la información para cada ocurrencia de una determinada entidad. 3. técnicas de compresión de datos. cuales son los datos. y que almacenan información para una determinada entidad. etc. En este nivel. de los que interesa conocer su valor. que es único. es decir. corresponde a la implementación del modelo conceptual. El motivo de que sea éste el modelo más extendido. para cada entidad. establece el modelo teórico sobre el que están asentados los modelos externos. Además. Dichas columnas se denominan atributos. como por ejemplo dispositivos de memoria a usar (tamaño de páginas.). 2. apellidos. en dar valores para cada uno de los atributos de la entidad. como por ejemplo el derecho a insertar o borrar determinados datos. tamaño de los buffers. dentro del Comité X3 que se ocupa de ordenadores e informática. las relaciones entre ellos y las restricciones de integridad y confidencialidad. Describe la estructura almacenamiento físico de los datos. Así mismo especifica todos los aspectos relacionados con el hardware. como ya se verá más adelante. Por lo tanto. El modelo interno. número de éstas. Cada atributo o conjunto de atributos que identifica unívocamente a cada tupla de la relación se denomina clave. o acelerar las consultas / actualizaciones. las estrategias de acceso a los datos. nombre. Nivel Interno: Nivel más bajo en la abstracción. con aquellos datos e interrelaciones que dicho usuario necesite. Nivel Externo: Es el nivel más cercano a los usuarios. 12 . se puede saber a que empleado nos estamos refiriendo. como ya se ha dicho. su nombre y apellidos. que almacena información sobre los empleados de una empresa. sueldo y categoría. propugnaron una arquitectura basada en tres niveles de abstracción: 1.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Arquitectura ANSI/X3/SPARC ANSI/X3/SPARC es un grupo de estudio del Standard Planning and Requirements Commitee (SPARC) del ANSI (American National Standars Institute). A dichas filas también se las denomina tuplas. El modelo conceptual. para evitar cierto tipo de anomalías. que es único. Las claves se representan subrayando el / los atributo/s que forman parte de ella. lo que permitirá. El modelo relacional El modelo más usado. y para cada uno de ellos existirá un valor (cabe la posibilidad de que existan atributos en los que no aparezca ningún valor). su sueldo y su categoría. y en el se definen los datos tal y como los va a ver este. Cada una de estas relaciones representa en sus columnas los valores significativos. el poder estructurar o reestructurar las relaciones. El siguiente ejemplo (Figura 1) representa una relación denominada empleado. denominadas relaciones. Nivel Conceptual: Proporciona una descripción global del esquema independiente de la estructura física de la base de datos. Dicho modelo se basa en la representación de la información por medio de estructuras tipo tabla. los atributos son cod_empleado. ya que si se sabe el valor de dicho atributo. también deberán definirse las restricciones de uso. radica en la facilidad y en su amplia base matemática. y por lo tanto el que se estudiará en este curso. En sus estudios acerca de los SGBD. La información que se desea saber de cada empleado es su código. etc. etc. es el modelo relacional. Cada usuario puede tener su propio modelo externo. es decir. como están organizados. criptografiado. el atributo cod_empleado es clave de la relación. La información se descompondrá. o poder acceder a ellos.

Introducción.© Grupo EIDOS 1. Figura 1 13 .

.

Una vez elegido el modelo lógico. lógico y físico). . Ser un servidor operacional y eficiente de los datos. y produce como resultado el esquema conceptual de la base de datos. a la vez que ayuda a alcanzar los dos principales objetivos que tienen las bases de datos: • • Ser una representación fidedigna del mundo real. pueden existir un conjunto de esquemas lógicos equivalentes al mismo esquema conceptual. independientemente de la elección del equipamiento y del Sistema Gestor de Base de Datos (en adelante referido como SGBD) que se usen para la implementación de la base de datos. lo que permite reducir la complejidad que entraña el diseño. Un esquema lógico es la descripción de la estructura de la base de datos que puede procesarse por un SGBD. Un esquema conceptual es una descripción a alto nivel de la estructura de la base de datos. El diseño conceptual parte de la especificación de requerimientos. El diseño lógico parte del esquema conceptual y genera el esquema lógico.Visión general sobre el diseño de bases de datos Fases del diseño El diseño de una base de datos suele descomponerse en tres grandes fases (diseño conceptual. La meta del diseño lógico es producir el esquema lógico más eficiente con respecto a las operaciones de consulta y actualización.

y todos los aspectos relacionados con el diseño físico. esquema que proporciona una descripción estable de la base de datos (independiente del SGBD) que se vaya a utilizar. Figura 3. por último se eligen las estructuras de almacenamiento. posteriormente se pasa del esquema conceptual al modelo de datos propio de SGBD elegido (diseño lógico). los caminos de acceso (índices). Un esquema físico es una descripción de la implementación de la base de datos en memoria secundaria. Figura 2. Correspondencia entre el diseño y la arquitectura ANSI/X3/SPARC 16 . Diseño de una base de datos En la Figura 2 se resumen las tres grandes fases del diseño de una base de datos: primero se diseña el esquema conceptual (que se realiza con un modelo conceptual de datos). Por ello. describe las estructuras de almacenamiento y los métodos de acceso para acceder a los datos de una manera eficiente. el diseño físico se genera para un SGBD y un entorno físico determinado.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS El diseño físico toma como punto de partida el esquema lógico y como resultado produce el esquema físico.

también denominado modelo conceptual. en el que priman las consideraciones de eficiencia. resume la fase de diseño lógico. el de que la base de datos ha de ser un servidor operacional y eficiente de los datos. aunque la más usada es la de entrevistas a los usuarios. A su vez. Consiste en ir refinando sucesivamente el primer esquema descriptivo. adaptándolo al modelo de datos en el que se apoya el SGBD que se va a utilizar. incluye 17 . En la Figura 4. con independencia de usuario o aplicaciones en particular y fuera de consideraciones sobre eficiencia del ordenador. así como el análisis de los requisitos de determinadas vistas o aplicaciones críticas. si se tiene en cuenta el segundo de los objetivos mencionados anteriormente. conjunto de información que puede ser accedida por un usuario) y lógico (estructura de tablas y restricciones) de la arquitectura ANSI/X3/SPARC. La Figura 3 muestra la correspondencia existente entre las fases de diseño y los niveles de la arquitectura ANSI/X3/SPARC. El diseño físico se corresponde con el nivel físico de dicha arquitectura. es decir. mediante distintas técnicas. Visión general sobre el diseño de bases de datos. se hace necesaria una reestructuración de relaciones. Sin embargo. Consta de dos fases: • Análisis de requisitos: Es en esta etapa donde se debe responder a la pregunta: ¿qué representar?. se irán refinando hasta obtener el esquema conceptual. es obtener una buena representación de los recursos de información de la empresa. debe ser independiente del SGBD a usar. en la que una vez estructurado el esquema origen. es decir. el diseño lógico se corresponde con los niveles externo (donde se definen las vistas de usuario. La primera. la normalización no cubre toda esta fase. al que se añaden las claves ajenas y otras restricciones de integridad. para conseguir pasar del mundo real al esquema descriptivo y de éste al esquema conceptual. consistente en la estructuración de las relaciones atendiendo a consideraciones de tipo lógico. El diseño conceptual es una etapa previa al diseño lógico. • Diseño lógico El objetivo del diseño lógico es transformar el esquema conceptual obtenido en la fase anterior. Esta reestructuración toma como entrada el esquema relacional estructurado obtenido anteriormente. obteniendo de esta manera un esquema relacional resultante. La Figura 4. analizando diferentes factores como las distintas dependencias o la posibilidad de existencia de valores nulos. El modelo relacional es el único modelo que ha permitido abordar la fase de diseño lógico aplicando una teoría formal: el proceso de normalización. Ahora bien. que deberá ser expresado sin tener en consideración cuestiones de implementación. se obtiene un esquema relacional. Los problemas que presenta esta primera especificación. lo que implica una descripción de los datos mediante el uso del lenguaje natural.© Grupo EIDOS 2. se detallan las dos etapas en las que se divide la fase de diseño lógico. y que constituye la primera fase de diseño. Conceptualización: En esta etapa se intenta responder a la pregunta: ¿cómo representar?. En la práctica a veces es preciso proceder a una reestructuración de las relaciones. con el fin de mejorar la eficiencia de la base de datos. Diseño conceptual El objetivo del diseño conceptual. Se pretende en esta etapa elaborar un esquema descriptivo del mundo real. mostrándose insuficiente para alcanzar todos los objetivos de la misma.

vertical o mixto. por razones lógicas. Las herramientas para llevar a cabo este objetivo son dos: 18 . Estructuración y reestructuración de relaciones El objetivo de la estructuración de relaciones es obtener un esquema relacional estructurado. mientras que en la segunda se reestructuran las relaciones teniendo en cuenta consideraciones de tipo físico que pueden llevar a la desnormalización. o al particionamiento horizontal. Figura 4.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS la normalización. los cuales no ofrecen los adecuados instrumentos de diseño físico. seguido de la proyección. obligando a trasladar a la fase de diseño lógico consideraciones de eficiencia que deberían ser ajenas a dicha fase. en el cual se han eliminado los valores nulos (inaplicables) mediante un particionamiento horizontal basado en la selección. un esquema normalizado. tomando como entrada un esquema relacional origen con todas sus dependencias. En esta etapa de estructuración se conseguirá. La razón de esta etapa de reestructuración se encuentra en la falta de flexibilidad de la estructura interna de los actuales SGBD. etc. valores inaplicables. así como el particionamiento horizontal de las mismas cuando sea necesario.

Figura 5. El resultado de este particionamiento horizontal será la división de una relación en la que existen o pueden existir valores nulos. en la que una relación origen ha sido sustituida por otras dos. esto no quiere decir que las relaciones que se vayan a almacenar en la base de datos sean las resultantes de estos procesos. como se muestra en la Figura 5. Figura 6. Visión general sobre el diseño de bases de datos. mediante un proceso de normalización. permite eliminar valores nulos inaplicables que pueden aparecer en las relaciones mediante un proceso de selección. Particionamiento horizontal de relaciones El objetivo de la reestructuración es el de mejorar la eficiencia de la base de datos. se ha propugnado por razones lógicas. En la primera etapa de estructuración de relaciones.© Grupo EIDOS 2. que representan la misma información que la relación origen. pero puede que no el segundo: el de que la base de 19 . • • El proceso de normalización El particionamiento horizontal de relaciones El proceso de normalización consiste en sustituir una relación por un conjunto de esquemas equivalentes. normalizar el esquema. seguido de proyecciones sobre las relaciones resultantes. en varias relaciones en las que los valores nulos inaplicables no tienen cabida. Sin embargo. así como eliminar los valores nulos mediante un proceso de particionamiento horizontal. ya que se ha logrado el primero de los objetivos de las bases de datos (ser una representación fidedigna del mundo real). pero que no presentan cierto tipo de anomalías a la hora de realizar operaciones sobre ella. Normalización de relaciones El particionamiento horizontal de relaciones.

particionamiento horizontal. mediante un proceso de desnormalización. o mixta (incluye ambas). o en bases de datos distribuidas. respectivamente. El particionamiento vertical también puede usarse en la partición de tablas individuales en bases de datos centralizadas. Estos fragmentos se colocan en diferentes localizaciones de la base de datos distribuida. Esto es muy útil cuando existen consultas que acceden sólo a determinada parte de la información dependiendo del valor de algún atributo. muestra un ejemplo en el que dos tablas previamente normalizadas. El particionamiento horizontal de relaciones consiste en la división de las tuplas de una relación en subconjuntos. dividirla en otras relaciones de forma horizontal. La Figura 7. Figura 7.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS datos ha de ser un servidor operacional y eficiente de los datos. El objetivo de este proceso es dada una relación. el objetivo del particionamiento vertical es crear fragmentos verticales de una relación de manera que minimice el coste de acceso a los elementos de datos durante el procesamiento de la transacción. que son: • • El proceso de desnormalización El particionamiento de relaciones El proceso de desnormalización es justamente el proceso inverso al de normalización. Para lograr este objetivo existen diversos métodos o formas de organizar los datos. ya que cada subconjunto puede ubicarse en distintos nodos de la red. particionamiento vertical y particionamiento mixto. acercándose al lugar de su tratamiento. En el particionamiento vertical. Desnormalización de relaciones El particionamiento de relaciones es otra forma de conseguir una mayor eficiencia en la base de datos. etc. por lo que se hace necesaria esta segunda etapa en el diseño lógico. el coste de proceso de transacciones se minimiza incrementando el proceso local de las transacciones (en un "nodo") así como reduciendo el número de accesos a objetos de datos que no son locales. Por ello. los atributos de una relación R son distribuidos en grupos no solapados y la relación R se proyecta en relaciones fragmentarias de acuerdo a estos grupos de atributos. y en la división de datos entre diferentes niveles de jerarquías de memoria. considerando esta idea de mejora de la eficiencia. 20 . A cada una de estas formas de particionamiento se la denomina. o vertical. entonces el coste de proceso de las transacciones podría ser minimizado. En el caso de bases de datos distribuidas. Si los fragmentos se ajustan bien a los requisitos del conjunto de transacciones facilitado. dan origen a una tabla más grande (que es justamente la tabla que se tenía antes de realizar la normalización).

aspectos de carácter físico. lo que explica la obligación de la etapa de reestructuración en el diseño lógico. Esto obliga a iterar desde la fase de diseño físico a la de diseño lógico. los cuales obligan a trasladar a la fase de diseño lógico. 21 . Diseño físico El objetivo del diseño físico. que es la última fase del proceso de diseño. requisitos de procesos. Visión general sobre el diseño de bases de datos. Aquí se tienen en cuenta aspectos del hardware. características del SGBD. Con ello se persigue: • • • • • disminuir los tiempos de respuesta minimizar espacio de almacenamiento evitar las reorganizaciones proporcionar la máxima seguridad optimizar el consumo de recursos El principal problema que se plantea en la fase de diseño físico es el debido a la poca flexibilidad de los actuales SGBD. describe las estructuras de almacenamiento y los métodos de acceso para acceder a los datos de una manera eficiente. y viceversa. hasta obtener conseguir los objetivos anteriormente expuestos. es conseguir una instrumentación lo más eficiente posible del esquema lógico. que es una descripción de la implementación de la base de datos en memoria secundaria. Como su propio nombre indica. o viceversa. Por ello el diseño físico se genera para un SGBD y un entorno físico determinado. cualquier factor cercano a la "maquina". que deberían ser ajenos a dicha fase.© Grupo EIDOS 2. Como resultado del diseño físico se genera un esquema físico. el particionamiento mixto engloba a ambos tipos de particionamiento (horizontal y vertical). del SO y en general. Consiste en aplicar un particionamiento vertical a uno o más de los fragmentos obtenidos mediante un particionamiento horizontal.

.

el diseño conceptual. Puesto que no se corresponde con ningún nivel de la arquitectura ANSI/X3/SPARC. Otro error que se suele cometer en esta etapa de diseño es el de considerar aspectos tales como la eficiencia del equipo hardware en el que se vaya a montar la base de datos. consiste en obtener una buena representación de los recursos de información de la empresa. se pueden establecer las siguientes características que debe cumplir un buen esquema conceptual: Debe representar fielmente la información del mundo real • • Es independiente del SGBD Es independiente del Hardware . o no representa fielmente la información del mundo real. Como ya se ha dicho. Esto no es aconsejable. el esquema de la base de datos no será estable. con independencia de usuario o aplicaciones en particular y fuera de consideraciones sobre eficiencia del ordenador. ya que el diseño lógico parte del esquema conceptual y. sino que es un paso previo. el esquema conceptual debe representar la información fuera de consideraciones sobre hardware y sobre el SGBD sobre el que se implementará. tiende a ser no tenido en cuenta a la hora de proceder al diseño de una base de datos. viéndonos obligados a reajustarlo constantemente debido a las deficiencias arrastradas desde esta etapa de diseño. o SGBD's concretos. De ahí la importancia de realizar un buen esquema conceptual.Diseño conceptual Introducción Como ya se ha visto en el tema anterior. que represente fielmente las características del mundo real. Por lo tanto. si éste no es correcto. que constituye la primera etapa en el diseño de una base de datos.

Etapa de análisis de requisitos: En esta etapa se debe responder a la pregunta "¿Qué representar?". la que se utilizará aquí no es. Éste se basa en una representación gráfica de una serie de entidades relacionadas entre sí. En ella se transforma el esquema obtenido en la primera. por supuesto. las relaciones existentes entre las distintas entidades. centrándose en la estructura lógica y abstracta de los datos. fidelidad. El modelo que se estudiará es el Modelo Entidad / relación (en adelante referido como ME/R o modelo E/R). con independencia de consideraciones de tipo físico. que un buen diseño del esquema conceptual. influirá positivamente en el resto de etapas. Existen muchas formas de representarlo. en el que se provean detalles de los datos a representar. no redundancia. A continuación se describirá el proceso de creación de un esquema conceptual. sino distintos modelos según los autores. El objetivo es elaborar un esquema descriptivo de la realidad. Etapa de conceptualización: En esta etapa se debe responder a la pregunta "¿Cómo representar?". que se apoye en un modelo de datos que cumpla determinadas propiedades (según Piattini y De Miguel): coherencia. Aislar la representación de la información de los requisitos de máquina y exigencias de cada usuario en particular 3. lo cual explica que no exista uno sólo. Chen en dos artículos que publicó en los años 1976 y 1977. como ya se ha comentado. En ellos define dicho modelo como una vista unificada de los datos. la más utilizada es el lenguaje natural que. Los objetivos que debe cumplir un esquema conceptual son los siguientes (Piattini y De Miguel): 1. permite una mejor y más fácil comprensión de la información por parte del usuario. Se deberá obtener el esquema conceptual mediante una representación normalizada. hasta llegar al esquema conceptual. Captar y almacenar el universo del discurso mediante una descripción rigurosa. entrevista a los usuarios. por lo tanto.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Conviene no olvidar. Etapas del diseño conceptual La fase de diseño conceptual. como representación del mundo real. y le permite especificar los requisitos sin la intervención de formalismos. la única forma de hacerlo. se ira refinando sucesivamente. puede subdividirse a su vez en dos etapas: 1. Independizar la definición de la información de los SGBD en concreto. el modelo E/R permite distinguir fácilmente y a simple vista.). aunque carece del formalismo que pueden infligir otros métodos. 2. Dicho esquema se obtiene mediante el estudio u observación del mundo real (estudio de las reglas de la empresa. etc. Este primer esquema percibido bruto (como lo llaman Benci y Rolland). Aunque existen muchas respuestas sobre el modo de recoger dicha información. 2. simplicidad. etc. plenitud. El modelo entidad / relación El modelo E/R fue propuesto por Peter P. Posteriormente se fueron proponiendo nuevas aportaciones al modelo. Al utilizar una representación de este tipo. Los elementos de los que se componen son los siguientes: 24 . siguiendo el modelo E/R. que es el más utilizado hoy en día. mediante refinaciones sucesivas.

Diseño conceptual 1. Por ejemplo. Esto implica que los valores de los atributos clave no se pueden repetir para dos ocurrencias de la misma entidad. Atributos: Un atributo es cualquier característica que describe a una entidad. Si tenemos dos entidades automóvil y persona. Figura 8 2. ya que pueden existir dos automóviles distintos de la misma marca. con el nombre de dicha entidad escrito en la parte superior. que son capaces de identificar unívocamente una ocurrencia de una entidad. Entidades: Una entidad es "una persona. En el modelo E/R. justo debajo del nombre de ésta. real o abstracto. de interés para la empresa" (ANSI 1977). cosa. si conocemos el valor de dichos atributos. seremos capaces de conocer a que ocurrencia de entidad. y Un automóvil pertenece a una persona. Relación: Una relación representa. Los atributos de una entidad se colocan dentro del rectángulo que representa dicha entidad. Los atributos marca. modelo o color no identifican unívocamente una ocurrencia de la entidad. podemos tener una relación entre ellas. Por ejemplo. Clave: La clave de una entidad es un atributo o conjunto de atributos de dicha entidad. con sólo conocer el valor del atributo matrícula. marca. se representa por un rectángulo. 25 . un atributo clave se representa subrayando dicho atributo.© Grupo EIDOS 3. ya que no existe una misma matrícula para dos automóviles distintos. seremos capaces de identificar de que automóvil estamos hablando. la Figura 8 representa la entidad automóvil. entre todas las posibles. como su propio nombre indica. Figura 9 3. lugar. modelo o color. se puede decir que un automóvil tiene las siguientes características: nº de matricula. Figura 10 4. una correspondencia entre dos entidades. hace referencia. concepto o suceso. lo cual se muestra en la Figura 9. modelo y color. Es decir. En nuestro ejemplo. Dicha relación se puede establecer en ambos sentidos: una persona posee un automóvil. En el modelo E/R.

Ej. Ej.: una persona posee varios automóviles. Figura 13 6. Cardinalidad de una relación: La cardinalidad de una relación representa el número de ocurrencias que se pueden dar de una relación. Entidad débil: se dice que una entidad es débil. Se representa como indica la Figura 11. Cada ocurrencia de una entidad puede relacionarse con varias ocurrencias de otra entidad y viceversa. Cardinalidad máxima de una relación: representa el número máximo de ocurrencias de una entidad con las que se puede relacionarse otra entidad. Ej. 7.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS 5. Ej. Cardinalidad mínima de una relación: representa el número mínimo de ocurrencias de una entidad con las que se puede relacionarse otra entidad. 8. Puede ser de tres tipos: Cardinalidad 1-1: cada ocurrencia de una entidad se relaciona con una ocurrencia de otra entidad.: un automóvil debe pertenecer como mínimo a una persona. ni siquiera conociendo su clave. Se representa como aparece en la Figura 13. sino que debemos conocer el valor de algún otro atributo de otra 26 .: una persona puede tener como máximo tres automóviles.: una persona posee varios automóviles y un automóvil puede pertenecer a varias personas. Figura 11 Cardinalidad 1-N: también llamada uno a muchos. Figura 12 Cardinalidad N-M: también llamada muchos a muchos. Ej. Cada ocurrencia de una entidad puede relacionarse con varias ocurrencias de otra entidad.: una persona posee un automóvil. Se representa como muestra la Figura 12. cuando no somos capaces de conocer a que ocurrencia de entidad nos estamos refiriendo. o es dependiente de otra.

(nos fijaremos sólo en un sentido de la relación. Figura 15 Veamos a continuación unos ejemplos para comprender mejor las cardinalidades máxima y mínima. las cardinalidades de una relación se ponen en la última relación a la que se hace referencia. Éstas vienen a representar la opcionalidad de la ocurrencia de una entidad en una relación. la cardinalidad de la relación un alumno cursa asignaturas. cardinalidad mínima 1. sin la posibilidad de que exista un automóvil que no tenga dueño (cardinalidad mínima 1). Los tipos de cardinalidades son los que aparecen en la Figura 15. si dicha ocurrencia se debe dar obligatoriamente. Por ejemplo. si tenemos las entidades edificio (con el atributo clave codigo_edificio) y planta (con el atributo codigo_planta). si se tienen las entidades alumno y asignatura. ya que no somos capaces de identificar una planta con sólo conocer el código de la planta. o puede no tener ninguno (cardinalidad mínima 0). en una relación se suele representar conjuntamente las cardinalidades máxima y mínima. cardinalidad mínima 1. se tiene una relación 1-1 en la que un automóvil pertenece a una única persona (cardinalidad máxima 1). se pondrá al lado de la entidad asignatura. o si por el contrario se puede obviar. Diseño conceptual entidad. En los anteriores casos no se han considerado las cardinalidades mínimas. por ejemplo. Esto significa que el modelo interesa tener información de todas las personas. cardinalidad mínima 0. aunque no tengan automóvil. Esto significa que en el modelo no interesa tener información de aquellas personas que no tengan automóvil. Cardinalidad máxima 1. Cardinalidad máxima 1. En el siguiente ejemplo(Figura 16). cardinalidad mínima 1. Como se podrá comprobar. el de la izquierda).© Grupo EIDOS 3. Figura 14 En general. Figura 16 En la Figura 17. sino que además se necesita conocer el código del edificio al que se hace referencia. es decir. Cardinalidad máxima N. ésta última es una entidad débil. para determinar la planta dentro del edificio. Cardinalidad máxima N. se tiene una relación 1-1 en la que una persona puede tener un automóvil como mucho (cardinalidad máxima 1). 27 .

A dicha biblioteca podrán estar suscritos varios usuarios. pero puede que no tenga ninguno (cardinalidad mínima 0). nombre. se tiene una relación 1-N. pero como mínimo debe hacerlo a uno (cardinalidad mínima 1). el año de publicación y la materia. el autor o autores. se limita el número de ejemplares prestados a cada usuario a uno. De la editorial se desea conocer el nombre y la ciudad. en la que un profesor puede dar clase a muchos alumnos (cardinalidad máxima N). Un autor podrá haber escrito varios libros. Por cuestiones directivas. aunque no tengan automóvil. de un único ejemplar de cada libro. Esto significa que en el modelo interesa tener información de todas las personas. dirección y teléfono. Figura 19 Para concluir esta sección se verá un ejemplo completo que representará todos los conceptos vistos hasta ahora. número de socio. De ellos se quiere saber su DNI. apellidos. en la que una persona puede tener varios automóviles (cardinalidad máxima N). no podrá ser prestado a otro hasta que se devuelva. Supongamos que se desea establecer un modelo conceptual para la gestión de una biblioteca. la editorial. a su vez. el título. Esto significa que en el modelo no interesa tener información de aquellos profesores que no dan clase. Para cada libro interesa conocer el ISBN. de la misma forma que en un libro pueden participar varios autores. se tiene una relación N-N. Deberá quedar constancia de la fecha de préstamo de cada ejemplar.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Figura 17 En el siguiente ejemplo (Figura 18). por lo que un libro prestado a un usuario. Se dispone. apellidos y nacionalidad. 28 . Se desean tener almacenados todos los libros que la componen. Figura 18 En el siguiente ejemplo. De cada autor se quiere conocer su nombre.

Esto quiere decir que sólo se guardará información de las entidades cuando exista. ya que se desea conocer información de ellos. y que además tendrán sus propias letras. Como primera entidad. ya que para diferenciar un préstamo de otro. como puede ser un código que lo identifique dentro de la estantería. sino el socio al cual se ha prestado. ya que se verá en detalle en próximos temas. El problema que nos planteamos es el siguiente. se necesita saber no sólo el libro. Para realizarlos se utilizará la S-Designor. podemos establecer los discos que se venden. Pues ya tenemos la tercera entidad. de los cuales se desea almacenar su nombre.© Grupo EIDOS 3. aunque todavía no se haya realizado ningún préstamo. Diseño conceptual Figura 20 Lo más destacable del anterior ejemplo es la entidad préstamo. que es una herramienta CASE que abarca gran parte del ciclo de vida de las aplicaciones. empezaremos identificando las entidades. y para cada uno de ellos se desea conocer su nombre y apellidos. se desea conocer todas las canciones que están disponibles en los discos. y que podrán estar identificados internamente por un código de cliente. por lo tanto ya tenemos identificada una segunda entidad. incluyendo el diseño de esquemas conceptuales. simplemente quédese con la idea general de la construcción del esquema. para ir familiarizando al lector con los conceptos vistos hasta ahora. entendiendo por entidad un grupo de características que tienen entidad propia. Las únicas relaciones que tienen cardinalidad opcional. son las que tienen como origen o destino a la entidad préstamo. Así mismo se desean almacenar los clientes que han comprado en dicha tienda. identificada cada una de ellas por un código de canción. ya que tendremos información de todas las entidades. Supóngase que se desea informatizar una tienda de discos. lo cual es lógico. dirección y teléfono. una ocurrencia de la entidad. Además. además de sus cantantes y canciones. También se pueden observar que las cardinalidades mínimas son 1. Por otro lado se desea almacenar todos los artistas que intervienen en los discos de nuestra tienda. Ejemplos prácticos de diseño conceptual A continuación resolveremos unos problemas de diseño conceptual. al menos. Figura 21 29 . Pues bien. No se preocupe si no conoce la herramienta. La cuarta estará formada por los clientes. Es una entidad débil que depende de libro y de socio. Para ello se desean tener almacenados los nombres de todos los discos disponibles. apellidos.

para lo cual creamos una nueva entidad ciudad. 2. Otra entidad podría ser el alumno. y que consiste en tener una entidad que tipifique los posibles estados que puede tomar un atributo. denominado tipificación de estados. Por ejemplo podemos tipificar las ciudades. donde se almacenará un código y la descripción de la ciudad. Empezamos identificando entidades. por lo tanto establece una entidad. La principal ventaja de este procedimiento radica en que muchas veces supone un ahorro de espacio de almacenamiento (por ejemplo al identificar nombres de ciudades largas con un solo número) además de una estandarización de los datos almacenados (el estado sólo se almacena una vez). pero un disco sólo puede ser comprado por un cliente 1-N. dirección y teléfono. así como una breve descripción de éstos. Entre disco y canción: en un disco pueden aparecer varias canciones. muy usado en el diseño conceptual. apellidos. Supongamos que se desea tener almacenados todos los datos de los profesores de una empresa dedicada a impartir cursos. Cuando almacenemos la ciudad de un alumno. y una canción puede estar compuesta por varios cantantes (N-M). del cual se desea conocer su nombre. y cada canción puede estar en varios discos (N-M).Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Una vez establecidas las entidades. dirección y despacho. 3. Por lo tanto. 30 . y los alumnos a los cuales se les ha impartido. Entre cliente y disco: un cliente puede comprar varios discos. Sin embargo. Entre cantante y canción: un cantante puede componer varias canciones. sólo deberemos especificar el código de la ciudad. Podemos observar las siguientes relaciones: 1. el esquema conceptual es que muestra la Figura 22 Figura 22 Vamos a plantearnos otro problema. de la cual se desea conocer su descripción. podemos recurrir a un procedimiento muy usual. sólo nos queda relacionarlas. Ni que decir tiene que el curso describe otra entidad. De un profesor se desea conocer su nombre y apellidos.

pero un curso sólo puede ser impartido por un profesor (1-N). Profesor y Curso: un profesor puede impartir varios cursos. Por lo que podrá ser introducido en la entidad intermedia que surja cuando se haga el paso a tablas (véase siguiente capítulo). Alumno y Curso: un alumno puede asistir a varios cursos.© Grupo EIDOS 3. 31 . Diseño conceptual Figura 23 Una vez establecidas las entidades. Figura 24 Cabe destacar que el atributo calificación se da como consecuencia de la relación entre las entidades curso y alumno. y a un curso pueden asistir varios alumnos (N-M). 2. Por lo tanto. vamos a definir las relaciones entre ellas. Alumno y Ciudad: un alumno vive en una ciudad. 1. el esquema conceptual es el mostrado en la Figura 24. 3. y una ciudad puede tener varios alumnos (1-N).

Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Vamos a ver un último ejemplo. y estará identificado por un código interno cod_cliente. libretas de ahorro. extraordinaria. Como habrá podido observar. fecha. 2. Puesto que dicho banco esta constituido como sociedad anónima. dicho banco tiene intereses en otras empresas. nombre y CIF. y si el cargo es vigente o no. apellidos. 4. Sus atributos son cod_reunión.). Consejo: establece los componentes del consejo de administración. De ellas se desea conocer su código.). Reunión: entidad encargada de describir la información de las actas de las reuniones. que especifica si la reunión ha sido ordinaria o extraordinaria y una descripción. y una descripción del mismo (secretario. Producto: del cual queremos saber su descripción y estará identificado por un código interno cod_producto. el proceso es similar al de los demás ejemplos. Cada cliente podrá escoger entre todos estos productos el o los que más le plazcan (créditos. etc. además de los productos que puede ofrecer a éstos. 5. y esta compuesto por un código de tipo de cargo. pero no desespere. desea almacenar todos los componentes de su consejo de administración (actuales y ex-miembros) así como todas las actas de las reuniones ordinarias y extraordinarias. dirección y NIF. Empresa: identifica las empresas en las cuales el banco ha invertido. Tipo_cargo: describe los posibles cargos que puede tomar una persona en el consejo de administración. este ejemplo es un poco más complejo. Figura 25 32 . Empezaremos definiendo entidades y las veremos representadas en la Figura 25. apellidos y código de cargo de cada uno de sus componentes. Para ello se almacenará el nombre. 6. para poder mejorar su política de inversiones. etc. Podremos utilizar una nueva entidad que tipifique los tipos de cargo. por lo que desea conocer en todo momento la situación de dichas empresas. Las decisiones de inversión en estas empresas saldrán como resultado de dichas reuniones. 1. 3. así como la oferta de nuevos productos. presidente. fondos de inversión. De la misma forma. Supóngase un banco que desea almacenar todos sus clientes. Cliente: se desea conocer su nombre.

Su representación gráfica aparece en la Figura 23. Cliente y producto: cada cliente puede escoger varios productos. Consejo y cargo: un miembro del consejo sólo tiene un cargo. Reunión y consejo: a cada reunión pueden asistir varios miembros del consejo de administración. Reunión y empresa: de cada reunión pueden salir decisiones de invertir en más de una empresa. 5. Diseño conceptual Identifiquemos ahora las relaciones. 2. y cada producto puede ser ofrecido a varios clientes. y cada miembro puede asistir a más de una reunión. Reunión y producto: de cada reunión puede salir la oferta de mas de un nuevo producto pero cada producto nuevo sólo puede salir de una reunión.© Grupo EIDOS 3. y cada decisión de inversión sólo sale de una reunión. 33 . 1. 4. 3. y cada cargo puede pertenecer a más de un miembro.

.

Una buena forma de describir el ELS es utilizando el lenguaje estándar del MLS (por ejemplo SQL). además de las herramientas ya descritas (MLS. MLE. se disponen de otras que permiten establecer un buen diseño lógico. el diseño lógico de una base de datos consta de dos etapas: el diseño lógico estándar y el diseño lógico específico. jerárquico. En la fase de diseño lógico. lenguajes SQL). una buena forma de describirlo es utilizando el lenguaje de definición de datos (LDD) del producto especifico utilizado (en el caso de SQL-SERVER. El diseño lógico específico está muy ligado a la fase de diseño físico. la desnormalización. se elabora el esquema lógico específico (ELE). Una vez obtenido el ELS. y teniendo en cuenta los requisitos de proceso. y considerando el modelo lógico específico (MLE) propio del SGBD a usar (ORACLE..).). que será el mismo modelo de datos soportado por el SGBD a utilizar (relacional. de construye un esquema lógico estándar (ELS). se usará el TRANSACT SQL). ya que ambos dependen mucho del SGBD que se utilice. En el diseño lógico estándar. etc. INFORMIX. SQL-SERVER. etc. Al igual que en el caso anterior.Diseño lógico Introducción Como ya se ha señalado. como por ejemplo la normalización. En nuestro caso se utilizará el MLS relacional. etc. que ya se verán mas adelante en este tema. pero sin las restricciones de ningún producto comercial en concreto. . se toma el esquema conceptual resultante de la fase de diseño conceptual. que se apoya en un modelo lógico estándar (MLS).

cada entidad genera una tabla. tanto del libro como del autor. esta relacionada con la entidad con la entidad autor. lo que quiere decir que se generará una tabla. El esquema de las tablas resultantes es el que se muestra en la Figura 26 Figura 26 Veamos ahora el paso a tabla de otro ejemplo visto en el tema anterior. ISBN y Num_socio. Empezaremos identificando las relaciones.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Paso del esquema conceptual al esquema lógico estándar Lo primero que hay que realizar en la fase de diseño lógico. y concretando las tablas que generarán: 1. es obtener el esquema lógico estándar. A su vez. pero en este caso. cod_cliente. La entidad libro está relacionada con la entidad editorial con cardinalidad 1-N. Para entender mejor el funcionamiento de este método. la cardinalidad es N-M. que entrarán como claves en dicha tabla. a la que denominaremos Libro_autor mantiene la información de los códigos de libros junto con los códigos de autores. Cada relación dependiente. cod_cliente. con los atributos clave de ambas entidades. la entidad disco generará una tabla con sus atributos. apellidos y telefono. cuyo esquema conceptual es el que muestra la Figura 27. Cada relación N-M genera una tabla: las relaciones entre entidades con cardinalidad N-M generan una tabla. mantiene información de qué libros han sido prestados a qué usuarios y en qué fecha. es decir. Esta última relación obtenida. por lo tanto importa la clave de la entidad con cardinalidad 1. con los atributos de la entidad Préstamo además de las claves de las entidades de las que es dependiente. 36 . Por último se dispone de la entidad Préstamo. la entidad cliente generará su propia tabla. A su vez. e importará el atributo clave de la entidad con cardinalidad 1. es decir. Esta tabla. con sus propios atributos. son las que a continuación se explican: • • • • Cada entidad se transforma en una relación: esto es. lo que implica que se generará una tabla intermedia. Posteriormente. es decir. importa la clave de la otra entidad. nombre. que es dependiente tanto de la entidad Libro como de la entidad Usuario. Las reglas que permiten pasar del modelo E/R al esquema lógico. incluyendo las claves. Cliente-Disco: puesto que es una relación 1-N. se deberá acceder a sendas tablas. si se desea extraer más información. con sus mismos atributos. como clave. en la que se almacenarán las claves de ambas entidades. veamos el paso a tablas del ejemplo visto en el tema anterior acerca de la gestión de una biblioteca. a partir del esquema conceptual obtenido en la primera fase. Cada relación 1-N importa las claves de la entidad con las que se relaciona: cada relación con cardinalidad 1-N importa los atributos clave que contiene la entidad con cardinalidad N.

© Grupo EIDOS 4. es decir. que debería ser ajena al diseño lógico. queda como aparece en la Figura 28. Canción-Cantante: en este caso se tiene una relación N-M. Disco-Canción: es una relación 1-N. la fase de diseño lógico de una base de datos consiste en dos etapas: • Etapa de estructuración: donde el objetivo primordial es encontrar un esquema que sea una representación fidedigna del mundo real. 3. cod_canción y cod_cantante. el esquema lógico resultante del esquema conceptual anterior. y el proceso de normalización. Figura 28 Etapas en el diseño lógico Como ya se ha comentado. Esta etapa. 4. con los atributos claves de las entidades que relaciona. con los atributos cod_cantante y cod_disco. Disco_Cantante: siguiendo el mismo razonamiento. la tabla canción generada importará el cod_disco de la entidad disco. para evitar valores nulos. obligando a trasladar a esta etapa aspectos 37 • . es decir. Etapa de reestructuración: donde se tienen en cuenta aspectos más ligados con el nivel físico. y que consiste el modificar el esquema obtenido en la fase anterior para adaptarlo a las consideraciones de eficiencia. siguiendo el mismo razonamiento anterior. Diseño lógico 2. se considera aquí debido a la falta de flexibilidad de los SGBD. al ser una relación N-M. se generará una tabla intermedia. La forma de lograrlo es mediante el particionamiento horizontal. Figura 27 Con todo esto. se generará una tabla intermedia. a si que.

mientras que la Tabla 3 contiene los artículos. bien sea horizontal. Becquer Tabla 1 Editorial Ibérica Alcalá Tenemos información sobre dos libros. La Tabla 2 posee la tabla de libros. mixto y la desnormalización. Cod_publicación 123BB3-3 2322-DD Título El Quijote Rimas y Leyendas Tabla 2 Autor Miguel de Cervantes G. no tiene editorial. es decir llevar parte de la información a una tabla. Becquer Editorial Ibérica Alcalá 38 . es decir. autor. En este caso. supóngase el siguiente ejemplo en el que se tiene la tabla publicación. Comenzaremos por estudiar el particionamiento horizontal de relaciones. el particionamiento horizontal consiste en dividir longitudinalmente las filas que forman una tabla.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS mas relacionados con el nivel físico. podría ser conveniente "partir" dicha tabla horizontalmente en otras dos. la información que tenemos en la tabla es la mostrada en la Tabla 1. como es obvio. Particionamiento horizontal de relaciones Como su propio nombre indica. editorial. Por lo tanto. se crean dos tablas: una para albergar los libros y otra para ubicar los artículos. o artículos. y un artículo (El impacto de las TI) que. Aquí la diferenciación se establece entre aquellas filas que tienen editorial. separar las filas que conforman una relación. y aquellas que no tienen editorial. vertical o mixto. Cod_publicación Título 123BB3-3 113ZD3-0 2322-DD El Quijote El impacto de las TI Rimas y Leyendas Autor Miguel de Cervantes Francisco Hierves G. y el particionamiento. título. para dar paso posteriormente al proceso de normalización. En un momento dado. y parte a otra. A. esto es. con los siguientes campos: cod_publicación. Para entenderlo mejor. con su autor y su editorial correspondiente. para llevarlas a otra. La forma de lograrlo es mediante la desnormalización. usado tanto en la etapa de estructuración como en la de reestructuración. A. libros. dejando para el final el particionamiento vertical.

Un valor nulo es aquel que representa información desconocida. una consulta de un cliente que vive en Barcelona se debería realizar al nodo de Madrid. Supongamos. en el nodo de Barcelona. pues. y las calificaciones obtenidas en cada una de las asignaturas. Los motivos son los siguientes: • Si se sitúa toda la información en un único nodo. y ubicar únicamente la información de los clientes que viven en Madrid en dicho nodo. con determinada información en cada uno) con información acerca de clientes. lo que se deberá realizar en un particionamiento horizontal. Figura 29 Sobre el esquema de la Figura 29. Hierves Con esto. inexistente o no válida (en nuestro caso el valor del atributo editorial en el artículo). es decir. por ejemplo. Se dispone de dos tablas. La tabla alumno guarda sus datos personales. lo lógico sería pensar en situar la información de aquellos clientes que residen en Barcelona en dicho nodo. permanecen nulos. si se dispone de una base distribuida (para entendernos. con el coste que ello supone). el coste del acceso remoto aumenta (si toda la información está en Madrid. y suponiendo que se dispone de dos nodos. Sin embargo. mientras que la tabla profesor 39 . sino que también puede usarse en la fase de reestructuración para conseguir una mayor eficiencia. los aplicables pueden dejar de serlo en algún momento. nos podemos plantear varias cuestiones: 1. uno en Madrid y otro en Barcelona. que tenemos el siguiente esquema lógico. lo que hemos conseguido es eliminar la existencia de valores nulos no aplicables. Esto que acabamos de realizar. Mientras los no aplicables no cambian. correspondiente a una base de datos para gestionar los alumnos de una empresa de educación a distancia. Los valores nulos pueden ser aplicables o no aplicables. situados en distintas localizaciones. en el nodo de Madrid. es el primer paso que se debe seguir en el proceso de estructuración de relaciones. el coste de almacenamiento aumenta al tener toda la información duplicada. Por ejemplo. • En este caso. Si se sitúa toda la información en ambos nodos. para situar aquellas filas que correspondan a clientes de Madrid. alumno y profesor. el particionamiento horizontal no sólo se utiliza aquí. y aquellas filas que correspondan a clientes de Barcelona. una base de datos con distintos nodos.© Grupo EIDOS 4. Diseño lógico Cod_publicación 113ZD3-0 Título El impacto de las TI Tabla 3 Autor Fco.

40 . Puesto que en cada nodo sólo precisa información relevante a éste. al que accederán los demás. 3. Para ello se deben seguir los siguientes pasos: Paso 1: Realizar una consulta para separar las filas correspondientes a cada provincia. arte y latín en letras. la opción que más nos interesa es ubicar cada parte de información relevante a cada una de éstas. acceso. Los alumnos pueden optar por dos ramas. aumentar la eficiencia de la base de datos. es decir. además de sus datos personales. Opción 3: colocar una copia de toda la base de datos en cada nodo. y teniendo la premisa expuesta de que cada provincia trabajará de manera aislada. Opción 1 Opción 2 Cada provincia tendrá la parte de información que le interesa en su propio Si se precisa acceder a otras provincias nodo. podemos optar por tres opciones: Opción 1: colocar la base de datos en un sólo nodo (centralizado). las aulas donde dicho profesor imparte cada una de las clases. al evitar el acceso por red a otras provincias. para adecuarla a las necesidades de cada una de las provincias donde se encuentra ubicada la base de datos. información de todas las provincias en su de forma directamente proporcional al propio nodo. Nos planteamos. En la Tabla 4 se analizan las ventajas e inconvenientes de cada una de la anteriores opciones. disminuyendo el tiempo de número de provincias. donde se almacena la información relevante a ésta. con el tráfico de red y aumento de tiempo de acceso que esto supone. y matemáticas y ciencias en la rama de ciencias. Opción 2: colocar la parte de información relevante a cada nodo en cada uno de ellos. en su nodo local. Ventajas Se disminuye el espacio de almacenamiento (una sola copia de la información). Cada provincia tendrá toda la Se aumenta el espacio de almacenamiento. la respuesta es bastante simple: mediante el particionamiento horizontal. Tabla 4 Opción 3 Analizando la anterior tabla. 2. lo que aumenta la eficiencia en las distintas. pues bien. y en la provincia donde se encuentre la base de datos se disminuirá el tiempo de acceso inconvenientes El resto de las provincias deberá acceder a la provincia donde se encuentre la base de datos. y para cada una de ellas se imparten dos asignaturas. se dispone de un nodo en cada una de las provincias. entonces. ciencias o letras. en cada una de las tablas.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS almacena. se aumenta el tiempo de acceso (tráfico de red) consultas / actualizaciones. La base de datos se encuentra distribuida. La pregunta que surge ahora es ¿cómo se puede realizar?.

al contrario que en el caso del particionamiento horizontal. La forma de proceder es. crear nuevas tablas con la información correspondiente a un subconjunto de los atributos de las mismas. con el objetivo de eliminar estos valores nulos no aplicables. en dividir las tablas de forma transversal. en la tabla alumno_letras. y en la tabla alumno_ciencias. Podemos observar como en la tabla alumno. La sentencia SQL que realiza se ve en el Código fuente 1. Figura 30 Particionamiento vertical de relaciones El particionamiento vertical de relaciones consiste. al menos. cada una de ellas almacenando los atributos correspondientes a cada una de estas ramas. nombre_cliente. La información que tenemos de dicha tabla (Tabla 5) es: cod_proveedor. denominadas alumno_ciencias y alumno_letras. supóngase que se desean ubicar las filas de las tablas alumno y profesor en el nodo provincial de Madrid. ciudad_proveedor. estarían solamente las filas o tuplas correspondientes a alumnos que han escogido la rama de letras. Como ejemplo.© Grupo EIDOS 4. De esta manera es preciso proceder para el resto de las provincias. lo que supone que siempre se darán. que es el de obtener de ambas tablas solamente aquellas filas que corresponden a la provincia de Madrid. dos valores nulos inaplicables en cada fila de la tabla. Supóngase que tenemos la tabla reparto con la información de todos los repartos realizados por los proveedores a los clientes. Veamos un ejemplo para comprenderlo mejor. cod_material. Quédese simplemente con la idea de su funcionamiento. nuevamente. SELECT * FROM alumno WHERE provincia = "Madrid" SELECT * FROM profesor WHERE provincia = "Madrid" Código fuente 1 No se preocupe demasiado si no entiende las anteriores sentencias. respectivamente. Diseño lógico Paso 2: Ubicar la información obtenida en cada uno de los nodos correspondientes a dichas provincias. podremos decidir separar las filas de dicha tabla entre otras dos. Las tablas quedarían entonces como muestra la Figura 30. aquellos que han optado por la rama de ciencias. Llegados a este punto. es decir. Otra de las cuestiones que hemos planteado es la referente a las ramas por las que puede optar un alumno: letras o ciencias. Para ello se realizará una "criba" en ambas tablas donde el campo provincia sea Madrid. ya que un alumno puede optar por una de las dos ramas. mediante un particionamiento horizontal. pero no por ambas. pero manteniendo intacta la información correspondiente a las filas. ciudad_cliente y cantidad. nombre_proveedor. ya que se verán en detalle más adelante. De esta manera. se encuentran atributos que hacen referencia a las calificaciones obtenidas en ambas ramas. 41 . cod_cliente.

Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS cod_ cod_ proveedor cliente 123 128 837 113 114 998 cod_ material 112 118 128 nombre_ proveedor Pepe Luis Antonio nombre_ cliente Juan Paco Ángel Tabla 5 ciudad_ proveedor Sevilla Madrid Barcelona ciudad_ cliente Sevilla Cuenca Manresa cantidad 10 29 12 Dada la Tabla 5. otra con la información del cliente con los atributos nombre_cliente y ciudad_cliente y otra con la información de los repartos con los atributos cod_proveedor. cod_cliente. Para ello realizamos un particionamiento vertical. nombre_proveedor ciudad_proveedor Pepe Luis Antonio Sevilla Madrid Barcelona Tabla 6 nombre_cliente Juan Paco Ángel ciudad_cliente Sevilla Cuenca Manresa Tabla 7 cod_proveedor 123 128 837 cod_cliente 113 114 998 Tabla 8 cod_material 112 118 128 cantidad 10 29 12 42 . sobre estos atributos. podría interesarnos tener varias tablas: una que contenga la información del proveedor. cod_material y cantidad. con los atributos nombre_proveedor y ciudad proveedor.

ya que deberemos obtener toda la fila correspondiente a ese empleado. es decir. se deberá acceder a toda la fila. un mayor consumo de memoria (por el mismo motivo). sin únicamente deseamos obtener el sueldo de un empleado. Por ejemplo. ya que las ventajas que ofrece están relacionadas con la eficiencia. Nos plantemos entonces un particionamiento vertical. la información a la que accedemos tendrá más probabilidad de ser utilizada. si un usuario accede a una fila de una tabla. Esto es debido a que. otro podrá acceder a la misma fila en otra tabla. Puesto que la única transacción (consulta) que se va a realizar (de momento) es la consulta del sueldo de un empleado. • • Por contra. aunque no nos interese su valor. la concurrencia aumenta. Figura 30 Si nos damos cuenta. etc. pero más tablas con menos atributos. por ejemplo. con lo que ello supone. al reducir el tamaño de las filas. se accede a toda la fila de la tabla. la principal desventaja que tiene este método es el aumento del tiempo de consulta / actualización si se desea acceder a dos o más tablas. ésta se bloquea. Aumento de la velocidad de consulta / actualización: al ser las tablas más pequeñas. un aumento del número de operaciones de Entrada / salida (puede que la fila entera no quepa en el buffer de memoria. y debamos realizar más accesos a la base de datos). Puede que esto no nos sea útil. para extraer un solo atributo con todos los inconvenientes que esto supone. en los que no entraremos. ya que escapan del objetivo del presente curso. Es por ello por lo que hay que realizar un estudio pormenorizado de la probabilidad de consultas que se va a realizar. se puede separar esta tabla en 43 . un aumento del tiempo de proceso (debemos procesar toda la fila para extraer un solo atributo). ya que se necesitarán menos accesos a disco para completar la acción. normalmente. Disminución de tiempos de consulta de información irrelevante: si se quiere consultar un solo atributo de una tabla. Diseño lógico El resultado es que tenemos el mismo número de filas en todas las tablas. ni siquiera para consultar el valor de otro atributo). en la que se almacenan los datos personales de los empleados de una empresa. es decir. Entre ellas destacan: • Aumento de la concurrencia: cada vez que un usuario accede a una fila de la tabla. el acceso (o bloqueo de tupla) se realiza al nivel de fila o tupla. una consulta o actualización podrá realizarse en un menor tiempo. como por ejemplo una disminución de la concurrencia (otro usuario no podrá acceder simultáneamente a esa fila. Este proceso se realiza en la reestructuración. Para ello existen varios algoritmos. es decir. Al dividir un tabla en más. supóngase que se dispone un esquema lógico con una sola tabla. existen muchos atributos. a los que deberemos acceder en cada consulta.© Grupo EIDOS 4. En cambio. no puede ser accedida por otro usuario. por ejemplo el de Navathe y Ra.

pero no sería demasiado eficiente).Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS otras dos: una con el atributo sueldo. Destacar que la operación de join es bastante costosa en tiempo de ejecución. pasaría por añadir el campo categoría a la tabla anteriormente extraída. el esquema obtenido no nos valdría (bueno. y otra con el resto. Pues bien. o 2.Utilizar un identificador de fila. y asociarlas a las filas de la tabla homóloga. O bien se aplica un particionamiento vertical a una tabla previamente particionada horizontalmente. existen dos opciones: • Realizar primero un particionamiento horizontal. en este caso. o bien se aplica un particionamiento horizontal a una tabla particionada verticalmente. igual para cada fila en ambas tablas. Por lo tanto. Figura 31 Sin embargo. de hecho si valdría. Figura 32 Particionamiento mixto El particionamiento mixto consiste en un híbrido entre ambos tipos de particionamiento. para obtener ambos valores. como campo unión entre ambas tablas. sino también la categoría de un empleado?. ya que ahora se necesitaría realizar una operación de join o unión entre ambas tablas. ¿que pasaría si ahora se necesita saber no sólo el sueldo. Para identificar unívocamente cada una de estas filas. y 44 . En esta caso optamos por la segunda opción. por ejemplo para ubicar las distintas filas de una tabla en distintos nodos de una base distribuida (como el ejemplo visto anteriormente). De esta manera solventamos los anteriores inconvenientes que se presentaban. La solución.Utilizar un atributo clave. similar para filas iguales en ambas tablas. se pueden usar dos métodos: 1. quedando el esquema lógico particionado verticalmente de la como indica la Figura 31. utilizando el DNI.

ésta última.© Grupo EIDOS 4. La normalización se podría considerar prácticamente como el grueso de la fase de diseño lógico. supóngase que se dispone de la siguiente relación. por un conjunto de esquemas equivalentes que representen la misma información. El particionamiento mixto se usa en la etapa de reestructuración. al no poder insertar filas en una relación. Por lo tanto es el segundo paso a realizar dentro de la fase de diseño lógico. pero que no presenten cierto tipo de anomalías a la hora de realizar operaciones sobre ella. para conseguir un mayor ajuste de los tiempos de acceso a datos (evitar acceder a datos irrelevantes). con el objeto de verificar que el esquema relacional obtenido en esta fase cumple un cierto conjunto de reglas. el de que ha de representar fielmente la realidad. se ha particionado verticalmente en otras dos R3 y R4. e indica los distintos tipos de particionamiento por los que va atravesando una determinada relación. para conseguir disminuir los tiempos de acceso y posteriormente realizar un particionamiento horizontal sobre dichas tablas. ya que se tiene en cuenta aspectos relacionados con el nivel físico (eficiencia). y a su vez. Diseño lógico posteriormente realizar un particionamiento vertical sobre las tablas obtenidas. Cod_proveedor Cod_material 1 1 A234 B298 Ciudad Madrid Madrid Categoría 2 2 Cantidad 122 100 45 . ya que es el encargado de modificar el esquema conceptual obtenido en la fase anterior. La Figura 33 nos muestra como la relación original R se ha particionado de forma horizontal en otras dos R2 y R1. La forma de representar el particionamiento mixto se denomina árbol de particionamiento. Las anomalías que puede presentar una relación son de tres tipos: • Anomalías de inserción: son producidas por la pérdida de información. • Realizar primero un particionamiento vertical. Figura 33 Teoría de la normalización El proceso de normalización consiste en la aplicación de un conjunto de reglas. Por ejemplo. La normalización se puede definir como el proceso de sustituir una relación o tabla. correspondiente a los repartos realizados por distintos proveedores. y se corresponde con la etapa de estructuración. para que cumpla el primero de los objetivos de las bases de datos. después de la eliminación de valores nulos no aplicables (particionamiento horizontal). ya que no se conoce el valor de algún atributo no principal (que no es clave).

se pueden establecer dos conclusiones: el diseño es redundante y el esquema no está normalizado. la segunda forma normal (2FN) y la tercera (3FN). Sigamos con el ejemplo anterior. al menos. Figura 34 Una esquema relacional estará normalizado cuando esté. al existir únicamente una fila con dicho proveedor. es decir. • Por lo tanto. definidas por Fagin. perderemos toda la información relacionada con él. y eso sin contar el tiempo que se pierde en realizar dicha actualización. una que este en 3FN estará en 1FN y 2FN. no se puede reflejar en la relación. no bastará con hacerlo en un sitio. en 3FN. ya que si nos olvidamos de actualizar dicho valor en una fila. La principal característica que cumple cada una de estas formas normales es que la de nivel superior incluye a la de nivel inferior. supóngase el caso anterior. Por estos motivos. y modificar el valor de atributo ciudad en todas ellas. Si se desea modificar la ciudad de un proveedor. Evidentemente esto es muy peligroso. y la cuarta y quinta forma normal (4FN y 5FN). una relación que esté en 2FN estará en 1FN. Anomalías de modificación o actualización: vienen impuestas por la necesidad de propagar actualizaciones. ya que dicho proveedor todavía no ha realizado ningún reparto. lo que se busca con el proceso de normalización es eliminar estos tres tipos de anomalías. Si se desea borrar el reparto realizado por el proveedor 3. es decir. como muestra la Figura 34. distintas formas normales. definida por Boyce y Codd. la base de datos quedará inconsistente. la forma normal de Boyce-Codd (FNBC). Son debidas a un diseño redundante. Se dice que un esquema de relación esta en una determinada forma normal si satisface un determinado conjunto de restricciones. definidas por Codd. Consiste en conseguir. su ciudad y su categoría. 46 . • Anomalías de borrado: vienen determinadas por la perdida de información que no se desea. es decir. al eliminar una fila de una relación. Dichas formas normales son la primera forma normal (1FN). mediante varios pasos. es decir. sino que se deberán recorrer todas las filas correspondientes a todos los repartos de dicho proveedor. existirán dos valores distintos de ciudad para un mismo proveedor.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS 2 2 3 G344 G392 F893 Sevilla Sevilla 3 3 200 310 400 Valencia 1 Tabla 9 Si en este momento se desea añadir un nuevo proveedor. Por ejemplo. se debe modificar el mismo atributo en más de un sitio.

veamos el concepto de dependencia funcional. (varios empleados pueden cobrar lo mismo).© Grupo EIDOS 4. Por estos motivos. Sea la relación R compuesta por los atributos X. se tiene: ISBN. en la que se tiene: X --------> Y Y --------> Z Y ----/---> X 47 . para un mismo DNI no pueden existir más de un nombre. Otro caso particular de dependencia funcional es el de dependencia funcional transitiva. se puede concluir que entre Salario y Nombre no existe dependencia funcional. ya que para un mismo salario pueden existir varios nombres de empleados. Z. si se tiene la relación Libro con los atributos ISBN. Se dice que Y depende funcionalmente de X. Cod_socio ------------> ISBN ----/------> Cod_socio -----/---------> Fecha_préstamo Fecha_préstamo Fecha_préstamo Tabla 11 (1) (2) (3) ya que para un libro y un socio sólo existe una fecha de préstamo (1). Sea el esquema de relación R definido sobre el conjunto de atributos A y sean X e Y subconjuntos de A llamados descriptores. ya que por cada DNI tenemos un nombre. cada valor de X tiene asociado en todo momento un único valor de Y. Sea X un descriptor compuesto por X1 y X2 (X1 y X2 atributos de X). si se tiene la relación Empleado. y se representa X ---> Y. De la misma forma. veamos la Tabla 10. Diseño lógico Para comprender mejor el proceso de normalización y la obtención de las formas normales. X -------> Y X1 --/--> Y X2 --/--> Y (Y depende funcionalmente de X) (Y no depende funcionalmente de X1) (Y no depende funcionalmente de X2) Tabla 10 Por ejemplo. La dependencia funcional plena o completa es un caso particular de dependencia funcional.. Por ejemplo. compuesta por los atributos DNI. etc. es decir. nombre. se puede concluir que Fecha_préstamo tiene dependencia funcional completa de ISBN y socio. o que X determina o implica a Y si. mientras que el mismo libro se puede prestar varios días (2) y un mismo socio puede tomar prestado uno o varios libros más de un día (3). y sólo si. salario. se puede asegurar que DNI ---> Nombre . se dice que Y tiene dependencia funcional plena o completa de X si depende funcionalmente de X pero no depende de ningún subconjunto del mismo. Cod_socio y Fecha_préstamo. Y.

Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS se dice. Cod_alumno 10 Nombre L. no de una parte de la clave.---> Cod_postal. por ejemplo. es crear una fila por cada valor del atributo repetido. Fernández Asignatura Matemáticas Lenguaje 20 P. no está en 1FN. Fernández L. además de estar en 1FN. Cod_alumno 10 10 20 Nombre L. de la forma que indica la Tabla 13. Por ejemplo. Alonso Tabla 13 Asignatura Matemáticas Lenguaje Ciencias Segunda forma normal (2FN): Una relación está en 2FN cuando. y cada dirección sólo tiene un código postal (2). se tiene: Nombre ----------> Dirección (1) Dirección --------> Cod_postal (2) Dirección ---/----> Nombre (3) cada empleado sólo tiene una dirección (1). Alonso Tabla 12 Ciencias La forma de transformar esta relación a otra que sea 1FN sin pérdida de información. Dirección y Cod_postal. Por lo tanto Nombre --. y se tiene la dependencia funcional que sigue: 48 . que Z tiene una dependencia transitiva respecto de X a través de Y. todos los atributos que no forman parte de ninguna clave candidata suministran información acerca de la clave completa. con los atributos Nombre. mientras que varios empleados pueden vivir en una misma dirección (3). Por ejemplo. cada atributo no principal (que no forma parte de la clave) tiene dependencia funcional completa respecto de cada una de las claves. Fernández P. Cod_socio y Editorial. si se tiene la relación Empleado. Veamos a continuación las distintas formas normales. Primera forma normal (1FN): Una relación está en 1FN si cada atributo de dicha relación. tiene un sólo valor en cada fila. entonces. si se tiene la relación Libro con los atributos ISBN. La siguiente relación. O lo que es lo mismo. de los cuales los atributos clave son ISBN y Cod_socio. ya que la primera fila tiene dos valores para el atributo asignatura. y se representa X -------> Z.

es decir. Tercera forma normal (3FN): Una relación esta en 3FN cuando. que esté en 2FN. ya que ahora la dependencia (1) es completa. La cuarta y quinta forma normal dependen de un tipo especial de dependencias. por lo que se ha eliminado la transitividad.© Grupo EIDOS 4. cuya clave es el atributo nombre. Para transformarla a otro esquema equivalente. cosa que puede no interesar en la mayoría de los casos. dicho esquema se encuentra en 3FN. pero cumpliendo la segunda forma normal. así que simplemente se mencionarán. Se dice que una relación esta en forma normal de Boyce-Codd cuando se tiene que para toda dependencia funcional se tiene que el implicante (la parte derecha de la dependencia) es clave. con las siguientes dependencias funcionales: Nombre ----------> Dirección Dirección --------> Cod_postal (1) (2) dicha relación no se encuentra en 3FN. Diseño lógico ISBN ---------------> Editorial (1) dicha relación no esta en 2FN. Dirección y Cod_postal. además de estar en 2FN. que cumplan la tercera forma normal: R1 = {Nombre. Cod_socio} R2 = {ISBN. ya que supone que el esquema este muy fuertemente normalizado. Cod_postal} Ahora las nuevas dependencias que tenemos son (1) en R1 y (2) en R2. Nótese que la relación original se ha descompuesto en otras dos. Editorial} Este es un esquema equivalente al anterior. denominadas multivaluadas y de unión respectivamente. referente a los repartos realizados por varios proveedores en una empresa. supongamos que tenemos la instancia que aparece en la Tabla 14 de un esquema lógico. con los atributos Nombre. al tener que el atributo no principal cod_postal depende transitivamente de la clave nombre. para satisfacer este requisito. Para transformarla a 3FN. Cod_proveedor 1 1 Cod_material A234 B298 Ciudad Madrid Madrid Categoría 2 2 Cantidad 122 100 49 . Por ejemplo. representa la misma información. se descompone dicha relación en otras dos equivalentes. Por ejemplo. depende funcionalmente de una parte de la clave. no de toda ella. Ejemplos prácticos de normalización Para comprender mejor el proceso más importante en la fase de diseño lógico de una base de datos. si tenemos la relación Empleado. es decir. ya que el atributo no principal editorial. Dirección} R2 = {Dirección. Las formas normales que se verán ahora no son muy utilizadas. ya visto anteriormente. se descompone dicha relación en otras dos: R1 = {ISBN. veremos algún ejemplo sobre cómo normalizar un esquema lógico dado. no existe ningún atributo no principal que dependa transitivamente de alguna de las claves de la relación.

ya que la combinación de estos valores no se repiten para más de una fila en la tabla. podemos saber la cantidad abastecida. ya que en cada fila tenemos un único valor para cada atributo. Un esquema lógico. en las que el valor 1 para el código del proveedor implica la ciudad Madrid. estamos en disposición de asegurar la ciudad del mismo. Borrado: si borramos el reparto del proveedor 3. 2FN: el esquema no está en 2FN. La respuesta es no. Conociendo la ciudad. al menos. con el objeto de eliminar las anteriores anomalías. conocemos la categoría Para cada valor distinto del conjunto de atributos cod_proveedor y cod_material. En la Tabla 15 iremos modificando el anterior esquema. El atributo ciudad implica el atributo categoría. tenemos un valor distinto del atributo categoría. tenemos un valor distinto para el atributo cantidad. como podemos comprobar en las dos primeras filas. Actualización: si actualizamos la ciudad del proveedor 1. Es decir. ya que se producen anomalías: • • • Inserción: no podemos almacenar un proveedor. o para las dos siguientes en que el valor 2 para el atributo cod_proveedor implica la ciudad Sevilla. es decir. Para cada valor del atributo ciudad. conociendo el valor del código del proveedor. hasta que no haya realizado algún reparto. tenemos un único valor del atributo ciudad. En nuestro caso. • • 1FN: el esquema está en 1FN.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS 2 2 3 A234 G392 F893 Sevilla Sevilla Valencia Tabla 14 3 3 1 200 310 400 Lo primero que cabe preguntarse es ¿está normalizado?. cod_material cantidad Lo siguiente es encontrar una clave para la tabla. estaría formada por los atributos cod_proveedor y cod_material. está por defecto en 1FN. un atributo o conjunto de atributos que identifiquen unívocamente cada tupla de la relación. Conociendo el código del proveedor y del material. debemos propagar esta modificación a dos filas. normalmente. nos encontramos con la siguiente dependencia: 50 . Tabla 15 cod_proveedor ciudad ciudad categoría cod_proveedor. ya que. aunque está en 1FN. perdemos la información referente a dicho proveedor. Lo primero es identificar las dependencias del esquema: Para cada valor del atributo cod_proveedor. hasta lograr que este normalizado. con la posibilidad de la consiguiente inconsistencia del esquema.

esto es. que depende funcionalmente de una parte de la clave (cod_proveedor). para cada valor de ciudad. nos quedan las relaciones que muestra la Tabla 16. Esto se puede conseguir llevándonos cada dependencia a una relación distinta. de manera tal que se evite la dependencia funcional transitiva entre ambos atributos. tenemos que hay un atributo no principal (ciudad). pero no en 3FN. es decir. ya que el atributo categoría en la relación 2 depende transitivamente de la clave de dicha relación. Diseño lógico cod_proveedor --------> ciudad Puesto que la clave de la relación esta formada por los atributos cod_proveedor y cod_material.cod_material cod_proveedor.© Grupo EIDOS 4. Atributos cod_proveedor. por lo que el atributo ciudad depende de toda la clave. y llevar los demás a otra relación. de tal forma que el atributo ciudad dependa de toda la clave.cod_material cantidad cod_proveedor ciudad categoría Tabla 16 ciudad cod_proveedor De esta manera. que es cod_proveedor. no de toda ella. Una posible forma. Otra forma de proceder es dejar en una relación aquellos atributos que forman parte de la dependencia. junto con las dependencias funcionales que le afectan. puede ser llevar el atributo ciudad junto con la parte de clave de la que depende (cod_proveedor) a otra relación. ya que en la segunda relación la clave es ahora cod_proveedor. Relación 1 cod_maerial cantidad Cod_proveedor Relación 2 ciudad categoría Dependencias Clave Cod_proveedor. cod_proveedor ciudad ciudad categoría Como cod_proveedor no depende funcionalmente de ciudad. puede haber distintos valores de cod_proveedor: ciudad --/ cod_proveedor tenemos que categoría depende transitivamente de la clave cod_proveedor: cod_proveedor categoría Por lo tanto deberemos descomponer la relación 2 en otras dos. ya que en una ciudad puede haber varios proveedores. Por lo tanto. Por lo tanto. ahora la dependencia anterior ya es completa con respecto la clave. 51 . • 3FN: Hasta aquí el esquema está en 1FN y 2FN. deberemos descomponer dicha relación en otras dos.

y domicilio de éste. mediante la descomposición de una relación inicial en otras tres. ya que al existir una sola dependencia. sino sólo una vez en la relación 3. 389 C/Caimán.000 20. 28 Tabla 18 Este esquema no está normalizado. ya que ésta se almacena en la relación 2 Actualización: si cambiamos la categoría de una ciudad. 28 C/Alcala. ya que se producen las siguientes anomalías: • Inserción: No podemos insertar los datos de un profesor hasta que éste no haya impartido un curso. no perdemos la información referente al proveedor. 52 . ya que bastará con insertarlo en la relación 2.000 25. Por lo tanto hemos conseguido obtener un esquema normalizado en 3FN.000 Domicilio C/ Alcala.34 C/Caimán. no hace falta que haga ningún reparto. Borrado: si borramos un reparto. 389 C/Remanso. que representa los cursos impartidos por un profesor. De este modo hemos conseguido eliminar las dependencias que se nos planteaban en la relación original: • • • Inserción: si queremos insertar un nuevo proveedor. no hace falta cambiarla en todas las filas.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Atributos Relación 1 Relación 2 Relación 3 cod_proveedor cod_material cantidad Cod_proveedor ciudad ciudad categoría Dependencias Clave cod_proveedor. Cod_post al 28027 28190 28027 28007 28190 Profesor Juan Pedro Juan Luis Pedro Fecha 01/02/99 03/02/99 03/02/99 01/02/99 03/03/99 Curso Windows 95 Visual Basic Windows 95 Delphi Windows 98 Precio 10. Veamos ahora otro ejemplo de normalización. Supongamos esta vez que tenemos el esquema lógico de la Tabla 18.cod_material cod_proveedor cantidad cod_proveedor Ciudad Tabla 17 ciudad cod_material Ciudad categoría De esta manera se ha eliminado la dependencia transitiva. junto con su fecha.000 15.000 10. es imposible que esta dependa de otra.

cod_postal curso Relación 2 Curso Tabla 20 precio curso Ya hemos eliminado la dependencia no completa de la clave para la anterior dependencia funcional. y en la otra las demás. dejando en una dicha dependencia junto con sus atributos. El atributo profesor identifica unívocamente el atributo domicilio. que en nuestro caso está compuesta por los atributos profesor. Procedemos de igual forma que en el ejemplo anterior. Pero todavía tenemos un atributo que depende de parte de la clave en la relación 1: 53 . Actualización: Si modificamos la dirección del profesor Juan. Cada profesor vive en su domicilio. la relación se encuentra en 1FN.© Grupo EIDOS 4. el atributo precio no tiene dependencia funcional completa con respecto a la clave. Para cada valor diferente del atributo curso. Lo primero es identificar la clave. ya que tenemos la siguiente dependencia: curso -----> precio es decir. 2FN: Dicha relación no se encuentra en 2FN. Atributos Profesor Fecha Curso Domicilio Cod_postal Curso Precio Dependencias Profesor domicilio Clave Relación 1 domicilio Profesor. el atributo curso identifica el atributo precio. Diseño lógico • • Borrado: Si borramos la impartición del curso de Delphi. identifica de manera unívoca cada fila de la relación. cada domicilio tiene un código postal. ya que el conjunto de estos tres atributos. perdemos los datos de dicho curso. debemos hacerlo en dos filas y si modificamos el precio de un curso o el código postal de un domicilio. y del profesor que lo imparte. podemos existe un valor diferente para el atributo precio. Por lo tanto. fecha y curso. Tabla 19 Curso precio Profesor Domicilio domicilio cod_postal Ahora debemos comprobar si dicha relación cumple las reglas de cada una de las formas normales: • • 1FN: Puesto que para cada fila existe un solo valor para cada atributo. fecha. también. sino sólo a una parte. desglosamos esta relación en otras dos. es decir. El siguiente paso es identificar las dependencias funcionales. El atributo domicilio identifica el atributo cod_postal.

fecha curso Relación 2 precio Relación 3 Esta relación ya se encuentra en 2FN. no tiene dependencias no completas de ningún atributo no principal con respecto de la clave. ya que en un mismo domicilio pueden vivir varios profesores. Atributos Relación 1 Relación 2 Profesor Domicilio Curso Precio Dependencias profesor curso domicilio precio Clave profesor curso 54 . • 3FN: El anterior esquema no se encuentra en 3FN. Atributos Relación 1 Profesor Domicilio Cod_postal Curso Precio Profesor Fecha Curso Tabla 21 Dependencias profesor domicilio curso Clave domicilio profesor cod_postal curso Profesor. Ahora podemos asegurar que el esquema se encuentra normalizado hasta la tercera forma normal. para romper esta dependencia. desglosamos la relación 1 en otras dos.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS profesor domicilio Por lo tanto. además de estar en 1FN. tenemos una dependencia transitiva del atributo cod_postal con respecto de la clave: profesor cod_postal Por lo tanto. con lo que nos queda lo que indica la Tabla 22. podemos llevar cada una de ellas a una nueva relación. una que contenga los atributos referentes a dicha dependencia y otra con los demás. ya que. ya que la relación 1 tiene una dependencia transitiva con respecto de la clave: profesor domicilio domicilio cod_postal Como domicilio no depende de profesor.

domicilio y cod_postal. que mantiene la misma información. nos encontramos que para realizarla necesitamos acceder a dos 55 . Si tenemos que no se van a realizar prácticamente actualizaciones. fecha curso domicilio Relación 4 Tabla 22 Lo que hemos conseguido es sustituir un esquema en el que sólo existía una relación. y una parte de esta estructuración es la normalización de relaciones. si el número de consultas es alto con relación al de actualizaciones. cuando posteriormente se va a desnormalizar. en la relación correspondiente. primero se procede a estructurar el esquema. supóngase el ejemplo de los cursos visto en el apartado anterior. o del profesor que lo imparte. La respuesta es simple. Un último detalle a tener en cuenta es el de la descomposición sin perdida de dependencias. En estos momentos. o que simplemente no nos interese que el esquema sea eficiente. Actualización: si cambiamos el precio de un curso. puede que normalicemos hasta un cierto nivel. el proceso de desnormalización supone la unión de varias relaciones en un número menor de ellas. en otro con cuatro. pero que no presenta las anomalías que se daban en el original: • • • Inserción: si queremos dar de alta un nuevo curso lo haremos en la relación 2 y si queremos insertar un nuevo profesor. Destacar.© Grupo EIDOS 4. Sin embargo. el lector puede preguntarse que para qué se procede a normalizar un esquema. y debido a aspectos de eficiencia. Borrado: si borramos la impartición de un curso. Esto supone que puede que el esquema resultante de la normalización sea lo suficientemente eficiente como para que no sea preciso reestructurarlo. lo cual implica que se tardará menos en buscar la información. Proceso de desnormalización El proceso de desnormalización hace referencia justo al proceso inverso de normalización que se acaba de ver. a dejarlo como estaba. que no se queden dependencias en el camino. parte de la cual supone la desnormalización del mismo. o el domicilio de un profesor. se procurará que el esquema esté siempre normalizado al nivel de 3FN. Diseño lógico Relación 3 Profesor Fecha Curso Domicilio Cod_postal Domicilio cod_postal Profesor. es decir. a medida que disminuya el nivel de normalización. ya que se evitarán las anomalías expuestas. sólo se hará una vez. ya que el diseño será redundante. es frecuente que el número de relaciones disminuya. En definitiva. Por ejemplo. es decir. interesará que el nivel de normalización sea bajo. Como norma general. Posteriormente. Además. no perdemos la información de dicho curso. lo haremos en la relación 1. por último. se puede proceder a realizar una reestructuración del esquema. si no que se van a realizar consultas sobre los atributos profesor. esto es. para que el esquema original y el normalizado tengan la misma información. y que solo interese desnormalizar hasta otro determinado nivel. que interesa tener un nivel fuerte de normalización cuando el número de actualizaciones sea alto con relación al de consultas.

Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS tablas (relación 1 y relación 4). donde para acceder a dicha información. fecha curso Relación 2 precio Relación 3 Tabla 23 56 . con el aumento de tiempo de proceso que ello supone. simplemente se precisa consultar la relación 1. Atributos Relación 1 Profesor Domicilio Cod_postal Curso Precio Profesor Fecha Curso Dependencias profesor domicilio curso Clave domicilio profesor cod_postal curso Profesor. Por lo tanto. es decir. se deberá realizar un join. puede interesar en este caso desnormalizar dicho esquema un nivel. hasta 2FN.

del Sistema Operativo y del hardware. características del SGBD. Sin embargo. los requisitos de procesos. equivalente al relacional que permita una definición formal de esa fase de diseño. que optimice el ratio coste / beneficios. y que pueden ser utilizadas para definir un esquema físico. hasta obtener un esquema aceptable. debido a la falta de flexibilidad de los actuales SGBD. debido a la carencia de un modelo formal. es decir. . existen características que son comunes a la mayoría de los productos.Diseño físico Introducción El diseño físico busca conseguir una instrumentación lo más eficiente posible del esquema lógico. El diseño físico es fuertemente dependiente del producto comercial que se vaya a usar. es preciso llevar a cabo a cabo en muchas ocasiones un proceso de reestructuración de relaciones para conseguir una mayor eficiencia. lo que significa que se debe iterar desde el diseño lógico específico al físico y viceversa. considerando los aspectos más cercanos al hardware. pretendiendo los siguientes objetivos: • • • • • Disminuir los tiempos de respuesta Minimizar espacio de almacenamiento Evitar las reorganizaciones Proporcionar la máxima seguridad Optimizar el consumo de recursos Como ya se ha comentado.

etc. está compuesto por varios factores: • • • • Tiempo de arranque: tiempo que tarda el disco en empezar a mover las cabezas. los recursos lógicos (SO. a la par que se mantiene la independencia. también denominado página o bloque. un registro lógico puede estar almacenado en varios registros físicos. El tiempo en acceder a un sector del disco. 58 . deben ser accedidos por el SGBD utilizando los mecanismos de gestión de ficheros que provee el sistema operativo. Inflexibilidad. que es la unidad mínima que puede tratarse en una operación de Entrada / salida. Destacar que esta es la estrategia más utilizada en los actuales SGBD. es decir.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Se podría considerar el diseño físico como una caja negra. que representa la implementación del esquema lógico en un hardware específico. Tiempo de transferencia: tiempo necesario para transferir la información. La principal ventaja de esta estrategia es la independencia físico / lógica del esquema. información sobre las aplicaciones que se ejecutarán en la máquina así como los objetivos que se plantean en esta fase. junto con unas normas de seguridad y unas especificaciones para el ajuste. Conceptos básicos sobre gestión de ficheros La unidad básica de las estructuras físicas (ficheros) es el registro físico. El tamaño de los bloques depende del producto comercial y del sistema operativo.). Las tuplas (en el caso del modelo relacional) se almacenan en dichos registros. Flexibilidad. oscilando éste entre 2 y 4 Kbytes. en la que se toman como entradas los recursos de la máquina. Tiempo de latencia: tiempo que debe esperar hasta que el sector para por debajo de las cabezas. Implica que el administrador de la base de datos pueda diseñar la estructura interna. Los bloques. El SGBD proporciona una estructura interna opcional que el diseñador puede cambiar con el fin de mejorar la eficiencia. el esquema lógico obtenido en la fase anterior. pudiendo almacenar cada uno de éstos varias de aquellas. 3. impidiendo y dejando al administrador pocas opciones de cambiarlo. 2. que es bastante elevado. aunque por contra. Del mismo modo. y se obtienen como salidas una estructura interna. De aquí podemos definir el factor de bloqueo para un fichero como el número de registros lógicos (o tuplas) por bloque para dicho fichero. a memoria principal. Estrategias en el diseño físico Existen tres tipos de estrategias que los fabricantes de SGBD imponen en sus productos comerciales: 1. lo cual supone un aumento de la eficiencia. si los datos son muy grandes. Es el contrapunto al anterior caso. Tiempo de seek: tiempo necesario para mover las cabezas al cilindro (conjunto de pistas del mismo diámetro) requerido. por el bus de datos. el esquema interno resultará más ineficiente. que se encuentran almacenados en los sectores del disco. aunque también de la dependencia físico / lógica. la forma de iterar entre la etapa de diseño lógico específico y la fase de diseño físico. Entre las ventajas que supone utilizar esta técnica estriba la de que la BD puede empezar a funcionar de inmediato al disponer del esquema interno opcional. Híbrido entre ambos. con la posibilidad de ir mejorando sucesivamente la eficiencia al ir realizando ajustes. El SGBD impone una estructura interna.

es decir. A la hora de acceder a dichos atributos. es decir. Los parámetros que se pueden especificar son: • El porcentaje de espacio libre que se deja en cada bloque para albergar posteriores actualizaciones de los registros lógicos. ISAM: Es una opción más amplia que la anterior. Se pueden agrupar determinado número de bloques contiguos en unidades llamadas extensiones.© Grupo EIDOS 5. Hash: Es una forma de organizar los ficheros teniendo como base una tabla indexada que apunta a la información. entre la que la más usada es la LRU (Least Recently Used). utilizando diversas políticas. ya que de todas maneras se necesita acceder a todas las filas. un registro detrás de otro. denominado caché o buffer. Otra política es aprovechar la ley de proximidad referencial. se suele usar un dispositivo de almacenamiento intermedio. Árbol B+: Es una estructura que soporta búsquedas dicotómicas (el número de búsquedas es menor que log2 n). ya que soporta búsquedas por valores de clave. el tiempo de acceso será instantáneo. Un índice se define sobre uno o varios atributos. Este dispositivo es gestionado por el sistema operativo. Número de bloques que se asignan a las extensiones. Al modificar un valor de un atributo. • • • Técnicas para el aumento de eficiencia Existen varias técnicas para aumentar la eficiencia del esquema: • Índices: Se puede definir un índice como una estructura que sirve para mejorar la eficiencia de las consultas a una base de datos. evitando de este modo accesos extra a disco. Algunos SGBD permiten especificar las características de los registros físicos. tienen una alta probabilidad de que sean usados en un futuro cercano. Diseño físico Para acelerar este proceso. un índice (ya se verá más adelante lo que es) estorbaría. puede que éste no quepa en el espacio reservado. Es conveniente usar esta forma de organización cuando existe una carga masiva de datos. que en este caso actúa como función para determinar la posición donde se encuentra la información. de forma que el acceso a los mismos se realice de una y otra forma: • Secuencial: El método de acceso es secuencial. es decir. es decir. que incide en un menor tiempo de respuesta. los datos que han sido usados más recientemente. son candidatos a desalojar la caché para albergar otros bloques. además de por parte de ella o usando patrones de búsqueda. Es útil cuando las filas se recuperan por el valor de la clave. cuyo cometido es el de almacenar los datos más usados. aprovechando de este modo la ley de proximidad temporal. Porcentaje de utilización de cada bloque. es decir. las tablas son pequeñas o cuando se accede a casi todas las filas. Un índice se puede 59 . La ventaja con respecto al caso anterior es que crece de forma dinámica. los datos próximos tienen mayor probabilidad de ser referenciados. De esta forma se evita la concatenación de bloques. • • Organización de ficheros Existen varias formas de organizar los ficheros. los bloques que se han usado hace más tiempo.

pero se debería acceder a dos. Cod_jugador 10 20 25 30 49 80 90 Nombre Adrián Fernando José Claudio Fernando Rafael Rafael Apellido Illie Redondo Guardiola López Hierro Alkorta M. y que no van a ser alterados No indexar tablas pequeñas No indexar tablas que se van a recorrer secuencialmente . si disponemos de dicho índice. solo se realizaría un acceso. mientras que si no lo tenemos. podemos acceder a la página del libro de forma inmediata. se deberá acceder a todas las filas. las filas cuyo nombre es Rafael. que no permita valores repetidos). se suele indexar la clave primaria (mediante un índice único. la de nombre Rafael y equipo Deportivo. supóngase que tenemos la relación que muestra la Tabla 24. Si tuviésemos un índice por el atributo Nombre. Madrid At. La siguiente lista resume una serie de consejos a la hora de indexar campos: • • • • • 60 Indexar la clave primaria con un índice único Indexar las claves ajenas. o aquellos atributos que no vayan a ser modificados. ya que cuanto mayor sea esta estructura. Por ejemplo. Vázquez Tabla 24 Equipo Valencia R. reduciéndose en este caso el número de accesos a dos. mayor espacio de almacenamiento será necesario. sin contar el tiempo que se pierde en actualizar el índice cuando se modifica algún valor de los atributos que forman parte de él. es decir. Madrid Barcelona Valencia R. Sin embargo. los accesos serían inmediatos a las dos únicas filas que cumplen este requisito.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS comparar con el índice de un libro. es decir los atributos de una tabla que son clave que otras tablas Indexar aquellos atributos que se van a consultar con más frecuencia. encontrándose dos jugadores que cumplen este requisito. Por este motivo. se han realizado siete accesos. se realizarían siete accesos (toda la tabla). se encontraría una única fila. es decir. Bilbao Deportivo Si en este momento se desea hacer una consulta sobre todos los jugadores que se llamen Fernando. es decir. Si ahora se desea buscar todas las filas con el nombre de Rafael. si se dispone de un índice por el atributo Nombre. deberemos ir mirando hoja por hoja hasta encontrar la página deseada. y que pertenezcan al Deportivo. Sin embargo si tuviésemos un índice combinado para los atributos Nombre y Equipo. Sin embargo no todo son ventajas. Ya se ha visto entonces la ventaja de usar este tipo de estructuras para acceder rápidamente a la información.

la compresión de datos permite reducir el espacio requerido para almacenar la información. que cambien el valor de todos los atributos duplicados. La forma más segura de controlarlo es mediante disparadores o triggers. esta redundancia debe ser controlada. Figura 35 Con este método se consigue mejorar la eficiencia en la consulta simultanea de ambas tablas. es decir. La técnica de compresión más utilizada es la de compresión diferencial. que consiste en almacenar la diferencia entre el valor de un atributo y el que le precede. Sin embargo. Sin embargo. cuando cambia uno de éstos. • Compresión de datos: Por un lado. Diseño físico • • No indexar atributos de tipo carácter muy largos Agrupamiento o "clustering": Se entiende por "clustering" de tablas la agrupación de tablas cuyas filas comparten un grupo de atributos llamado clave de agrupamiento. • Redundancia de datos: La redundancia de datos consiste en duplicar el valor de ciertos atributos de una tabla en otra.© Grupo EIDOS 5. 61 . Esta técnica supone una desnormalización física de las tablas. lo que radica en un menor número de operaciones de Entrada / salida. se debe garantizar la consistencia de la base de datos. pero que lógicamente siguen siendo dos tablas independientes. por lo que el agrupamiento será transparente al usuario. que se encuentran físicamente agrupadas. con el fin de evitar accesos a tablas consultadas frecuentemente. pero empeora cuando se recorren de forma separada. La Figura 35 muestra un agrupamiento de dos relaciones Empleado y Departamento. se requiere un mayor tiempo de proceso debido a la necesidad de descomprimir los datos que se recuperan.

.

pero además se le han añadido ciertas funciones adicionales. ¿Por qué se llama SQL Server?. etc. El Transact SQL. SQL Server abarca. se llama SQL porque utiliza este lenguaje para la definición y manejo de los datos. como su propio nombre indica. y que son específicas para este producto. soporta la definición. .. que se denomina Transact SQL. tanto el área de diseño. el lenguaje de manipulación de datos (DML). es decir. es decir. como la de administración. modificación y eliminación de bases de datos. la gestión de un entorno de bases de datos relacional. si ejecutamos una sentencia del conjunto adicional (Transact SQL) en otro SGBRD. así como la consulta. Pues bien. sigue una arquitectura cliente/servidor. que son los que realizan las peticiones a éste. es decir. desarrollado por Microsoft. que permite. proporcionando un interfaz bastante amigable con el usuario. atributos. éste no la entendería. SQL Server utiliza una extensión al SQL estándar. actualización y borrado de tuplas de tablas. índices. no contempladas en el estándar. el lenguaje de definición de datos (DDL). y se llama Server porque dispone de una parte servidora que se encarga de atender a los procesos clientes. Esto quiere decir que soporta el SQL de ANSI. tablas. es decir.Introducción a SQL Server ¿Qué es SQL Server? SQL Server es un Sistema de Gestión de Bases de Datos Relacionales (SGBDR).

ante el boom del PC. Sin embargo. ante la falta de resultados positivos. que fue la primera base de datos relacional en utilizar el lenguaje SQL. obliga a pensar si SQL Server puede ser útil para manejar y/o obtener datos de la red de redes. los SGBD relacionales más vendidos resultan ser ORACLE y SQL Server. Desde entonces y hasta hoy. que significa Open Database Connection (Conexión abierta a Bases de Datos). por ejemplo. obtenidos de una base de datos SQL. Sin embargo. que no tiene por qué saber las características de ésta. La aparición de Internet. Fue un poco más tarde cuando RSI decidió cambiar su nombre por el de su producto estrella. SQL Server fue avanzando. destinado a investigar el modelo relacional. principios de los ochenta. otra forma de acceder a una base de datos desde Internet es la ofrecida por un producto llamado Microsoft Internet Information Server (IIS). sobre todo con ORACLE. RSI lanzó al mercado la versión 2 de ORACLE. pero en este caso se ofrecen una serie de funcionalidades especiales para adaptarlo al lenguaje Java. deciden aliarse para sacar un nuevo producto al mercado: una base de datos relacional. de Ashton-Tate. sobre todo durante estos últimos años. también han ido experimentado un largo y constante cambio. a la vez que han ido apareciendo otros nuevos. A su vez. Este hecho supuso el nacimiento de SQL-Server. para PC. ORACLE. Microsoft y Sybase. y que supone la abstracción por parte del usuario que quiere acceder a la base de datos. Fue entonces cuando la aparición de Windows NT reemplazó a OS/2 como soporte para SQL Server. En 1979. SQL Server e Internet El impacto que. Mediante esta forma. originando una batalla para ganar posiciones en este mercado. por aquel entonces algo utópico. La combinación de éste con SQL Server. Por aquel entonces. ha venido sufriendo el uso de Internet. IBM y Microsoft se comprometieron a desarrollar un nuevo entorno. empezaban a implantarse las bases de datos relacionales.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Orígenes Como podemos comprobar. los cuales hacen todo el trabajo de traducción. ofrece una potente forma de unir SQL e Internet. capaz de soportar SQL-Server. y le dieron el nombre de OS/2. se decidió cancelar el proyecto. La verdad es que las interfaces de acceso a bases de datos. Cuando surgió aquella maquina que hoy denominamos PC. El interfaz de acceso a bases de datos por excelencia. adaptándose a las nuevas tendencias del mercado. Ashton-Tate. ha sido siempre ODBC. dirigido a las bases de datos. En el año 1988. nadie podía imaginar que iba a desbancar de su puesto a las grandes plataformas como el Sistema 36 de IBM o el VAX de Digital. 64 . el mercado de la informática ha ido cambiando sorprendentemente desde hace unos pocos años. con el fin de adecuarse a las necesidades cambiantes del mercado. IBM. ODBC ofrece una serie de métodos encapsulados. Su cometido es el mismo que ODBC. se pueden mostrar datos en un navegador de Internet. pero ni por asomo podían ser utilizadas en los PCs. supuso el nacimiento de un nuevo interfaz. llamado JDBC. A su vez. adecuado al lenguaje Java. y venderlo a Relational Software Inc. (RSI). Sin embargo. ORACLE fue el nombre que se le dio a un proyecto. la aparición de dBase. supuso una revolución en el mundo de las bases de datos para PC.

lo cual ha hecho posible la mejora y adaptación del mismo. cabe destacar las siguientes: • • • • • Soporte para XML. SQL-Server ha ido evolucionando a lo largo de los últimos años. mejoras que pasamos a detallar a continuación. Funciones de usuario. La Figura 36 muestra la arquitectura general de este SGBD. Soporte para Virtual Interface Architecture (VIA). Particionamiento horizontal de relaciones y gestión de vistas distribuidas.Lo nuevo en SQL-Server 2000 Introducción Como decíamos. Indexación de vistas. . Nuevas características Entre las nuevas características que ofrece SQL-Server 2000. La apuesta de Microsoft por este SGBD ha sido (y es) bastante fuerte. sobre todo al entorno remoto y distribuido. Veremos en este capítulo las mejoras que ha sufrido esta nueva versión. con respecto a las anteriores.

Bases de datos con SQL Server 2000 – Transact SQL

© Grupo EIDOS

• • • • • •

Nuevos tipos de datos. Nuevos triggers. Reglas de integridad referencial en cascada. Nuevas características de indexación. Soporte para consultas distribuidas. Características de seguridad y cifrado de datos.

Figura 36

Soporte para XML
El Extensible Markup Language, más conocido como XML es un metalenguaje, es decir, un lenguaje utilizado para definir lenguajes, y que se usa sobre todo para el intercambio de datos. Su sintaxis es similar a la que nos ofrece el HTML, es decir, un conjunto de etiquetas que definen la estructura de los datos. El Código fuente 2 define un posible formato de intercambio.
<cliente> <nombre>Pepe</nombre> <apellidos>Lopez</apellidos> <telefono>912345678</telefono> </cliente> Código fuente 2

66

© Grupo EIDOS

7. Lo nuevo de SQL - Server 2000

SQL-Server 2000 ofrece la posibilidad de devolver un conjunto de resultados utilizando para ello este tipo de formato, facilitando así el intercambio de datos.

Particionamiento horizontal de relaciones y gestión de vistas distribuidas
Otra de la características nuevas que nos ofrece SQL-Server 2000 es la posibilidad de particionar horizontalmente los datos de una relación. Ya se ha comentado lo útil que es este tipo de reestructuración de relaciones, sobre todo en el ambiente distribuido, en el cual se pueden colocar las tuplas en los servidores que se supongan más posibilidades tengan de consultarlas en forma local. Del mismo modo, se pueden definir vistas distribuidas que accedan a estos datos, en cada uno de los servidores que nos interese, de manera que la ejecución de la misma dé la impresión de estar interactuando sobre un conjunto completo de resultados.

Soporte para Virtual Interface Architecture (VIA)
SQL-Server 2000 introduce nuevas librerías de red, que permiten definir un entorno distribuido de forma eficiente, posibilitando una gran conectividad, tanto de servidores como de aplicaciones, en este tipo de entornos.

Funciones de usuario
Una funcionalidad nueva que aparece en esta versión del SGBD es la de permitir al usuario definir sus propias funciones. De esta forma se pueden definir funciones que oculten parte de la complejidad que puede entrañar una consulta, no sólo para la posterior reutilización de la misma, sino también teniendo en cuenta la abstracción para otros programadores que puedan precisar su uso.

Indexación de vistas
Esta funcionalidad permite optimizar la ejecución de vistas que actúan sobre la base de datos, creando índices sobre los resultados de ejecución de la misma, que son almacenados en la base de datos. El usuario no debe preocuparse de la actualización de los datos, sino que éstos son indexados automáticamente cada vez que se actualicen.

Nuevos tipos de datos
SQL-Server 2000 soporta tres nuevos tipos de datos con respecto a la anterior versión, la 7, que son el bigint o entero de 8 bytes, sql_variant, que soporta el almacenamiento de valores de distintos tipos, y table, que permite el almacenamiento temporal de resultados para su uso posterior.

67

Bases de datos con SQL Server 2000 – Transact SQL

© Grupo EIDOS

Nuevos triggers
Un trigger o desencadenador es un código especial que se ejecuta cuando se cumple una determinada condición, como por ejemplo al modificar o borrar datos (se verá en detalle en un capítulo posterior). SQL-Server 2000 soporta dos nuevos tipos de triggers, que son INSTEAD OF y que sustituye el comportamiento de ciertos comandos, como por ejemplo insert, update o delete, y AFTER, que se ejecuta una vez concluida la acción que lo ha desencadenado.

Reglas de integridad referencial en cascada
Las reglas de integridad referencial son la base del mantenimiento de la consistencia en la base de datos, y hacen referencia a información que esta relacionada entre si, como por ejemplo el departamento de un empleado cuyo código se especifica. La forma más usual de mantenerlo es usando claves foráneas, y especificando el comportamiento de las inserciones, borrados y actualizaciones de este tipo de datos.

Nuevas características de indexación
Las nuevas características de indexación permiten crear índices sobre campos calculados (no existen como tal en la base de datos, sino que se calculan a partir de otros valores), así como especificar si se desea construir estos índices de manera paralela, lo que aumenta la velocidad de procesado.

Soporte para consultas distribuidas
El optimizador de consultas ofrece la funcionalidad de ubicar datos en servidores distribuidos, dependiendo de valores tales como el nivel de carga, el tráfico de red, etc., de manera que las consultas pueden acceder a distintos servidores para obtener el resultado final.

Características de seguridad y cifrado de datos
SQL-Server 2000 utiliza Kerberos como servidor de autenticación, para acreditar el acceso al servidor que se realiza desde el cliente, así como diversas técnicas de seguridad.

68

Instalación de SQL Server 2000
En este capítulo, veremos como instalar SQL Server 2000, y las distintas opciones que plantea. Para empezar, introduzca el CD-ROM que contiene el programa. Si no arranca automáticamente, utilice el explorador para ejecutar el fichero autorun contenido en el CD-ROM. Tenemos dos opciones, la standard o la personal. La primera de ellas realiza una instalación completa, incluyendo los componentes servidor, mientras que la segunda es útil en el caso de que no dispongamos de un servidor. La primera pantalla que aparece es la que se muestra en la Figura 37.

Figura 37

únicamente se instalarán los componentes cliente). pulsamos la opción SQL Server 2000 Components. en el cual se haya instalado la versión 5. Figura 38 Pulsamos el botón Next. el único requisito que se necesita es disponer de un equipo con al menos 64 Mb de memoria RAM (recomendable 128 Mb) y sistema operativo Windows 98/NT/2000. Figura 39 70 .Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS En nuestro caso instalaremos la opción standard (si no disponemos de un servidor. apareciéndonos la pantalla que muestra la Figura 38. En principio. visualizándose la pantalla que se muestra en la Figura 39. Para proseguir la instalación.5 del navegador WEB Microsoft Internet Explorer.

sólo se nos permite seleccionar la opción de crear una nueva instancia de SQL Server.© Grupo EIDOS 8. Figura 41 71 . puesto que queremos instalar los componentes cliente en nuestro equipo local. Pulsando el botón Next. Si pulsamos el botón Next. donde se nos insta a poner nuestro nombre y compañía. Instalación de SQL .Server 2000 En este caso. sólo nos permite la selección de esta opción. visualizaremos la siguiente pantalla que muestra la Figura 40 Figura 40 Nuevamente. obtendremos la pantalla que se muestra en la Figura 41. al estar instalando la versión standard en un equipo con Windows 98.

podremos visualizar la pantalla que se muestra en la Figura 42. cuyo cometido es el de mostrarnos las condiciones de uso de la licencia. pulsamos Yes para pasar a la siguiente pantalla que se indica en la Figura 43. en la que podemos seleccionar los componentes y subcomponentes a instalar. 72 . accederemos a la pantalla de la Figura 44. Figura 42 Figura 43 Seleccionando la opción de instalación de las herramientas cliente y pulsando el botón Next.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Si pulsamos nuevamente el botón Next.

Figura 45 73 . mostrará la pantalla final en la cual se nos informa de la conclusión del proceso de instalación. tras la cual el sistema empezará a instalar los componentes seleccionados y. como muestra la Figura 46. para acceder a la página de la Figura 45. tras unos minutos.© Grupo EIDOS 8.Server 2000 Figura 44 Dejamos marcados los que vienen por defecto y pulsamos el botón Next. Instalación de SQL .

Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Figura 46 74 .

tal y como se plasmarían las relaciones en tablas. y accederemos a la opción Diagramas (Diagrams) de la base de datos deseada dentro del grupo Bases de datos (Databases). las restricciones. sino a nivel lógico. . es decir. En la parte derecha podremos observar como aparecen todos los diagramas disponibles para la base de datos seleccionada. como muestra la Figura 48. pudiendo además especificar cuestiones como la integridad referencial. Para acceder a esta herramienta. pero no a nivel conceptual. bastará con hacer doble click con el ratón sobre el. deberemos acceder a la opción del Administrador corporativo o Enterprise manager. etc. mientras que para crear uno nuevo.El modelo E/R en SQL-SERVER 2000 Introducción SQL-Server nos ofrece una herramienta para realizar diseños relacionales. Una vez dentro. como muestra la Figura 47. daremos de alta el registro de servidor (si no se encuentra ya hecho). Para acceder a uno de ellos. seleccionaremos la opción New Database Diagram del menú contextual que aparece al hacer click con el botón derecho del ratón sobre esta pantalla.

Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Figura 47 Figura 48 76 .

Pulsamos el botón Siguiente para avanzar al siguiente paso. Figura 49 Figura 50 77 . que no es más que la primera página de un asistente que nos guiará durante el resto del proceso de creación del diagrama. El modelo E/R en Sql-Server 2000 Crear un nuevo diagrama Vamos a crear ahora un nuevo diagrama. que se muestra en la Figura 50.© Grupo EIDOS 9. como la de la Figura 49. para lo cual actuamos como se acaba de comentar. Nos aparecerá entonces una ventana.

que tendrá un aspecto similar al mostrado en la Figura 52. para trabajar posteriormente con el. pulsando el icono en forma de disco de la barra de herramientas. en el que se nos muestran las tablas que hemos seleccionado. las claves (que aparecen con un icono en forma de llave). Esta opción es muy útil para chequear restricciones de una tabla que no sabemos con cuales se relaciona. Vamos a guardar nuestro diagrama. La forma de añadir una tabla al diagrama es seleccionándola y pulsando el botón Add. y las relaciones entre ellas. como el lector ya habrá podido adivinar. 78 . En el podemos observar las tablas que hemos seleccionado. La caja de selección que aparece en la parte inferior bajo el nombre Add related tables automatically permite añadir todas las tablas relacionadas con las seleccionadas de manera automática. habremos de pulsar el botón Remove. tablas relacionadas de tablas relacionadas. y ya tenemos nuestro diagrama. Una vez seleccionadas todas la tablas que deseamos pasen a formar parte del diagrama (en nuestro caso escogemos las tablas authors. pudiendo además especificar el número de niveles que se incluirán. y dándole un nombre coherente. que se muestra en la Figura 51.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS En la parte izquierda nos aparecen todas las tablas disponibles. Pulsamos el botón Finalizar. mientras que para eliminarla del mismo. mientras que en la derecha tenemos las tablas que nosotros seleccionaremos para pasar a formar parte de nuestro diagrama. pulsamos el botón Siguiente para avanzar al próximo paso. es decir. Figura 51 Este es el último paso. junto con el nombre de sus atributos. Estas relaciones muestran las dependencias existentes entre ellas. titleauthor y titles).

© Grupo EIDOS 9. pulsamos con el botón derecho del ratón en la opción Propiedades (Properties) del menú contextual. y el atributo que actúa como clave ajena dentro de la tabla destino y le damos un nombre a dicha restricción. sin soltarlo. Para visualizar este tipo de características. En la pestaña Indexes/Keys es donde se especifican aspectos referentes a los índices que van a hacer referencia a los atributos de la tabla. arrastrarlo hasta la tabla que contiene la clave primaria con la cual se relaciona. existe otra manera mucho más cómoda. 79 . para establecer este tipo de reglas. El modelo E/R en Sql-Server 2000 Figura 52 Restricciones e integridad referencial Una de las principales utilidades que nos ofrece esta herramienta es la de establecer las restricciones y las reglas de integridad referencial de una manera fácil y visual. que es seleccionar con el ratón el atributo que es clave ajena dentro de una tabla y. Para ello debemos indicar el atributo que actúa como clave primaria dentro de la tabla origen. y cuyo aspecto es el mostrado en la Figura 54. Sin embargo. dentro de la tabla o relación deseada. Dentro de la pestaña Relationship se pueden especificar restricciones y características tales como la integridad referencial. apareciéndonos una pantalla similar a la de la Figura 53.

Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Figura 53 Figura 54 80 .

Dentro de la pestaña Check Constraints podemos indicar las restricciones sobre los atributos de la tabla. esto es. como muestra la Figura 56. añadir o borrar tablas o atributos del diagrama (existentes o nuevas). El modelo E/R en Sql-Server 2000 En esta pantalla podemos crear o borrar índices. El índice primario hará referencia a la clave primaria de la relación. definidos sobre uno o varios atributos. inserciones y actualizaciones. Figura 55 Modificación del esquema Aparte de definir restricciones. crear nuevas relaciones. en la Figura 55 se especifica una restricción sobre el atributo clave de la tabla. cluster.© Grupo EIDOS 9. aunque también podemos especificar otro tipo de índices. especificando mediante una expresión regular que dicho atributo deberá ser rellenado con 9 dígitos. 81 . de tipo ascendente o descendente (se refiere a la ordenación). cambiar el tipo o el nombre de los mismos. la herramienta de diagramas también nos da la posibilidad de realizar modificaciones del esquema. Por ejemplo. y que se aplicará en las replicaciones. etc. nuevamente habrá que escoger la opción correspondiente haciendo click con el botón derecho del ratón. Para ello. como de tipo único. etc.

es pulsando sobre el y escribiendo directamente el nuevo sobre la tabla. El diagrama resultante es el mostrado en la Figura 59. Si hacemos click derecho y escogemos la opción propiedades sobre la nueva relación creada. como muestra la Figura 57. Una vez que aparezca la tabla seleccionada en el diagrama. mostradas en la Figura 60 Figura 57 82 . sólo tendremos que confirmarlo ante la pantalla que nos aparece en la Figura 58. Para ello pulsamos con el ratón el atributo stor_id en la tabla authors y.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Figura 56 Otra de las formas de modificar. vamos a añadir la relación con una existente. y escoger la pestaña Columns. Crear una nueva relación Una vez vistos los principales conceptos en la creación de diagramas. sin soltarlo. por ejemplo. Lo primero es seleccionar la opción Add Table del menú contextual y seleccionar la tabla existente en el esquema que deseamos añadir al diagrama. para practicar lo aprendido hasta ahora. o cambiar el tipo haciendo click derecho en el atributo y escogiendo la opción de propiedades. Ya tenemos la relación entre ambas tablas. nos movemos a la tabla stores. vamos ahora a crear una nueva relación con una tabla existente. el nombre de un atributo. podemos observar las restricciones y las reglas de integridad aplicables a la misma.

El modelo E/R en Sql-Server 2000 Figura 58 Figura 59 83 .© Grupo EIDOS 9.

Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Figura 60 84 .

con las opciones disponibles. una barra de menú. Podemos observar en ella un editor. que sirve para ejecutar las sentencias. Disconnect: Cierra la conexión a la base de datos en uso.El analizador de consultas Introducción El analizador de consultas (o query analizer) es la herramienta que permite editar y ejecutar sentencias de T-SQL. y una barra de herramientas con iconos de acceso rápido a ciertas utilidades. pero para todas las conexiones abiertas New: Abre una nueva ventana dentro del editor. Save: Guarda a un archivo la ventana del editor en uso. . podemos encontrar las siguientes: • • • • • • Connect: Abre una nueva conexión a una base de datos. Disconnect all: Idem que el anterior. Open: Abre un archivo de SQL existente. Su apariencia es la que muestra la Figura 61. Las opciones de menú Entre las opciones que ofrece el menú File.

pero con la posibilidad de indicar un nombre de archivo. Recent file list: Muestra una lista con los archivos más recientemente usados. Exit: Cierra el analizador de consultas.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS • • • • • Save as: Idem que el anterior. pero para todas las ventanas abiertas en el editor. Save all queries: Idem que el anterior. Figura 61 Figura 62 En el menú Edit podemos encontrar las siguientes opciones: 86 . Print: Imprime la ventana en uso del editor.

procedimientos almacenados. Insert template: permite añadir una plantilla de una sentencias. Go to line: Mueve el cursor a una línea determinada. Find: Busca un texto determinado dentro de la ventana en uso del editor. rellenarla con las tablas. que se ajusten a sus necesidades. dentro de la ventana en uso del editor. El analizador de consultas • • • • • • • • • • • • Undo: Deshace el último cambio realizado en el texto de la ventana en uso del editor.). Clear window: Borra todo el contenido de la ventana en uso del editor. Replace: Reemplaza un texto por otro. Select all: Selecciona todo el texto de la ventana en uso del editor. ahorrando al programador la mayor parte del trabajo. etc. muy util para sentencias repetitivas. Repeat last find: Idem que el anterior. Replace template parameters: Permite al usuario cambiar los parámetros dentro de una plantilla. Además SQL-Server nos ofrece plantillas predeterminadas.© Grupo EIDOS 10. Cut: Corta el texto seleccionado al portapapeles. Paste: Pega el contenido del portapapeles a la ventana en uso del editor. Advanced: Opciones avanzadas de edición. pero para buscar varias coincidencias. campos. dentro de la ventana en uso del editor. etc. para cada uno de los casos más representativos (creación de vistas. o marcas dentro del texto de las sentencias a ejecutar. es dccir. Bookmarks: Permite manejar los bookmarks. • • Figura 63 87 . Copy: Copia el texto seleccionado al portapapeles. para su mejor identificación.

se muestra el plan de ejecución de la consulta. es decir. como cuestiones diversas sobre T-SQL. relacionadas con la edición y ejecución de consultas: • • • • • Change Database: Permite cambiar la actual conexión a una base de datos por otra.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Dentro del menú Query nos encontramos con las opciones disponibles. • • • • • • • • Por su parte. etc. navegar entre ellas. se muestran estadísticas de ejecución de la consulta. para colocarlas en cascada. pasos de la ejecución. consumo de procesador. se muestra información acerca de la traza de ejecución de la consulta en el servidor. Por último la opción Help ofrece una completa ayuda tanto del editor. separados por filas y columnas. Current connection properties: Muestra información acerca de la actual conexión a la base de datos. en mosaico. Cancel executing query: En el caso de que se esté ejecutando una consulta. Execute: Ejecuta la consulta del editor. y mostrando errores si no cumple con ésta. los resultados de la consultas serán enviados a un archivo. junto con los resultados. Si la opción display estimated execution plan nos enseñaba el plan estimado. Una posible estadística es la mostrada en la Figura 67. una vez realizada. los resultados de la consulta serán mostrados en una rejilla o grid. Show client statistics: Si esta opción está marcada. desglosando en pasos cómo se ejecutará la consulta. En particular. Results in grid: Si está marcada esta opción. Results in text: Si está marcada esta opción. permite detenerla. La opción Window permite manejar las ventanas que se encuentran dentro del editor. esta opción muestra. Results to file: Si está marcada esta opción. el plan real de ejecución de ésta. vista desde la parte cliente. verificando su sintaxis. Display estimated execution plan: Muestra el plan previsto. Show execution plan: Si esta opción esta marcada. La Figura 65 indica un posible plan de ejecución para una consulta concreta. número de lecturas/escrituras. Parse: Compila la consulta del editor. los resultados de la consulta serán mostrados en formato textual. etc. esta opción arranca un asistente para realizarlo. 88 . La Figura 66 muestra una posible traza de ejecución en el servidor de una sentencia select de ejemplo. Show server trace: Si esta opción está marcada. la opción de menú Tools muestra opciones referentes a herramientas que se pueden usar para configurar diversas opciones referentes al editor o ejecución de consultas. Index tunning wizard: Permite realizar el ajuste o “tunning” (cuyo concepto ya ha sido visto en los primeros capítulos) de los índices de una base de datos concreta.

El analizador de consultas Figura 64 Figura 65 89 .© Grupo EIDOS 10.

Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Figura 66 Figura 67 90 .

pudiendo utilizar para ello una plantilla. Ejecuta la consulta.© Grupo EIDOS 10. Compila la consulta para verificar su sintaxis. rejilla o archivo) y la información adicional (plan de ejecución. Muestra el plan estimado de ejecución de la consulta Muestra una lista de los objetos del sistema Permite realizar una búsqueda de los objetos del sistema Muestra información acerca de la actual conexión Muestra el panel de resultados de la ejecución de la consulta 91 . trazas de servidor y estadísticas de cliente). Abre una consulta existente en un archivo Guarda la consulta del editor en un archivo Introduce una plantilla de consulta en el editor Corta el texto seleccionado al portapapeles Copia el texto seleccionado al portapapeles Pega el texto almacenado en el portapapeles Borra el contenido de la ventana del editor Busca un texto determinado en la consulta del editor Deshace el último cambio realizado en la consulta del editor Permite seleccionar la forma en que se mostrarán los resultados (en texto. Permite seleccionar la base de datos. Detiene la ejecución de una consulta. El analizador de consultas La barra de herramientas Crea un nueva consulta.

La de arriba contiene la sentencia a ejecutar. Escogemos una de ellas. SELECT * FROM titles Código fuente 3 A continuación ejecutamos la sentencia. ya tenemos acceso a todas las bases de datos existentes en el servidor. como muestra la Figura 68. ya que entraremos en detalle en posteriores capítulos). escogiendo la opción Execute del menú Query. Ejecutamos nuevamente. Para ello accederemos al analizador de consultas. 92 . En ella podemos apreciar como se nos ha dividido el editor en dos partes. o tecleando F5. Figura 68 Una vez hecho esto. mientras que la de abajo muestra los resultados de la ejecución de la misma. haciendo click en el botón en forma de flecha verde de la barra de herramientas. tecleando el servidor (si no se pone nada se accederá al servidor local) y el login y password. y lo que nos aparece ahora es una ventana como la que muestra la Figura 70. Para ello seleccionamos la opción Results in grid del menú Query. cuyo cometido es mostrar todos los valores de todos los atributos de la tabla titles. Probemos ahora a mostrar los resultados en forma de tabla. Lo que nos aparecerá será una ventana como la de la Figura 69. por ejemplo pubs. y dentro del editor tecleamos el Código fuente 3.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Ejecutando una consulta Pongamos ahora en práctica los conceptos aprendidos ejecutando una consulta sencilla (no debe preocuparse si todavía no entiende nada de código.

© Grupo EIDOS 10. El analizador de consultas Figura 69 Figura 70 En ella podemos observar como lo que antes nos aparecía en forma de texto. con una salvedad. ahora nos aparece en un grid. Esta pestaña no sólo sirve para visualizar el 93 . el mensaje que indicaba el número de registros devueltos aparece ahora en otra pestaña en la parte inferior. nombrada como Messages.

como por ejemplo los de error. Figura 72 94 .Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS número de registros seleccionados. guardaremos nuestra pequeña consulta en un archivo. y escogiendo un nombre para el mismo. para lo cual seleccionaremos la opción Save as del menú File. tal como se puede observar en la Figura 71. como muestra la Figura 72. sino muestra otro tipo de mensajes. Figura 71 Por último.

y estando en el modo de Results in grid. Para ello. y la forma de exportación y separación de campos. seleccionamos con el ratón el rango de resultados que deseemos exportar y hacemos clic con el botón derecho del ratón para seleccionar la opción Save as. en la que deberemos dar un nombre al archivo. El analizador de consultas Otra de las posibilidades que nos ofrece SQL-Server es la de exportar los datos que hayamos obtenido en una consulta.© Grupo EIDOS 10. Nos aparecerá una ventana como la de la Figura 73. Figura 73 95 .

.

índices. Estos tipos de datos serán utilizados a la hora de definir los atributos de una tabla. tablas. Tipos de datos Existe una amplia variedad de tipos de datos que podemos utilizar en Transact SQL. ya que en un próximo capítulo se describirán con detalle los operadores básicos que ofrece Transact SQL. no se preocupe. existen dos tipos de sentencias. Lenguaje de Definición de Datos (DDL): permite establecer y/o modificar el esquema relacional. La Tabla 25 muestra una descripción de éstos. añadir. Si el lector encuentra alguna terminología un tanto desconocida. así como algunas consideraciones acerca del lenguaje. En este capítulo se verá este último. que permiten mantener dicho esquema: • • Lenguaje de Manipulación de Datos (DML): permite manipular los datos del esquema relacional. o borrar información. es decir. dejando el primero para otro posterior. . etc.El lenguaje de definición de datos (DDL) Introducción Como ya se vio en la anterior parte acerca del diseño de esquemas relacionales. con diferente cometido. es decir. consultar. actualizar. borrar o actualizar atributos.

5507 4 bytes 98 .147.18E-38 hasta -3. Declarable hasta un máximo 1 byte por carácter de 255 caracteres declarado. Espacio consumido fijo.685.79E308 hasta +1.685. Números con Desde una precisión de 922. Espacio consumido variable 8 bytes varchar(n) money smallmoney Moneda. Declarable hasta un máximo 1 byte por carácter de 255 caracteres usado.483.337.767 2 bytes 1 byte de 2 a 17 bytes dependiendo de la precisión especificada Entero minúsculo (sin Desde 0 hasta 255 signo) decimal exacto sin redondeo Enteros y decimales desde 1. Precisión positiva: desde 2. 8 bytes real numérico de coma flotante con redondeo.447.147.447.79E308 Precisión negativa: desde 2.s) decimal(p.40E38 hasta +3.203.648 hasta +2.647 Tamaño 4 bytes 8 bytes Desde -32.s) Descripción Entero Entero largo Entero corto Rango de valores Desde -2.40E38 float(n) numérico de coma flotante con redondeo.79E308.337.203.79E308 hasta +1. hasta 922.18E-38 hasta 3.5508 cuatro decimales.23E-308 hasta 1.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Identificador en SQL Server Int bigint Smallint Tinyint numeric(p. Doble precisión. donde n está comprendido entre 8 y 15.40E38.79E308 en donde p es el número de dígitos de la parte entera (precisión) y s es el de la parte decimal (escala) Redondeos de números desde -1. Precisión positiva: desde 1. Simple precisión.768 hasta 32.79E308 Redondeos de números desde -3.40E38 Precisión negativa: desde 1. Números con una precisión de cuatro decimales.483.23E-308 hasta -1. donde n está comprendido entre 1 y 7. 4 bytes char(n) Alfanumérico de longitud fija Alfanumérico de longitud variable Moneda.

Tabla 25 Creación de tablas Una de las principales sentencias de definición de datos es la de creación de una tabla.© Grupo EIDOS 11. El dato horario se guarda como número de milisegundos desde la medianoche del día en cuestión Máximo de 255 bytes de longitud Máximo de 255 bytes de longitud Máximo de 2 Gigabytes de longitud Máximo de 2 Gigabytes de longitud n bytes. Su sintaxis es la siguiente: CREATE TABLE tabla (atributo tipo) La ejecución de esta sentencia. genera como resultado una nueva tabla. El lenguaje de definición de datos (DDL) datetime Fecha y hora para fechas históricas Desde 1-enero-1753 hasta 8 bytes 31-diciembre-9999. Campo para guardar imágenes de hasta 2 Gigas Sql_variant table bit Tipo bit 0ó1 Almacena datos de distintos tipos Almacena datos temporales Desde 1 bit mínimo reutilizado a partir del espacio de otra columna hasta 1 byte máximo si la columna fuera única. El nombre de la tabla debe ir después de la palabra TABLE. El nombre de los 99 . en la base de datos en la que estemos conectados. sean usados todos o no n bytes como máximo Máximo 2 GB Máximo 2 GB smalldatetime Fecha y hora para uso corriente binary(n) varbinary(n) text image Campo binario de longitud fija Campo binario de longitud variable Campo para texto largo de tipo Memo. El dato horario se guarda como número de milisegundos desde la medianoche del día en cuestión Desde 1-enero-1900 hasta 4 bytes 06-junio-2079.

ALTER TABLE tabla1 ADD atributo1 varchar(30) NULL Código fuente 7 Sólo pueden modificar las tablas el administrador. cargando su estructura. deberíamos ejecutar el Código fuente 7. si queremos añadir un atributo atributo1 de tipo varchar(30). ALTER TABLE tabla ADD atrib tipo NULL Código fuente 6 Nótese que el nuevo atributo añadido debe ser de tipo NULL. sp_dboption base_datos. lo que haría sería volcar el contenido de la tabla tabla2 en la tabla tabla1. borrarlos. Por ejemplo. Otra opción nos permite cargar un número de filas de otra tabla. para poder utilizar esta opción. deberemos ejecutar el Código fuente 5. La sentencia que permite modificar una tabla es la que muestra el Código fuente 6. especificando el tipo. a la tabla tabla1. es necesario modificar un parámetro de SQL Server. Sin embargo. es decir. SELECT * INTO tabla1 FROM tabla2 Código fuente 4 La anterior sentencia. o cambiar la definición. 100 . 'select into/bulkcopy'. true Código fuente 5 Modificación de tablas Entendemos por modificar una tabla. el propietario de la base de datos. ya que si no se permiten valores nulos. se produciría un error. Si existe más de un atributo. La sentencia encargada de esto la vemos en el Código fuente 4. añadir atributos.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS atributos deberá ir entre paréntesis. al crearse los campos de la tabla con este valor. se deberán separar por comas. y el propietario de la tabla. cambiar su estructura. Para ello.

Sin embargo. De este modo se evitan posibles colisiones que pueden surgir al crear índices cuando la tabla ya tiene datos. o el propietario de la misma. cod2) Código fuente 9 Esta sentencia permite añadir una clave primaria en tabla. debe ir a continuación de la palabra reservada TABLE. denominado Código. En este caso deberemos hacer un SELECT de otra tabla para liberarla. por el campo cod_cliente. CREATE INDEX codigo ON todos (cod_cliente) Código fuente 10 Sí además queremos que el índice no admita valores nulos. DROP TABLE tabla Código fuente 8 El nombre de la tabla que se borra. Creación y borrado de índices La creación de índices en SQL Server. se debe ejecutar el Código fuente 11. ésta no debe estar siendo usada.© Grupo EIDOS 11. se debe realizar junto con la creación de la estructura de las tablas. por los campos cod1 y cod2. Para poder borrar una tabla. aunque la base de datos esté cargada. Por ejemplo. CREATE UNIQUE INDEX codigo ON todos (cod) WITH IGNORE_DUP_KEY Código fuente 11 101 . esto es no puede admitir duplicados. la generación del índice daría un error. si creamos un índice único por un campo. Para crear un índice en la tabla todos. SQL Server permite la creación de índices. ALTER TABLE tabla ADD CONSTRAINT K1 PRIMARY KEY (cod1. se debe especificar el Código fuente 10. así como en la mayoría de los SGBDR existentes. El lenguaje de definición de datos (DDL) Borrado de tablas La sentencia que borra una tabla aparece en el Código fuente 8. y se encuentran valores no únicos. Además sólo podrá borrar una tabla el administrador.

Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS La sentencia que se encarga de borrar un índice. Esta sentencia se encarga de borrar el índice código creado anteriormente. DROP INDEX codigo Código fuente 12 102 . se muestra en el Código fuente 12.

CREATE TABLE tabla (atributo tipo) Código fuente 13 Por ejemplo. si se encuentra en venta o alquiler y el precio del mismo. la provincia y el domicilio donde se encuentra. Interesará almacenar por cada una de las ofertas la siguiente información: un código de identificación. La sentencia CREATE TABLE Esta sentencia es la que permite la creación de nuevas tablas dentro de una base de datos. se procederá a continuación a crear una tabla destinada a contener información acerca de las ofertas disponibles en una agencia inmobiliaria. Además. La sentencia SQL que nos permite crear esta tabla se muestra en el Código fuente 14: .Ejemplos prácticos de uso del DDL Introducción Se verán en este capítulo una serie de ejemplos para poner en práctica los conceptos aprendidos en el anterior. el tipo de bien inmueble al que pertenece. la definición de estos esquemas nos servirá como base para utilizar el lenguaje de manipulación de datos en próximos capítulos. plasmado en el analizador de consultas de SQL-Server 2000. para afianzar al lector en el uso del lenguaje de definición de datos. Recordamos su sintaxis en el Código fuente 13.

[CA_Nombre] [varchar] (50) NOT NULL ) ON [PRIMARY] GO CREATE TABLE [dbo].Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS CREATE TABLE [dbo]. ya que no esta normalizada. utilizando la sentencia drop table (aprenderemos como modificar un esquema en el siguiente epígrafe). Para ello primero borramos el esquema creado anteriormente. [OF_Precio] [int] NOT NULL ) ON [PRIMARY] Código fuente 14 Sin embargo. no podremos crear un tipo de bien inmueble nuevo hasta que no dispongamos de un bien con esas características. [OF_Tipo] [varchar] (50) NOT NULL . Por lo tanto procederemos a crear una tabla para los tipos de bienes y otra para las provincias (que a su vez se relacionará con una tabla de comunidades autónomas). la tabla que hemos creado más arriba puede dar problemas. [OF_Direccion] [varchar] (50) NOT NULL . por ejemplo. Figura 74 DROP TABLE Oferta GO CREATE TABLE [dbo].[Oferta] ( [OF_ID] [int] NOT NULL PRIMARY KEY . El diagrama de la Figura 74 mostraría el esquema resultante. [OF_Transaccion] [varchar] (50) NOT NULL . [OF_Provincia] [varchar] (50) NOT NULL .[Oferta] ( 104 . y el Código fuente 15 las sentencias a ejecutar para conseguirlo.[ComunidadAutonoma] ( [CA_ID] [int] NOT NULL PRIMARY KEY.

[TB_Nombre] [varchar] (50) NOT NULL ) ON [PRIMARY] GO Código fuente 15 Supongamos ahora que se desea tener constancia de los datos personales de los comerciales que trabajan en dicha agencia. [Com_Direccion] [varchar] (50) NOT NULL . dirección. [OF_Transaccion] [varchar] (50) NOT NULL . [OF_Direccion] [varchar] (50) NOT NULL . [Prv_ID] [int] NOT NULL . nombre y apellidos. [Cli_CCC] [varchar] (30) NOT NULL 105 .[TipoBien] ( [TB_ID] [int] NOT NULL PRIMARY KEY. como muestra el Código fuente 17. necesitando almacenar. teléfono y categoría. [TB_ID] [int] NOT NULL . [Com_Apellidos] [varchar] (50) NOT NULL . [Cli_Nombre] [varchar] (50) NOT NULL . se necesitará también conocer los datos personales de los clientes que están suscritos a nuestra agencia. provincia. conociendo por cada uno de ellos su NIF.[Provincia] ( [Prv_ID] [int] NOT NULL PRIMARY KEY. [Com_Nombre] [varchar] (50) NOT NULL . [Prv_Nombre] [varchar] (50) NOT NULL ) ON [PRIMARY] GO CREATE TABLE [dbo]. [CA_ID] [int] NOT NULL . siendo en NIF la clave primaria de la tabla. [Cli_CodPostal] [char] (5) NOT NULL . nombre y apellidos. dirección. [Cli_Telefono] [char] (9) NOT NULL . código postal. como muestra el Código fuente 16 . [Cli_Direccion] [varchar] (50) NOT NULL . [Prv_ID] [int] NOT NULL . CREATE TABLE [dbo]. teléfono y sus datos bancarios (nos bastará con el CCC de la cuenta bancaria). [Cli_Apellidos] [varchar] (50) NOT NULL . código postal. [Com_Categoria] [varchar] (10) NOT NULL ) ON [PRIMARY] GO Código fuente 16 Al igual que para los comerciales. Ejemplos prácticos de uso del DLL [OF_ID] [int] NOT NULL PRIMARY KEY. para cada uno de ellos.[Cliente] ( [Cli_NIF] [char] (10) NOT NULL PRIMARY KEY. [Prv_ID] [int] NOT NULL . [Com_Telefono] [char] (9) NOT NULL . la siguiente información: NIF (que de momento hará las veces de clave primaria de la tabla). [OF_Precio] [int] NOT NULL ) GO CREATE TABLE [dbo]. [Com_CodPostal] [char] (5) NOT NULL . CREATE TABLE [dbo].© Grupo EIDOS 12. provincia.[Comercial] ( [Com_NIF] [char] (10) NOT NULL PRIMARY KEY.

[TipoTransporte] ( [TT_ID] [int] NOT NULL PRIMARY [TT_Nombre] [varchar] (30) NOT ON [PRIMARY] GO CREATE TABLE [dbo].Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS ) ON [PRIMARY] GO Código fuente 17 Hasta el momento. Nos podemos plantear esta información como dos tablas: una de tipos de transporte (por ejemplo metro y cercanías RENFE) y otra de transportes en sí.[Transporte] ( [Tr_ID] [int] NOT NULL PRIMARY [Tr_Nombre] [varchar] (30) NOT [TT_ID] [int] NOT NULL ) ON [PRIMARY] GO KEY. Código fuente 18 106 . el diagrama de la Figura 75 muestra la situación actual en la que se encuentra nuestro esquema relacional: Figura 75 Sin embargo. NULL. y que son los transportes públicos más cercanos de los cuales dispone. podemos darnos cuenta de que falta una cosa bastante importante para ubicar el inmueble. como muestra el diagrama de la Figura 76 y el Código fuente 18. que almacenará las estaciones o paradas para cada tipo de los mencionados (por ejemplo Legazpi y Pacífico para metro y Fanjul y Móstoles para cercanías). CREATE TABLE [dbo]. NULL ) KEY.

e importa la clave de esta última tabla). así que daremos también de alta esta tabla. como nos indica el Código fuente 19 CREATE TABLE [dbo].© Grupo EIDOS 12. Ejemplos prácticos de uso del DLL Figura 76 En un momento dado nos puede interesar la posibilidad de tener almacenados en la base de datos todos los códigos postales. es una relación 1-N.[CodigosPostales] ( [Prv_ID] [int] NOT NULL. Su sintaxis es la descrita en el Código fuente 20: ALTER TABLE tabla ADD atrib tipo NULL Código fuente 20 107 . necesitando los siguientes atributos: el código postal (que actuará como clave primaria de la tabla) y la provincia (ya que una misma provincia dispondrá de distintos códigos postales. [CP_Codigo] [char] (5) NOT NULL PRIMARY KEY ) ON [PRIMARY] GO Código fuente 19 La sentencia ALTER TABLE Como ya se explicó. para posibles clasificaciones de inmuebles o futuras estadísticas. esta sentencia permite la modificación del esquema o la estructura de una tabla ya creada.

Figura 77 Sin embargo esto nos obliga a modificar el esquema. y que se podrían mejorar. Para conseguir esta característica adicional en nuestro esquema. lo que hace que se importe el atributo clave de la tabla de comerciales como muestra el diagrama de la Figura 77.[Oferta] ADD [Com_NIF] [char] (10) GO Código fuente 21 108 . Así. por ejemplo. etc. los comerciales aparecen desconectados de las ofertas de bienes. podremos conseguir información de valor añadido si conectamos la tabla de ofertas a la de comerciales. por lo que no mucho sentido. Esto puede ser muy útil a la hora de calcular comisiones o prever promociones. con objeto de añadir este nuevo atributo a la tabla de ofertas existente como muestra el Código fuente 21. podemos darnos cuenta de varios aspectos del esquema que no son del todo correctos. la relación entre tablas. puesto que el modelo relacional es eso. pero un inmueble sólo puede ser gestionado por un comercial). será necesario añadir un atributo más a la tabla de ofertas que la relacione con el comercial. ALTER TABLE [dbo]. a no ser que sólo nos interesen dichos datos a título informativo. Esto es así debido a la relación 1-N que existe entre ambas tablas (un comercial interviene en la transacción de muchos inmuebles. Pero ya que tenemos esa tabla y.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Volviendo sobre el ejemplo de la agencia desarrollado en el anterior epígrafe. para de este modo conocer qué comerciales han intervenido en la compra/alquiler de qué inmuebles.

etc. que a su vez puede estar próxima a otros inmuebles. para controlar los pagos. La conexión entre ambas tablas es similar al caso anterior. [Tr_ID] [int] NOT NULL ) ON [PRIMARY] GO Código fuente 24 Sin embargo esta tabla dispone de una clave primaria compuesta. se creaba una tabla intermedia que importaba las claves de ambas. enviarles facturas. El Código fuente 24 muestra la forma de hacerlo: CREATE TABLE [dbo]. de un modo similar. El caso de la tabla de transportes es algo especial. haremos lo mismo con la tabla de códigos postales. formada por ambos atributos.[Oferta] alter column [Com_NIF] [char] (10) not null GO Código fuente 22 Igual que para los comerciales. es un claro ejemplo de relación N-M. Si recordamos lo que ocurría con este tipo de relaciones. Ejemplos prácticos de uso del DLL Sin embargo nos encontramos con un problema.© Grupo EIDOS 12. nos interesaría saber qué clientes han comprado/alquilado qué inmuebles. así que se deberá ejecutar el Código fuente 25 para modificar el esquema de forma que se añada una restricción en forma de clave primaria a dicha tabla: ALTER TABLE [dbo]. así que se utilizará. y es que no podemos añadir un nuevo atributo con la propiedad not null. ALTER TABLE [dbo]. Y al igual que en el anterior caso también.[OfertaTransporte] WITH NOCHECK ADD CONSTRAINT [PK_OfertaTransporte] PRIMARY KEY NONCLUSTERED ( [Of_ID].[Oferta] alter column [Cli_NIF] [char] (10) not null GO Código fuente 23 Siguiendo el mismo razonamiento. la sentencia alter table (véase el Código fuente 23). ya que para un mismo inmueble pueden existir más de una estación de metro cercana.[OfertaTransporte] ( [Of_ID] [int] NOT NULL . así que deberemos ejecutar una segunda sentencia. [Tr_ID] ) ON [PRIMARY] GO Código fuente 25 109 . se necesita modificar el esquema de la base de datos.[Oferta] ADD [Cli_NIF] [char] (10) GO ALTER TABLE [dbo]. que modifique el atributo añadido para que no pueda tomar valores nulos (ya que es una clave ajena): ALTER TABLE [dbo].

[Oferta] ADD CONSTRAINT [FK_Oferta_Cliente] FOREIGN KEY ( [Cli_NIF] ) REFERENCES [dbo].[Oferta] ( [OF_ID] ).Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Sin embargo no debemos olvidarnos de un aspecto muy importante.[TipoBien] ( [TB_ID] ) GO ALTER TABLE [dbo]. CONSTRAINT [FK_Oferta_Comercial] FOREIGN KEY ( [Com_NIF] ) REFERENCES [dbo]. Ejecutando el Código fuente 26 podremos estar seguro de esto: ALTER TABLE [dbo].[ComunidadAutonoma] ( [CA_ID] ) GO ALTER TABLE [dbo]. CONSTRAINT [FK_Oferta_Provincia] FOREIGN KEY ( [Prv_ID] ) REFERENCES [dbo]. CONSTRAINT [FK_OfertaTransporte_Transporte] FOREIGN KEY ( [Tr_ID] ) REFERENCES [dbo].[Transporte] ADD CONSTRAINT [FK_Transporte_TipoTransporte] FOREIGN KEY ( [TT_ID] 110 . que es el de las claves ajenas y las restricciones.[Provincia] ( [Prv_ID] ).[Provincia] ADD CONSTRAINT [FK_Provincia_ComunidadAutonoma] FOREIGN KEY ( [CA_ID] ) REFERENCES [dbo].[OfertaTransporte] ADD CONSTRAINT [FK_OfertaTransporte_Oferta] FOREIGN KEY ( [Of_ID] ) REFERENCES [dbo].[Transporte] ( [Tr_ID] ) GO ALTER TABLE [dbo]. o insertar tipos que no estén dados de alta en las tablas maestras que los tipifican.[Comercial] ( [Com_NIF] ).[Cliente] ( [Cli_NIF] ). CONSTRAINT [FK_Oferta_TipoBien] FOREIGN KEY ( [TB_ID] ) REFERENCES [dbo]. para no tener problemas de borrar una tupla de una tabla que sea clave ajena en otra relación. Deberemos relacionar todas las tablas de manera que se establezca una relación entre las claves ajenas que unen las relaciones.

Con todo esto. y su sintaxis es la que se muestra en el Código fuente 27: DROP TABLE tabla Código fuente 27 111 . Ejemplos prácticos de uso del DLL ) REFERENCES [dbo]. obtenemos el esquema relacional que se muestra en el diagrama de la Figura 78: Figura 78 La sentencia DROP TABLE Permite el borrado de una tabla existente en la base de datos. la forma de introducir claves ajenas en la base de datos es mediante restricciones. seguido de las palabras foreign key y a continuación las referencias a los atributos que son clave en sus relaciones. poniendo el nombre de la tabla donde se encuentra el atributo que es clave ajena.© Grupo EIDOS 12.[TipoTransporte] ( [TT_ID] ) GO Código fuente 26 Como podemos ver.

como muestra el Código fuente 28: Drop table CodigosPostales Código fuente 28 La sentencia CREATE INDEX La sintaxis que permite la creación de índices sobre tablas es la especificada en el Código fuente 29: CREATE [UNIQUE] INDEX indice ON tabla (atributos) Código fuente 29 Recordemos cual es el cometido de un índice.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Retomando el ejemplo que nos lleva en este capítulo. 112 . no nos aporta nada. de momento. así que procederemos a su borrado. Es más. es una decisión del diseñador el establecer los índices oportunos para que el rendimiento de la misma no se vea afectado. Sin embargo y. que no es otro que el de acelerar las consultas que se realizan sobre una base de datos. Veamos que índices podemos crear en el ejemplo que nos lleva este capítulo. como será el caso. la mayoría de las consultas se realizaran por precio o por tipo de transacción. ya que la información que se precisa para un inmueble. puede llegar a ralentizar las actualizaciones de datos. podemos observar que la tabla de código postales. no recoge este dato como algo necesario. Pues bien. Sin embargo. Por ejemplo. podemos adivinar que la tabla crítica para realizar consultas será la de ofertas. por contra. puede dificultarnos la gestión de la base de datos. La siguiente decisión es considerar si crear un único índice con estos dos atributos. Si suponemos que la mayoría de las consultas se realizarán por ambos criterios. conviene crearlos por separado de la siguiente forma: CREATE INDEX oferta1 ON Oferta (Of_Transaccion) GO CREATE INDEX oferta2 ON Oferta (Of_Precio) GO Código fuente 30 La sentencia DROP INDEX Permite el borrado de un índice creado para una tabla. y su sintaxis es la que se muestra en el Código fuente 31. ya que un índice es una estructura que si bien acelera las consultas. o crear dos por separado. convendría crear un único índice con ambos atributos. depende de las consultas que se vayan a realizar. podemos intuir que la mayoría de las consultas de dicha tabla involucrarán a los atributos precio y tipo de transacción (alquiler o venta).

oferta2 Código fuente 32 La salvedad es que debemos indicar el código del índice de la forma tabla. deberíamos ejecutar: drop index Oferta.© Grupo EIDOS 12. Ejemplos prácticos de uso del DLL DROP INDEX codigo Código fuente 31 Si en nuestro caso deseáramos borrar el índice oferta2 creado anteriormente. para evitar ambigüedades. 113 .indice.

.

que es el que permite definir y modificar la estructura de un esquema. como su propio nombre indica. que nos permite. Su sintaxis es la siguiente: SELECT <atributos> FROM <tablas> [WHERE <condicion>] [GROUP BY <atributos>] [HAVING <condición>] [ORDER BY <atributos>] Donde las mayúsculas representan palabras reservadas. puede ser omitido. manejar los datos contenidos en el esquema. que pertenece al conjunto del Lenguaje de Manipulación de Datos. el de manipulación de datos.El lenguaje de manipulación de datos (DML) Introducción Ya se ha visto en un capítulo anterior el lenguaje de definición de datos (DDL). Veremos a continuación el otro lenguaje. y lo encerrado entre corchetes es opcional. de una o varias bases de datos. Una vez vista la anterior forma de representación. Se compone de tres partes: . vamos a detenernos en la sintaxis de la sentencia Select. y que sirve para recuperar registros de una o varias tablas. La sentencia Select La sentencia Select es una sentencia SQL.

WHERE <condición>: permite establecer una condición de recuperación de las filas de la/s tabla/s. deseamos obtener todos los atributos de dicha tabla. Si por ejemplo. nos devuelve toda la información almacenada en ella. de las cuales sólo visualizaremos los valores de los atributos title y price (especificados en la cláusula SELECT). deberíamos escribir el Código fuente 33. éstas irán separadas por comas. para que. es decir. ya que no hemos dado ninguna condición. Si se especifica el símbolo *. seleccionar los campos que deseamos recuperar de la base de datos. price FROM titles Código fuente 33 De esta manera. se obtendrán todos los campos de la tabla. • • • • • En el caso de que se especifiquen varias tablas. se recuperarán todas las filas. Si por el contrario. separados por comas. SELECT title. obtenemos todas las filas.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS • SELECT <atributos>: permite hacer una proyección de las tablas. la anterior sentencia nos devuelve todos los atributos de todas las filas de la tabla titles. es decir. se sepa en cada momento a cual de ellos nos estamos refiriendo. GROUP BY <atributos>: permite establecer una selección de campos cuando se utilizan funciones escalares o de conteo (ya se verá más adelante lo que significa. Si se especifica más de una tabla. deberíamos escribir el Código fuente 34. FROM <tablas>: permite especificar la tabla de la cual se desean obtener los datos. en la cláusula FROM. En el caso de que se omita esta parte. HAVING <condición>: establece una condición para los atributos obtenidos como resultado de la aplicación de funciones escalares. será conveniente denotar los campos de la cláusula SELECT precedidos por el nombre de la tabla donde se encuentra y un punto. ORDER BY <atributos>: permite obtener el resultado de la consulta ordenado por los atributos especificados. SELECT * FROM titles Código fuente 34 Puesto que hemos especificado el literal * dentro de la cláusula SELECT. en el caso de que dicho campo exista en más de una tabla. deseamos obtener todos los valores de los atributos title y price de la tabla titles. que será opcional. 116 . de la tabla titles (especificada en la cláusula FROM). Sólo se obtendrán aquellas tuplas que verifiquen dicha condición. evitando en este caso el problema de ambigüedad.

si queremos obtener los títulos cuyos derechos de autor sean mayores del 10 %. Estos operadores serán vistos en detalle en el siguiente capítulo. pero básicamente son los siguientes: • • • • • • • • • : compara si una expresión es mayor que otra < : compara si una expresión es menor que otra >= : compara si una expresión es mayor o igual que otra <= : compara si una expresión es menor o igual que otra <>: compara si una expresión es distinta que otra LIKE : compara todas las cadenas que verifican un patrón de búsqueda NOT LIKE : compara todas las cadenas que no verifican un patrón de búsqueda BETWEEN : compara todas las cadenas que están comprendidas en un rango de valores IN : compara todas las cadenas que están contenidas en una lista Por ejemplo. es mediante la opción WHERE. Para expresar una expresión lógica se pueden emplear cualquiera de los operadores de Transact SQL cuyo resultado devuelva un valor lógico. SELECT * FROM titleauthor WHERE royaltyper > 10 Código fuente 35 SELECT * FROM titles WHERE price <= 2 Código fuente 36 Si queremos obtener el nombre de los autores cuya primera letra este comprendida entre la C y la H.© Grupo EIDOS 13. De la misma forma. El lenguaje de manipulación de datos (DML) La cláusula Where La forma de usar el Transact SQL para realizar consultas realizando una proyección horizontal (es decir. se debe especificar la condición lógica que se debe evaluar. ejecutaremos el Código fuente 36. ejecutamos el Código fuente 37. si queremos obtener todos los títulos cuyo precio no supere los 2$. seleccionando las filas). y que a continuación tenga el literal 'urry'. aunque también se pueden utilizar operadores de cadena. para obtener aquellas filas que la cumplen. A continuación de esta palabra reservada. teclearemos el Código fuente 35. SELECT au_fname FROM authors WHERE au_fname LIKE '[C-H]urry' Código fuente 37 117 .

filas que tienen el mismo valor para un atributo. y a continuación mostrar los grupos. si queremos obtener el apellido de todos los autores. SELECT au_lname FROM authors GROUP BY au_lname Código fuente 41 En ella. SELECT city FROM authors WHERE city in ('San Francisco'. ejecutamos el Código fuente 40. detrás de esta cláusula se debe determinar el atributo au_lname. ejecutaremos el Código fuente 38. en grupos distintos. Esto que parece tan complicado. SELECT au_lname FROM autors Código fuente 40 Si nos fijamos en el resultado obtenido. en lugar de todas. que se corresponda con San Francisco o con Salt Lake City. 118 . sino de los grupos obtenidos a partir de la cláusula GROUP BY. Con esto garantizamos que sólo se mostrará una fila por cada apellido distinto. Por ejemplo. que lo único que nos interesa es obtener todos los apellidos que sean distintos. Supongamos ahora. tenemos que existen dos autores. usando la cláusula GROUP BY. ya que sólo mostramos una fila del grupo. en lugar de las filas. pero no de las filas de la tabla. ejecutaremos el Código fuente 39. se muestran dos filas iguales para este apellido. como su propio nombre indica. una por cada autor que se apellida Ringer.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS O si queremos obtener la ciudad de todos los autores. Por lo tanto. garantizando así que todas las filas cuyo valor de este atributo sea igual. SELECT title FROM titles WHERE price BETWEEN 1 AND 2 Código fuente 39 La cláusula Group by La cláusula GROUP BY agrupa. Ringer.'Salt Lake City') Código fuente 38 Si se desea conocer todos los títulos cuyo precio oscila entre 1 y 2 dólares. Para ello deberemos agrupar los autores cuyo apellido sea el mismo en un único grupo. cuyo apellido es el mismo. lo que se hace es simplemente un select. irán al mismo grupo. Puesto que deseamos agrupar por el apellido. se resume en una sentencia.

se debe especificar el atributo o los atributos por los cuales se ordenará el resultado obtenido en la consulta. Por lo tanto el funcionamiento es similar al ya visto para WHERE. si dada la anterior sentencia de agrupación. A continuación de dicha palabra reservada. en este caso alfabéticamente por el apellido. La única diferencia es que HAVING se aplica a condiciones de grupo. determina cómo se ordenarán las filas que se mostrarán. bastará con ejecutar la sentencia que aparece en el Código fuente 43 donde el atributo especificado a continuación de la cláusula ORDER BY. SELECT au_lname FROM authors GROUP BY au_lname HAVING au_lname = 'Ringer' Código fuente 42 La cláusula Order by La cláusula ORDER BY determina el orden de visualización de las filas obtenidas en la sentencia SELECT. Si queremos obtener la suma del precio de todos los pedidos almacenados. El lenguaje de manipulación de datos (DML) La cláusula Having La cláusula HAVING es similar a la cláusula WHERE. supongamos que tenemos una tabla de pedidos. es decir. si queremos mostrar el nombre y apellido de todos los autores de nuestra base de datos pubs.© Grupo EIDOS 13. cod_material y precio. ejecutaremos el Código fuente 42. Por ejemplo. como la que vemos en el Código fuente 44. todas aquellas que permiten realizar operaciones de conteo de filas. Por ejemplo. Dichas funciones se especifican a continuación de la palabra reservada SELECT. obtención de medias. Las funciones que soporta la sentencia SELECT en el Transact SQL son las siguientes: • SUM: Realiza una suma acumulativa de un atributo para todas las filas accedidas mediante una consulta SQL. con los atributos cod_cliente. au_lname. au_fname FROM authors ORDER BY au_lname Código fuente 43 Funciones escalares para Select Entendemos por funciones escalares. salvo que aquella se usa como condición de búsqueda cuando se especifica la cláusula GROUP BY. Por ejemplo. bastará con realizar una función de tipo SUM. SELECT sum(precio) FROM pedido Código fuente 44 119 . SELECT au_lname. deseamos que sólo se muestre el autor cuyo apellido sea Ringer. suma de atributos. etc.

con los atributos DNI. Si ahora queremos obtener la suma total de todos los pedidos realizados por el cliente cuyo código es "R12CE". si tenemos una tabla cliente. podríamos haber escogido cualquier otro. sea cual sea el atributo que seleccionemos. deberemos realizar un count. SELECT count(*) FROM cliente Código fuente 47 Si ahora queremos saber el número de clientes que viven en Madrid. y queremos saber todos los clientes que tenemos. dirección y población. deberemos realizar un conteo de todas las filas con la condición de que el atributo población sea Madrid. para obtener todas el número de filas de la tabla ejecutamos el Código fuente 46. apellidos. con todos los clientes de una empresa de servicios. pero especificando una condición para obtener únicamente las filas cuyo cod_cliente es "R12CE": SELECT sum(precio) FROM pedido WHERE cod_cliente = "R12CE" Código fuente 45 • COUNT: Cuenta todas las filas de las tablas accedidas mediante una consulta SQL. SELECT count(*) FROM titles Código fuente 49 120 . teclearemos el Código fuente 49. nombre.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS La anterior consulta obtiene la suma del precio para todas las filas de la tabla pedido. SELECT count(DNI) FROM cliente Código fuente 46 En el anterior ejemplo. al existir el mismo número de filas. ya que no hemos especificado ninguna condición en la cláusula WHERE. Por ejemplo. debemos realizar la misma consulta. En general. SELECT count(*) FROM cliente WHERE poblacion = "Madrid" Código fuente 48 Si queremos saber cuantos títulos tenemos nuestra base de datos. se suele escribir el Código fuente 47.

que obtenga el mayor valor para el atributo precio de todas las filas. internamente.© Grupo EIDOS 13. Para nuestro ejemplo. deberemos ejecutar el Código fuente 52. que tenemos la tabla de materiales descrita anteriormente. precio y cantidad_pedida. SELECT max(price) caro FROM titles Código fuente 53 121 . teniendo en cuenta todas las filas de la tabla: SELECT avg(cantidad_pedida) FROM material Código fuente 51 La anterior sentencia. y a continuación la divide por el número total de filas accedidas. El lenguaje de manipulación de datos (DML) Y si queremos saber cuantos títulos tenemos. por ejemplo. es decir. ejecutaremos el Código fuente 53. realiza la media aritmética. de entre todas las filas seleccionadas mediante la sentencia SQL. deberemos realizar un SELECT con la cláusula max. deberemos realizar lo mismo. SELECT count(*) caros FROM titles WHERE price > 20 Código fuente 50 • AVG: Realiza una media aritmética de los atributos para todas las filas accedidas mediante la consulta SQL. realiza primero una suma de todos los valores. descripción. cuyo precio es mayor de 20 $. Si por ejemplo tenemos una tabla de materiales. Supóngase. con los atributos cod_material. SELECT avg(price) media FROM titles Código fuente 52 • MAX: Obtiene el máximo valor del atributo especificado. Si queremos saber el material mas caro. y queremos saber la cantidad media pedida de todos los materiales. pero especificando esta condición en la cláusula WHERE. si queremos saber cual es el libro más caro. Al resultado de la búsqueda le llamaremos caros. si queremos saber la media del precio de los títulos que tenemos disponibles. Volviendo a nuestra cultural base de datos pubs. deberemos realizar una media aritmética.

que ha sido definido como no nulo. INSERT INTO authors (au_id. contract) VALUES ('409-99-9876'. au_fname) VALUES ('409-99-9876'. Line 1 Cannot insert the value NULL into column 'contract'. y valores especifica los valores que se darán para estos atributos. State 2. el resto de los de la tabla deberá contener el valor nulo (NULL). cuando el atributo esté definido como NO NULO. Si SELECT nos permitía recuperar datos. Sin embargo. obtenemos el siguiente error: Server: Msg 515. para dar un valor al Código fuente 56.authors'. INSERT fails. rectificamos el Código fuente 55. au_lname. La razón es que no hemos dado valor al atributo contract. Por ejemplo. por lo que la información se añadirá a una tabla en forma de filas. The statement has been terminated. Pues bien. INSERT nos va a permitir añadirlos al esquema. La sintaxis de este sentencia es: INSERT INTO tabla (atributos) VALUES (valores) donde tabla especifica la tabla en la cual se añadirá la fila. mientras que si es numérico no. SELECT min(price) barato FROM titles Código fuente 54 La sentencia Insert La otra gran sentencia de manipulación de datos es INSERT. Si queremos saber cual es el libro más barato de nuestra base de datos. en cuyo caso deberemos especificar un valor para éste. Recordemos que estamos en el modelo relacional. Level 16. habrá ciertas ocasiones en que esto no será posible. column does not allow nulls. si queremos añadir un nuevo autor a nuestra base de datos. au_lname. atributos es una lista de atributos separados por comas que determinan los atributos para los cuales se darán valores. Por lo tanto. separados por comas. 1) Código fuente 56 122 . table 'pubs. de entre todas las filas seleccionadas mediante la sentencia SQL.dbo. deberemos ejecutar el Código fuente 55. si ejecutamos la anterior sentencia. 'Pepe'. con esta sentencia podemos añadir información a la base de datos. es decir.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS • MIN: Obtiene el mínimo valor del atributo especificado. INSERT INTO authors (au_id. 'Perez'. 'Pepe'. au_fname. deberemos ejecutar el Código fuente 54. 'Perez') Código fuente 55 Destacar que si el valor a introducir es alfanumérico. deberá ir encerrado entre comillas. Si sólo queremos insertar un valor para un atributo.

Podemos comprobarlo ejecutando un SELECT sobre dicha fila. Para poder borrar filas en una tabla se deben cumplir las condiciones de seguridad determinadas por el administrador (se verán en un 123 . atributo2 = valor2. SELECT * FROM authors WHERE au_id = '409-99-9876' Código fuente 57 La sentencia Update El objetivo de la sentencia UPDATE es actualizar los valores de una o varias filas de una tabla. Por lo tanto se actualizarán todas las filas que cumplan la condición especificada. sin necesidad de borrarla e insertarla de nuevo. . WHERE condicion donde tabla especifica la tabla donde se encuentran las filas que queremos actualizar. por el código (condición where). es decir. sólo admite dos valores.© Grupo EIDOS 13. y a continuación actualizar el valor del atributo nombre de la fila obtenida a Pepito. La sintaxis es la siguiente: UPDATE tabla SET atributo1 = valor1 . obtenemos como resultado (1 row(s) affected) lo que nos indica que la fila se ha insertado con éxito.. y lo que viene a continuación de SET especifica la asignación de los nuevos valores a los atributos. SELECT * FROM authors WHERE au_id = '409-99-9876' Código fuente 59 La sentencia Delete El objeto de la sentencia DELETE es el de borrar filas de una tabla. El lenguaje de manipulación de datos (DML) El valor que hemos dado al atributo contract es un 1. Podemos comprobarlo ejecutando el Código fuente 59. y 1 para el caso contrario. deberemos escribir el Código fuente 58. 0 para especificar que no está contratado. Si ejecutamos la anterior sentencia.. obtenemos el resultado: (1 row(s) affected) lo que quiere decir que la fila ha sido actualizada con éxito. ya que está definido como tipo binario. UPDATE authors SET au_fname = 'Pepito' WHERE au_id = '409-99-9876' Código fuente 58 Lo que hacemos con la anterior sentencia es buscar el autor insertado. condición especifica la condición que se debe cumplir para actualizar las filas. Si queremos cambiar el nombre al autor que hemos insertado en el anterior apartado. Al ejecutar esta sentencia.

La sintaxis es la siguiente: DELETE FROM tabla WHERE condicion donde tabla especifica la tabla sobre la cual queremos borrar las filas. es decir. y deben de cumplirse también las reglas de integridad referencial. DELETE authors Código fuente 60 Por ejemplo. SELECT * FROM authors WHERE au_id = '409-99-9876' Código fuente 62 124 . ejecutamos la sentencia que muestra el Código fuente 62. y condición especifica la condición que se debe cumplir para que se borren las filas. la sentencia que aparece en el Código fuente 60 borra todas las filas de la tabla authors. ha sido borrada. es decir. Para comprobarlo. obteniendo el siguiente resultado: (1 row(s) affected) DELETE FROM authors WHERE au_id = '409-99-9876' Código fuente 61 lo que viene a decir que la fila se ha borrado. lo que quiere decir que la fila no se encuentra en la tabla.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS próximo capítulo). Si omitimos la condición. si queremos borrar la fila que hemos creado en la tabla autores. deberemos ejecutar el Código fuente 61. se borrarán todas las filas de la tabla. cuyo resultado es: (0 row(s) affected).

Operadores básicos y consideraciones del lenguaje Introducción En este capítulo se describirán con detalle los operadores básicos. etc. Dicho operador consiste en restringir la cantidad de información que obtenemos de una o varias tablas. Las principales que veremos aquí son: • • • Proyección Unión Join o combinación No confundir los anteriores operadores propios del álgebra relacional. comparaciones lógicas. los que permiten la evaluación de expresiones. . Entendemos por operadores. es decir. sobre todo para acotar la consulta de tablas. así como algunas apreciaciones acerca del lenguaje que ofrece Transact SQL. aquellas palabras reservadas o símbolos delimitadores que nos permiten aplicar las diversas técnicas del álgebra relacional. unión de cadenas. con los que ofrece SQL Server. Operador proyección El operador de proyección es muy usado.

se deberán proporcionar éstos a continuación de la palabra reservada SELECT. campo2 FROM tabla1 Código fuente 63 El método no varia si queremos realizar la proyección sobre más de una tabla. Probemos ahora con el query analyzer. en realizar una criba sobre aquellos atributos que nos interesen para todas las filas de una tabla.campo1. Para distinguir el campo1 de tabla1. tabla2 Código fuente 64 En el anterior ejemplo se ha proyectado sobre dos campos de dos tablas distintas. el Código fuente 63 realiza una proyección de los atributos campo1 y campo2 de la tabla tabla1: SELECT campo1. en nuestro ejemplo. aunque también se puede acotar el resultado de ésta. type tipo FROM titles Código fuente 65 Nótese como después de cada atributo hemos tecleado otro nombre. Veamos ahora como realizar una proyección utilizando Transact SQL. del campo1 de tabla2. y tecleamos el Código fuente 65. Así. especificando una condición. que son los alias que les hemos dado respectivamente. para que el resultado se aplique únicamente a las tuplas que la cumplan. dichos atributos aparecen bajo los nombre título y tipo.campo1 FROM tabla1. se precede el nombre de la tabla al del campo. 126 . Para especificar las tablas sobre las cuales se desea realizar la proyección. SELECT title título. pero como podemos observar en el resultado mostrado en la Figura 79. nos conectamos a la base de datos pubs. tabla2. se deberán especificar después de la palabra reservada FROM. seleccionándola en la lista desplegable de la parte superior derecha. se recuperarán todas las filas de la tabla titles. SELECT tabla1. y separados por comas. es decir. seguido por un punto. Así. Para especificar los atributos de la tabla o tablas que deseamos que aparezcan en la consulta. Una vez abierto. A este nombre se le denomina alias y sirve para que el atributo obtenido aparezca con otro nombre.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Aquí veremos la proyección vertical. y realizaremos una proyección sobre los atributos title y type.

Probemos ahora en el query analizer. tecleando el Código fuente 68. Operadores básicos y consideraciones del lenguaje Figura 79 Operador Union El operador unión consiste. Por ejemplo. en unir campos de más de una tabla. 127 . y quedarnos luego sólo con la información relevante.© Grupo EIDOS 14. que no es ni más ni menos. Este operador casi nunca se utiliza por separado. escribiremos el Código fuente 67. si queremos obtener la unión de las dos consultas a dos tablas. que todas las filas de las tablas titles y titleauthor. Pulsamos ahora el botón de ejecución. para obtener el resultado consultando en varias tablas. es utilizar la palabra reservada UNION. tabla2 Código fuente 66 Otra forma de realizar una unión entre el resultado de dos consultas. El resultado obtenido contendrá entonces campos de las tablas especificadas en la cláusula FROM. o F5. sino junto con el de proyección. y obtenemos el resultado mostrado en la Figura 80. El Código fuente 66 constituye un ejemplo de unión de las tablas tabla1 y tabla2: SELECT * FROM tabla1. como su propio nombre indica.

campo1 Código fuente 69 128 . con todas las filas de la tabla con la que se hace el join.campo1 = tabla2. La forma de realizarlo en Transact SQL es especificando en la cláusula WHERE los atributos por los cuales se va a realizar el join entre ambas tablas. Lo que se realiza es una unión de cada fila de una tabla. titleauthor Código fuente 68 Operador join El operador de join es uno de los más usados en el álgebra relacional. SELECT * FROM tabla1. tabla2 WHERE tabla1.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Figura 80 SELECT * FROM tabla1 UNION SELECT * FROM tabla2 Código fuente 67 SELECT * FROM titles. Sirve para combinar dos tablas entre sí. cuyos atributos comunes coincidan. utilizando un atributo común.

y para cada fila cuyo campo común sea igual en ambas tablas. Dentro de este tipo de join. El otro tipo de join. aunque éstas no tengan correspondencia en su homóloga. Esto es debido a que el valor del atributo por el que se hace el join (campo1). la tercera fila de la tabla 1.campo1 1 1 2 Tabla 28 tabla2.campo1 1 1 2 tabla2.© Grupo EIDOS 14. no existe en el atributo campo1 de la tabla 2.campo2 5 3 8 Como hemos podido comprobar. Veamos un ejemplo de como funciona un join. A este tipo de join se le denomina inner join. hay dos filas en la Tabla 27 cuyo atributo campo1 es igual. copiar las filas de la segunda tabla. Por ejemplo. copiando cada fila de la primera tabla. pero incluyendo todas las filas de ambas tablas. Operadores básicos y consideraciones del lenguaje El Código fuente 69 realiza un join entre las tablas tabla1 y tabla2. y deseamos hacer un join por el atributo campo1 de ambas. denominado outer join. consiste en realizar el join. existen dos categorías: 129 . para la primera fila de la Tabla 26. por el campo1 de ambas tablas.campo2 10 10 9 tabla1. El join de estas dos tablas queda como muestra la Tabla 28 tabla1. Supóngase que tenemos las dos siguientes tablas. cuyo valor es 3. Campo1 1 2 3 4 Tabla 26 Campo2 10 9 4 1 Campo1 1 1 2 Campo2 5 3 8 Tabla 27 Lo primero que se realiza al hacer un join es una unión de ambas tablas. no aparece en el join.

campo1 1 1 2 ? Tabla 30 tabla2. SELECT * FROM tabla1 rigth join tabla2 on tabla1.campo1 1 1 2 3 Tabla 29 tabla2. por los campos comunes campo1 y campo2.campo2 5 3 8 1 En Trasact SQL.campo = tabla2.campo2 Código fuente 71 También se puede realizar un join por más de un campo. Los campos de la segunda tabla se rellenan con interrogantes.campo2 Código fuente 70 • Rigth join: incluyen todas las filas de la segunda tabla. tabla1.campo2 10 10 9 ? tabla1.campo1 1 1 2 ? tabla2. El Código fuente 72 realiza un join entre las tablas Tabla 26 y Tabla 27.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS • Left join: incluyen todas las filas de la primera tabla.campo = tabla2. la sentencia para realizar este left join se muestra en el Código fuente 70. aunque éstas no tengan correspondencia en la primera.campo2 10 10 9 4 tabla1. aunque éstas no tengan correspondencia en la segunda. Los campos de la primera tabla se rellenan con interrogantes. SELECT * FROM tabla1 left join tabla2 on tabla1.campo2 5 3 8 ? En Trasact SQL.campo1 1 1 2 4 tabla2. 130 . Tabla1. la sentencia para realizar este rigth join aparece en el Código fuente 71.

se genera una tabla intermedia con la clave de cada tabla). Como se puede observar.au_id = authors. realizamos un join de esta tabla. authors. authors. SELECT titles. ejecutaremos la misma sentencia que antes. podemos acceder a los autores. Deberemos acceder a la tabla de títulos. Veamos un ejemplo de implementación de join en Transact SQL.© Grupo EIDOS 14.title_id = titleauthor.title_id AND titleauthor. titleauthor. además de las condiciones de join.title.campo1 AND tabla1. El resultado es el mostrado en la Figura 81.campo2 Código fuente 72 En el lenguaje de manipulación de datos. SELECT titles.au_id = authors.au_lname. junto con el nombre de su autor. Si se desea obtener el título de cada obra.title_id AND titleauthor.price < 20 Código fuente 74 131 . deberemos ejecutar el Código fuente 73.au_lname FROM titles. que es donde se encuentra el título de cada obra. que es la que almacena el código de cada título. la cláusula WHERE realiza los dos join necesarios para acceder a las tres tablas. realizando un join de la tabla titleauthor con la tabla authors. una de las operaciones más usuales es precisamente la de join de varias tablas. authors WHERE titles. A partir de esta tabla. aunque de éstas no se muestre ningún atributo.price FROM titles. tabla2 WHERE tabla1.title. En la cláusula WHERE. precisamente por el campo au_id. titles. authors WHERE titles. junto con los autores que lo han escrito (recuérdese que en las relaciones N-M. Por lo tanto.campo2 = tabla2. que es el código del autor.au_id Código fuente 73 Analicemos la anterior sentencia. A continuación. podremos especificar otro tipo de condiciones.campo1 = tabla2. titleauthor. junto con sus autores.au_id AND titles. en la cláusula FROM se deben especificar todas las tablas que serán accedidas. Operadores básicos y consideraciones del lenguaje SELECT * FROM tabla1. con la tabla intermedia titleauthor. si queremos obtener una relación de todos los títulos cuyo precio no supere los 20 $.title_id = titleauthor. Por ejemplo. que es que el atributo price de la tabla titles no supere los 20$. pero añadiendo ahora una nueva condición.

Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Figura 81 Figura 82 Operadores propios de Transact SQL Los operadores que nos proporciona SQL Server se dividen en varios grupos: 132 .

Operadores básicos y consideraciones del lenguaje • • • • Aritméticos: realizan operaciones aritméticas.:concatenación. etc. Ej. etc. división. multiplicación. etc. La Tabla 31 muestra un resumen de los principales operadores con que nos podemos encontrar en Transact SQL. Lógicos: realizan operaciones que devuelven un resultado lógico. etc. DESCRIPCIÓN + Operadores Aritméticos * / % Suma Resta Multiplicación División Módulo o resto de la división entera AND binario (1 si los bits de ambos operandos son 1) EJEMPLO SELECT 2 + 4 SELECT 3 . Ej.: comparaciones.: suma. De nivel de bit: realizan operaciones transformando los operandos a bits. Ej.1 SELECT 3 * 2 SELECT 6 / 2 SELECT 4 % 3 RESULTADO 6 2 6 3 1 11 & 10 = 10 >2 11 | 10 = 11 -> 3 11 ^ 10 = 01 -> 1 ~10 = 01 -> 1 & SELECT 3 & 2 | Operadores nivel de bit ^ OR binario (1 si el bit de alguno de los dos SELECT 3 | 2 operandos es 1) OR exclusivo binario (1 si el bit de los SELECT 3 ^ 2 operandos es distinto) NOT binario (cambia el bit) SELECT ~ 2 ~ Operadores lógicos = < > >= <= Igual Menor Mayor Mayor o igual Menor o igual SELECT 1 = 2 SELECT 1 < 2 SELECT 1 > 3 SELECT 1 >= 1 SELECT 10 <= 1 FALSO VERDADERO FALSO VERDADERO FALSO 133 . búsqueda.© Grupo EIDOS 14. De cadena: realizan operaciones que afectan a strings o cadenas de caracteres. Ej.: AND al nivel de bit.

si queremos obtener todos los títulos cuyo precio oscile entre los 30 y los 50 dólares.M _ SELECT * FROM tabla WHERE atributo2 like '_urry' Hurry Otros operadores importantes aplicables a expresiones son los siguientes: • BETWEEN: Verifica los valores comprendidos dentro del rango especificado. si queremos obtener el nombre de todos los autores que vivan en San Francisco o en Salt Lake City. La sintaxis es: expresion IN lista Por ejemplo. NOT: negación de la expresión LIKE: búsqueda por patrón Cadenas no coincidentes. escribimos el Código fuente 75. NOT: negación de la expresión LIKE: búsqueda por patrón Cadena con ese carácter coincidente. SELECT * FROM titles WHERE price BETWEEN 10 AND 50 Código fuente 75 • IN: Verifica si el valor especificado está contenido dentro de una lista de ellos. 134 . La sintaxis es: expresion BETWEEN expresion AND expression Por ejemplo.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS <> != !> !< + Distinto Distinto No mayor No menor Concatenación Cadenas coincidentes. NOT: negación de la expresión LIKE: búsqueda por patrón Tabla 31 SELECT 1 <> 2 SELECT 1 != 1 SELECT 1 !> 3 SELECT 1 !<1 SELECT 'A' + 'B' SELECT * FROM tabla WHERE atributo1 LIKE '[CH]urry' SELECT + FROM tabla WHERE atributo1 NOT LIKE '[^I-Z]' VERDADERO FALSO VERDADERO VERDADERO AB [] Curry Hurry Operadores de Cadena [^] J.L. ejecutamos el Código fuente 76.K.

si queremos obtener el nombre de los autores.© Grupo EIDOS 14.33 milisegundos) de ocupación de la CPU ejecutando instrucciones SQL Server desde que éste fue ejecutado número de filas seleccionadas en la última selección número del primer día de la semana número del último error producido en la ejecución de una sentencia. la forma de evaluación es desde dentro hacia fuera. que viven en ciudades pertenecientes al estado de California (CA). La Tabla 32 muestra un resumen con las variables globales que nos pueden resultar de utilidad: @@connections @@cpu_busy @@cursor_rows @@datefirst @@error @@fetch_status @@identity @@idle @@io_busy @@LANGID número de conexiones realizadas desde que se ejecutó SQL Server número de ticks (3. -1: preselección erronea. y luego se aplica el valor obtenido para la evaluación del operador IN. Esta variables se pueden distinguir porque comienzan por dos arrobas @@. Operadores básicos y consideraciones del lenguaje SELECT au_lname FROM authors where city in ('San Francisco'. etc. es decir.'Salt Lake City') Código fuente 76 También se puede especificar como lista. SELECT au_lname FROM authors where city IN (SELECT city FROM authors WHERE state = 'CA') Código fuente 77 En la anterior consulta. el resultado de otra consulta. que informan en cada momento del estado del sistema. Por ejemplo. 0 si no ha habido error estado de la preselección (0: preselección satisfactoria. escribimos el Código fuente 77. o del resultado de una consulta. primero se evalúa la sentencia que está entre paréntesis. -2: filas no disponibles) identificador de la última operación realizada número de ticks de tiempo ocioso de CPU desde que se ejecutó SQL Server número de ticks de tiempo empleado en realizar operaciones de entrada/salida desde que se ejecutó SQL Server lenguaje local actual seleccionado 135 . Variables globales Existe un conjunto de variables globales.

fecha y tipo de procesador actualmente en uso para SQL Server Tabla 32 136 .Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS @@language @@lock_timeout @@max_connectio ns @@max_precision @@nestlevel @@options @@pack_received @@pack_sent @@packet_errors @@procid @@remserver @@rowcount @@servername @@servicename @@spid @@textsize @@timeticks @@total_errors @@total_read @@total_write @@trancount @@version descripción del lenguaje especificado para SQL server tiempo de time-out (tiempo hasta el cual se intenta dar por válida la transacción) en milisegundos para bloqueo número máximo de conexiones simultaneas que permite SQL Server nivel de precisión usado por los tipos de datos decimal y numeric nivel de anidamiento del actual procedimiento almacenado información sobre las opciones de usuario número de paquetes recibidos por SQL Server desde que se inicializó número de paquetes enviados por SQL Server desde que se inicializó número de paquetes erróneos desde que SQL Server se inicializó identificador del actual procedimiento almacenado nombre del servidor remoto número de filas afectadas por una sentencia de selección nombre del servidor local nombre de la clave de registro para SQL Server identificador del proceso actualmente en ejecución tamaño máximo para los tipos de datos texto e imágenes número de milisegundos por tick de CPU número total de errores producidos desde que se inicializó SQL Server número de lecturas de disco desde que se inicializó SQL Server número de escrituras en disco desde que se inicializó SQL Server número de transacciones activas por el usuario en curso versión.

. correspondiente a la parte ELSE (opcional). IF (SELECT count(*) FROM titles) > 10 BEGIN SELECT title FROM titles END ELSE BEGIN SELECT count(*) FROM titles END Código fuente 78 En definitiva. en lugar de una sola. según se cumpla el valor de una expresión lógica. Por ejemplo. se ejecutará la sentencia 2. Si deseamos obtener los títulos almacenados cuando éstos superen las 10 unidades.© Grupo EIDOS 14. En otro caso. se devolverá el resultado correspondiente especificado a continuación de la palabra reservada THEN. si queremos saber el nombre de los estados de los autores. En otro caso. SELECT state = CASE state WHEN 'CA' THEN 'California' WHEN 'OR' THEN 'Oregon' ELSE 'Otro' 137 . Operadores básicos y consideraciones del lenguaje Sentencias condicionales Las sentencias condicionales son aquellas que permiten discriminar entre diversas sentencias. no ha verificado ninguna de las expresiones. Si se desea especificar un conjunto de sentencias. La primera de ellas tiene la siguiente sintaxis: IF expresion_logica sentencia1 [ELSE sentencia2] La sentencia 1 sólo se ejecutará si el resultado de la evaluación de la expresión lógica es verdadera. Si llegados al final. Si alguna de estas expresiones se cumple. [ELSE resultado3] La anterior sentencia compara la expresión 1. Existen dos tipos de sentencias condicionales. ejecutaremos el Código fuente 78. éstas deberán ir encerradas entre las palabras reservadas BEGIN y END. se ejecutará la rama ELSE. que devuelve el número de títulos almacenados en la tabla titles.. con el resto de expresiones especificadas a continuación de la palabra reservada WHEN. La sintaxis es la siguiente: CASE expresion1 WHEN expresion2 THEN resultado1 WHEN expresion3 THEN resultado2 . podemos ejecutar el Código fuente 79. en lugar de las iniciales. la sentencia SELECT title FROM titles sólo se ejecuta cuando se cumple la condición (SELECT count(*) FROM titles) > 10. Otra forma de ejecutar sentencias de forma condicional. corresponde a la sentencia CASE. se devolverá el resultado especificado a continuación del ELSE. y el número de ellos cuando no lo superen.

138 . La sentencia que permite realizarlo es WHILE. aunque se cumpla la expresión lógica. si es OR se devolverá Oregon. y abandonarlo. mientras se cumpla una condición lógica. ignorando aquellas que vienen a continuación del CONTINUE. permite romper el bucle.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS END FROM authors Código fuente 79 En este caso se comprueba el valor del atributo state. La cláusula BREAK. y su sintaxis WHILE expresion_logica sentencia [BREAK] [CONTINUE] La sentencia especificada se ejecuta de forma iterativa. mientras se cumpla la expresión lógica. mientras que CONTINUE permite ejecutar de nuevo las sentencias desde el comienzo del bucle. se devolverá California. Sentencias iterativas Una sentencia iterativa es aquella que permite ejecutar una o varias sentencias de manera repetida. y en otro caso se devolverá el literal 'Otro'. y si este es igual a CA.

y <valores> es una lista de valores separados por comas. La palabra reservada INTO es opcional y se puede omitir en la sentencia. Si insertamos un valor nulo para un atributo que no acepta ese tipo de valores. y los valores para dichos atributos. los atributos que se van a insertar. que ya se ha visto. se producirá un error y la fila no será insertada. Existe una correspondencia unívoca entre los atributos y los valores. al atributo especificado en primer lugar se le asignará el valor indicado en primer lugar. y así sucesivamente. especifica el nombre de una tabla. .La sentencia INSERT Introducción La sentencia insert permite la introducción de nuevos registros dentro de un esquema. Su sintaxis. o si no especificamos un valor concreto para este tipo de columnas. es decir. Sintaxis La sintaxis de la sentencia insert es la siguiente INSERT INTO <tabla> (<atributos>) VALUES (<valores>) donde <atributos> es una lista de atributos separados por comas.

‘Madrid’) Código fuente 80 Figura 83 Para ver si efectivamente se han insertado ambos registros.Bases de datos con SQL Server2000 – Transact SQL © Grupo EIDOS Ejemplos Para comenzar veremos un ejemplo sencillo de inserción de tuplas en la tabla del ejemplo de la agencia inmobiliaria que venimos manejando. ejecutamos una sentencia select como muestra el Código fuente 81 (véase la Figura 83). como indica el Código fuente 80. Insertaremos dos Comunidades Autonomas en la tabla de comunidades. CA_Nombre) VALUES (2. CA_Nombre) VALUES (1. ‘Catalunya’) INSERT INTO ComunidadAutonoma (CA_ID. INSERT INTO ComunidadAutonoma (CA_ID. SELECT * FROM ComunidadAutonoma Código fuente 81 140 .

© Grupo EIDOS

15. La sentencia INSERT

Como decíamos, si ahora intentamos insertar otra provincia si especificar el atributo CA_ID, que es clave, se producirá un error, como podemos observar en la Figura 84 al ejecutar el Código fuente 82.

INSERT INTO ComunidadAutonoma (CA_Nombre) VALUES (‘Andalucía’) Código fuente 82

O si por el contrario introducimos un valor duplicado para la clave, también obtendremos el error de la Figura 85 al ejecutar el Código fuente 83.

INSERT INTO ComunidadAutonoma (CA_ID, CA_Nombre) VALUES (1, ‘Andalucía’) Código fuente 83

Figura 84

Otra forma de introducir filas es no especificando la lista de atributos, en cuyo caso los valores se van asignando de manera secuencial a los atributos de la tabla. Por ejemplo en el Código fuente 84 se asigna el valor 3 al atributo CA_ID y ‘Andalucía’ al atributo CA_Nombre.

141

Bases de datos con SQL Server2000 – Transact SQL

© Grupo EIDOS

Figura 85

INSERT INTO ComunidadAutonoma VALUES (3, 'Andalucía') Código fuente 84

Del mismo modo se pueden especificar valores para los atributos en distinto orden, siempre que se expresen de manera explícita en la lista de los mismos, como muestra el Código fuente 85, en el que se asigna el código 1 a la provincia Madrid, que pertenece a la comunidad de Madrid (es decir, código 2).

INSERT INTO Provincia (Prv_Nombre, Prv_ID, CA_ID) VALUES ('Madrid’, 1, 2) Código fuente 85

Así mismo se pueden especificar menos valores que atributos, siempre que para los atributos que no se especifiquen se puedan insertar valores nulos o los establecidos por defecto. La forma de asignar estos valores por defecto es como se muestra en el Código fuente 86.

INSERT INTO tabla DEFAULT VALUES Código fuente 86

142

© Grupo EIDOS

15. La sentencia INSERT

Esto insertaría una nueva fila en la tabla, con los valores establecidos por defecto. Otra forma de insertar filas es a partir del resultado de una consulta. Por ejemplo, el Código fuente 87 insertaría en la tabla 2, los valores de la tabla 1. Ni que decir tiene que ambos esquemas deben coincidir. También se puede especificar un filtro en la claúsula where para la consulta.

INSERT INTO tabla2 SELECT * FROM tabla1 Código fuente 87

Carga de la base de datos de ejemplo
Para concluir este capítulo, se ofrecen las sentencias necesarias para cargar las tablas de la base de datos del ejemplo de la agencia inmobiliaria que venimos utilizando.

INSERT INTO Provincia VALUES (2, 1, 'Barcelona') INSERT VALUES INSERT VALUES INSERT VALUES INTO TipoBien (1, 'Piso') INTO TipoBien (2, 'Chalet') INTO TipoBien (3, 'Solar')

INSERT INTO Cliente VALUES ('11384H', 'Juan Jose', 'Martinez', 'C/Bernardino 2', '28021', 1, '913382888', '12888271777') INSERT INTO Cliente VALUES ('11383K', 'Alfonso', 'Loira', 'C/Apache 34', '28023', 1, '913334888', '123423471777') INSERT INTO Cliente VALUES ('123454L', 'Amadeo', 'Lerra', 'C/Portugal 4', '08021', 2, '933485888', '1282344777') INSERT INTO Comercial VALUES ('113384H', 'Juan Alberto', 'Espado', 'C/Alcala 321', '28038', 1, '914538288', '1') INSERT INTO Comercial VALUES ('11323K', 'Luis', 'Canto', 'C/Esplandiu 4', '28033', 1, '913379888', '2') INSERT INTO Comercial VALUES ('22354L', 'Pedro', 'Alcantara', 'C/Portugal 4', '08021', 2, '933485875', '3') INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INTO Oferta (1, 1, 'C/Samba, 4', 1, 'V', 100000, '11323K', '11384H') INTO Oferta (2, 2, 'C/Salca, 34', 2, 'A', 1000, '113384H', '11383K') INTO Oferta (3, 1, 'C/Sabueso, 83', 1, 'V', 100000, '11323K', '11383K') INTO Oferta (4, 2, 'C/Llobregat, 34', 2, 'V', 100000, '11323K', '11384H') INTO Oferta (5, 1, 'C/Alcala, 197', 1, 'A', 500, '113384H', '11384H') INTO Oferta (6, 2, 'C/Alquimia, 34', 2, 'V', 100000, '22354L', '123454L')

143

Bases de datos con SQL Server2000 – Transact SQL

© Grupo EIDOS

INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES

INTO Oferta (7, 1, 'C/Alcosta, 867', 1, 'V', 100000, '11323K', '123454L') INTO Oferta (8, 1, 'C/Lorca, 33', 1, 'V', 100000, '22354L', '11384H') INTO Oferta (9, 1, 'C/Alcantara, 256', 1, 'V', 100000, '11323K', '11384H') INTO Oferta (10, 1, 'C/Arboleda, 32', 1, 'V', 100000, '11323K', '11384H') INTO Oferta (11, 1, 'C/Simbiosis, 32', 1, 'V', 100000, '11323K', '11384H') INTO TipoTransporte (1, 'Metro') INTO TipoTransporte (2, 'Cercanias') INTO TipoTransporte (3, 'Bus') INTO Transporte (1, 'Sol', 1) INTO Transporte (2, 'La Musas', 1) INTO Transporte (3, 'Alvarado', 1) INTO Transporte (4, 'Pacífico', 1) INTO Transporte (5, 'Sants', 1) INTO Transporte (6, 'Atocha', 2) INTO Transporte (7, 'Chamartin', 2) INTO Transporte (8, '12', 3) INTO Transporte (9, '24', 3) INTO Transporte (10, '2', 3) INTO Transporte (11, '123', 3) INTO Transporte (12, '56', 3) INTO Transporte (13, '34', 3) INTO Transporte (14, '5', 3) INTO OfertaTransporte (1, 1) INTO OfertaTransporte (1, 2) INTO OfertaTransporte (1, 3) INTO OfertaTransporte (3, 1) INTO OfertaTransporte (4, 4) INTO OfertaTransporte (4, 5) INTO OfertaTransporte (6, 1) INTO OfertaTransporte (6, 2) INTO OfertaTransporte (6, 6) INTO OfertaTransporte (8, 8)

144

© Grupo EIDOS

15. La sentencia INSERT

INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES

INTO OfertaTransporte (8, 9) INTO OfertaTransporte (8, 10) INTO OfertaTransporte (8, 11) INTO OfertaTransporte (9, 1) INTO OfertaTransporte (9, 8) INTO OfertaTransporte (10, 3) INTO OfertaTransporte (10, 10) INTO OfertaTransporte (10, 11) INTO OfertaTransporte (10, 12) INTO OfertaTransporte (10, 5) Código fuente 88

145

La sentencia SELECT
Introducción
La sentencia select es la principal manera que tiene el usuario de consultar información de la base de datos. Veremos aquí algunos ejemplos de utilización, basándonos en los ejemplos que hemos visto en el capítulo acerca del DDL. La forma más simple de utilización es especificando una lista de atributos de una tabla. Así el Código fuente 89 mostraría todos los datos referentes a comerciales

SELECT * FROM Comercial Código fuente 89

y el Código fuente 90 mostraría el nombre y apellidos de todos los clientes

SELECT Cli_Nombre, Cli_Apellidos FROM Cliente Código fuente 90

Bases de datos con SQL Server2000 – Transact SQL

© Grupo EIDOS

La claúsula WHERE
La forma de especificar una condición dentro de una sentencia select es mediante la claúsula WHERE, que especifica una condición lógica que devolverá únicamente aquellos registros que la cumplan. Por ejemplo, para obtener todos los inmuebles de la tabla de ofertas que se encuentran en venta, deberíamos teclear el Código fuente 91.

SELECT * FROM Oferta WHERE Oferta.Of_Transaccion = ‘V’ Código fuente 91

O si queremos consultar todos los inmuebles cuyo precio oscile entre 100 y 2.000 euros, deberemos ejecutar Código fuente 92.

SELECT * FROM Oferta WHERE Oferta.Of_Precio >= 100 and Oferta.Of_Precio <= 2000 Código fuente 92

Esta sentencia equivaldría a esta otra:

SELECT * FROM Oferta WHERE Oferta.Of_Precio BETWEEN 100

and 2000

Código fuente 93

Si además deseamos especificar un orden, habrá que utilizar la claúsula ORDER BY. Por ejemplo, el Código fuente 94 muestra el precio de todos los inmuebles de 100 a 2.000 euros, ordenado de más caro a más barato, como muestra la Figura 86.

SELECT Oferta.Of_Precio FROM Oferta WHERE Oferta.Of_Precio BETWEEN 100 ORDER BY Oferta.Of_Precio

and 2000

Código fuente 94

148

Prv_Nombre FROM Oferta Inner join Provincia on Oferta. el operador join es el más usado para obtener información de tablas relacionadas. que se encuentra en otra tabla distinta de la de ofertas.Prv_ID = Provincia. Si por ejemplo deseamos obtener todas las viviendas que no 149 .© Grupo EIDOS 16. La diferencia entre ambos ya se ha comentado en un capítulo anterior. La sentencia SELECT Figura 86 El operador join Si la sentencia select es la más utilizada para consulta de información. así que no se entrará en detalle. como pueden ser el left outer y el rigth outer. y que se encuentra relacionada con ésta mediante la clave ajena Prv_ID. para obtener una información detallada de en que provincias se encuentran los inmuebles. Si deseamos obtener datos de dos tablas que están relacionadas por un atributo. SELECT Of_Direccion. En el anterior ejemplo se ha utilizado un inner join. deberemos ejecutar el Código fuente 95.Prv_ID Código fuente 95 De esta manera obtenemos la información de la provincia. Por ejemplo. pero también existen otros tipos de join. deberemos utilizar este operador para obtener la información contenida en ambas.

vInmuebles SELECT Oferta. TipoBien.Bases de datos con SQL Server2000 – Transact SQL © Grupo EIDOS han sido compradas todavía por ningún cliente.TB_ID Código fuente 98 Ya continuación hacer un select de la vista como si de una tabla se tratase: SELECT * FROM vInmuebles 150 .TB_ID = TipoBien. si dicho cliente no existe en la base de datos. que sean pisos.Cli_NIF FROM Oferta Inner join Provincia on Oferta. Supongamos que ahora nos viene un cliente.Of_Direccion.TB_Nombre = ‘Piso’ WHERE Oferta. SELECT * FROM Oferta Inner join Provincia on Oferta. obtendremos ese atributo a nulo. Prv_Nombre.Prv_ID INNER JOIN TipoBien ON Oferta.TB_ID = TipoBien.Prv_ID Left outer join Cliente on Oferta.Cli_NIF = Cliente. Provincia.Cli_NIF WHERE Cliente.Prv_Nombre. obtendremos los clientes que no tienen correspondencia con las ofertas. Cliente.Cli_NIF is null Código fuente 96 En el anterior ejemplo. que se encuentren en alquiler y que pertenezcan a la provincia de Madrid. Oferta.Prv_Nombre = ‘Madrid’ inner join TipoBien on Oferta.Prv_ID = Provincia.Prv_ID = Provincia.Of_Transaccion. Puesto que se ha utilizado una claúsula where que nos devuelve únicamente los clientes que tienen dicho atributo a nulo. y a continuación un left outer join con la tabla de clientes para obtener el cliente que tiene asignado la oferta.Prv_ID and Provincia.Of_Transaccion = ‘A’ Código fuente 97 Aunque el anterior código es válido. o que han sido asignadas a clientes erróneos deberemos ejecutar el Código fuente 96.TB_ID and TipoBien.Prv_ID = Provincia. y nos pregunta por todos los inmuebles. primero realizamos un inner join para obtener la provincia (caso de que no exista no aparecería nada). SELECT Of_Direccion.TB_Nombre FROM Oferta INNER JOIN Provincia ON Oferta. hubiese sido más cómodo crear una vista como la siguiente: CREATE VIEW dbo. Habría que ejecutar el Código fuente 97.

© Grupo EIDOS 16.TT_Nombre = ‘Cercanias’) Código fuente 100 Incluso podemos seleccionar todos los clientes que no han comprado ningún inmueble: SELECT Cliente.Cli_NIF is null Código fuente 101 Sin embargo.TT_ID (TipoTransporte.Cli_NIF = Cliente. El código sería el siguiente: SELECT Of_Precio FROM Oferta Inner join Inner join Inner join And OfertaTransporte on Oferta.Tr_ID TipoTransporte on Transporte. lo cual se obtiene mediante la claúsula ORDER BY <atributo> DESC. y cogiendo el primer registro de todos (utilizando la claúsula TOP 1).TT_ID = TipoTransporte. como muestra el Código fuente 103 y podemos apreciar en la Figura 87. Ordenando por precio de manera descendente. La sentencia SELECT WHERE Of_Transaccion = ‘A’ and TB_Nombre = ‘Piso’ and Prv_Nombre = ‘Madrid’ Código fuente 99 Vamos ahora a por un ejemplo con los transportes.Cli_NIF WHERE Oferta. Supóngase que se desea saber cuanto valen todos los pisos que están próximos a una estación de cercanías o de metro.Cli_Nombre FROM Cliente Left outer join Oferta on Oferta.Tr_ID = Transporte. Of_Precio FROM Oferta ORDER BY Of_Precio desc Código fuente 103 151 .Of_ID = Transporte.TT_Nombre = ‘Metro’ or TipoTransporte. obtenemos el inmueble cuyo precio es máximo.Of_ID Transporte on OfertaTransporte. SELECT top 1 Of_Direccion. el anterior código podría haberse simplificado de la siguiente manera: SELECT Cli_NIF FROM Cliente WHERE Cli_NIF not in (SELECT Cli_NIF FROM Oferta) Código fuente 102 Las funciones de agregado Imaginemos ahora que deseamos obtener el inmueble más caro de todos.

SELECT min(Of_Precio) FROM Oferta Inner join Provincia on Provincia. encontramos la función min. T-SQL nos ofrece una forma más sencilla de realizar esta consulta.Prv_ID = Oferta. De esta manera obtenemos el máximo valor para el atributo que especificamos para dicha función. utilizando una función de agregado que se denomina max. Por ejemplo. SQL-SERVER nos ofrece otras muchas. que veremos en más detalle a continuación. y análogamente a max.Bases de datos con SQL Server2000 – Transact SQL © Grupo EIDOS Figura 87 Sin embargo.Prv_Nombre = ‘Madrid’ Código fuente 105 152 . dentro de la consulta especificada. como muestra el siguiente código equivalente: SELECT max(Of_Precio) FROM Oferta Código fuente 104 Además de este función de agregado. encargada de devolver el registro cuyo valor es el mínimo.Prv_ID and Provincia. El Código fuente 105 devolvería el inmueble más barato de la provincia de Madrid.

En este caso. como muestra el Código fuente 108. SELECT avg(Of_Precio) FROM Oferta Inner join Provincia on Oferta. y cuyo cometido es devolver como resultado la suma del atributo especificado entre paréntesis.Cli_NIF = Cliente.Prv_ID = Provincia. SELECT sum(Of_Precio) FROM Oferta inner join Cliente on Oferta. El Código fuente 107 serviría para contar el número de filas de la tabla Oferta.Prv_ID = Provincia. para un atributo determinado dentro de una consulta. SELECT count(*) FROM Oferta Código fuente 107 Y si queremos obtener el número de ofertas existentes en la provincia de Barcelona. será necesario obtener por medio de un join que contenga dicho nombre.Prv_ID And Provincia. Por ejemplo. ya que el número de filas es similar es para todos los atributos. La sentencia SELECT Otra función muy usual es la de suma. dentro de la consulta especificada. seria equivalente al código que realiza los cálculos por separado. Si queremos obtener el dinero gastado por un cliente del que sabemos que su apellido empieza por “Marti”.© Grupo EIDOS 16. pero ahora filtrando por el código de provincia que. aunque se puede especificar un atributo entre paréntesis.Prv_ID And Provincia.Prv_Nombre = ‘Barcelona’ Código fuente 108 Para obtener media aritméticas. bastaría ejecutar el Código fuente 106. el número total de ofertas almacenadas en la base de datos. lo más usual es poner el comodín *. como no conocemos a priori. restringiendo en ésta última tabla por aquellos clientes cuyo atributo apellidos comience por Marti (claúsula like). expresada por sum. volveremos a utilizar esta sentencia. cuya misión es contar es numero de filas que devuelve la consulta. el código que nos muestra la media del precio de los inmuebles de Barcelona. No menos importante es la función count. es decir.Cli_Apellidos like 'Marti%' Código fuente 106 En el anterior código nos basamos en utilizar un join con la tabla de clientes utilizando el atributo común Cli_NIF.Prv_Nombre = ‘Barcelona’ Código fuente 109 153 .Cli_NIF and Cliente. SELECT count(*) FROM Oferta Inner join Provincia on Oferta. SQL-SERVER nos ofrece la función avg.

es como un where pero que se aplica a grupos de registros.Prv_ID = Provincia. deberemos utilizar esta claúsula. entonces tendremos un avg por cada grupo que obtengamos.Prv_Nombre FROM Oferta Inner join Provincia on Oferta.Prv_ID = Provincia. la varianza estadística (var) y la varianza de llenado (varp).Prv_ID = Provincia. Modificamos el código para utilizar esta cláusula. debemos utilizar es la claúsula group by. Si modificamos la anterior consulta para que sólo se devuelvan aquellas provincias cuya media de precio supera los 100. La claúsula GROUP BY Si deseamos obtener agrupaciones dentro de una consulta. y Prv_Nombre puede que no sea único. Provincia.000 euros. Provincia.Prv_ID GROUP BY Provincia. en principio deberíamos ejecutar el Código fuente 111. SELECT avg(Of_Precio). si ejecutamos este código.Bases de datos con SQL Server2000 – Transact SQL © Grupo EIDOS SELECT sum(Of_Precio) / count(Of_Precio) as media FROM Oferta Inner join Provincia on Oferta.Prv_Nombre WHERE avg(Of_Precio) > 100000 Código fuente 113 154 . SELECT avg(Of_Precio).Prv_Nombre FROM Oferta Inner join Provincia on Oferta. Si por ejemplo deseamos obtener la media del precio de los pisos por provincias.Prv_ID Código fuente 111 Sin embargo. lo lógico sería ejecutar el código.Prv_Nombre Código fuente 112 Paralelamente al uso de group by se suele utilizar la claúsula having. nos mostraría un error.Prv_Nombre FROM Oferta Inner join Provincia on Oferta. Provincia. Para entendernos. para obtener los resultados agrupados. y obtenemos algo como la Figura 88.Prv_ID GROUP BY Provincia.Prv_ID = Provincia. en lugar de a registros por si solos. la desviación típica de la población (stdevp).Prv_ID And Provincia.Prv_Nombre = ‘Barcelona’ Código fuente 110 El funcionamiento es similar para las funciones encargadas de calcular la desviación típica (stdev). SELECT avg(Of_Precio). por lo que SQL SERVER se hace “un lio”. ya que avg devuelve un registro. Para evitar esto.

Prv_ID = Provincia. La sentencia SELECT Figura 88 Sin embargo esto nos devuelve un error. Sustituimos el where por having en el Código fuente 114. al estar utilizando group by deberemos especificar una función de agregado. ya que el where se aplica a registros y. SELECT Prv_Nombre FROM Oferta inner join Provincia on Oferta. SELECT avg(Of_Precio). para obtener cuales son las provincias en las cuales tenemos algún inmueble. Por ejemplo.Prv_ID GROUP BY Provincia.© Grupo EIDOS 16. podríamos ejecutar el código.Prv_ID Código fuente 115 155 . Provincia.Prv_Nombre FROM Oferta Inner join Provincia on Oferta.Prv_Nombre HAVING avg(Of_Precio) > 100000 Código fuente 114 Otra utilidad que ofrece la cláusula group by es la de obtener los valores distintos que aparecen para uno o varios atributos.Prv_ID = Provincia.

Bases de datos con SQL Server2000 – Transact SQL © Grupo EIDOS Sin embargo. podemos utilizar la función dinstinct. con los consiguientes duplicados. que sí se resolvería utilizando la claúsula group by. SELECT count(Prv_Nombre) Cantidad.Prv_ID = Provincia.Prv_ID = Provincia. Prv_Nombre FROM Oferta inner join Provincia on Oferta. esto nos devuelve un registro por cada oferta que se encuentre. como sigue. por ejemplo contar el número de inmuebles por provincia. Para evitar esto.Prv_ID Código fuente 116 Sin embargo esto no es válido si queremos realizar algún tipo de información adicional. como muestra el Código fuente 117.Prv_ID GROUP BY Prv_Nombre Código fuente 117 156 . SELECT distinct(Prv_Nombre) FROM Oferta inner join Provincia on Oferta.

en el caso de sólo se necesite acceder a una tabla. UPDATE Comercial SET Com_Direccion = 'C/Esplandiu. 5' . la sentencia update se utiliza para modificar la información existente. que será la misma que la que se actualice. éstas se deberán separar por comas. UPDATE <tabla> SET <atributo> = <valor> FROM <tablas> WHERE <condicion> Si se especifica más de una asignación de un valor a un atributo. que se muestra en el Código fuente 118 donde se actualiza la dirección del comercial cuyo NIF es 11323K. La claúsula FROM se puede omitir.La sentencia UPDATE Introducción Esta sentencia es la que permite la actualización de la información almacenada en la base datos. Si la sentencia insert se utilizaba para añadir nueva información. Su sintaxis es la siguiente. Ejemplos Para comenzar veremos un ejemplo sencillo.

se puede hacer subir a la categoría 4 a todos los comerciales de Madrid. UPDATE Comercial SET Com_Categoria = '4' FROM Comercial. obteniendo el resultado de la Figura 89.Bases de datos con SQL Server2000 – Transact SQL © Grupo EIDOS WHERE Com_NIF = '11323K' Código fuente 118 Para comprobar que efectivamente el cambio ha tenido efecto. sino que se pueden actualizar todas las filas que coincidan con un criterio de búsqueda. ejecutando el Código fuente 119.Prv_ID = Provincia. Por ejemplo.Prv_ID and Prv_Nombre = 'Madrid' Código fuente 120 158 . vamos a consultar los datos de este comercial. Com_Direccion FROM Comercial WHERE Com_NIF = '11323K' Código fuente 119 Figura 89 Pero no simplemente se puede actualizar una fila cada vez. para la cual se deberá ejecutar el Código fuente 120. Provincia WHERE Comercial. SELECT Com_NIF.

ejecutamos el Código fuente 121. es posible actualizar más de uno simultáneamente. Provincia WHERE Comercial. SELECT Com_Categoria. pero como hemos dicho. y sólo los correspondientes a la provincia de Madrid. ya que necesitábamos conocer el identificador correspondiente a la provincia de Madrid. Prv_Nombre FROM Comercial.Prv_ID Código fuente 121 Figura 90 Hasta ahora sólo hemos actualizado un atributo.© Grupo EIDOS 17. UPDATE Cliente SET Cli_Direccion = 'C/Apache 35'. La sentencia UPDATE En este caso hemos tenido que especifica la claúsula from para acceder a la tabla de provincias. Cli_Telefono = '912237887' WHERE Cli_Nombre = 'Juan Jose' and Cli_Apellidos = 'Martinez' Código fuente 122 159 . el Código fuente 122 muestra como actualizar la dirección y el teléfono del cliente Juan Jose Martinez.Prv_ID = Provincia. Por ejemplo. aunque no sea ésta la que se actualice. Para comprobar si se han actualizado los datos.

Primero ejecutaremos el Código fuente 124 para comprobar cual es el precio de estos inmuebles. Por ejemplo. Prv_Nombre FROM Oferta inner join Provincia on Provincia. obteniendo el resultado de la Figura 91. SELECT * FROM Cliente WHERE Cli_Nombre = 'Juan Jose' and Cli_Apellidos = 'Martinez' Código fuente 123 Figura 91 Del mismo modo. no hace falta especificar un valor a la hora de actualizar uno o varios atributos. 160 .Prv_ID where Prv_Nombre = 'Barcelona' Código fuente 124 Ahora ejecutamos el Código fuente 125 para actualizar su precio a un 5% más de su valor actual.Prv_ID = Oferta.Bases de datos con SQL Server2000 – Transact SQL © Grupo EIDOS Para comprobar que se ha actualizado correctamente el registro. podemos subir el precio de todos los inmuebles de Barcelona un 5%. ejecutamos el Código fuente 123. SELECT Of_Precio. sino que se puede indicar una expresión.

Provincia WHERE Provincia. actualizaremos la categoría del comercial dependiendo del número de inmuebles que haya vendido cada uno. Por ejemplo. Si ha vendido entre 0 y 2.05) FROM Oferta. la categoría a asignar será de 1.© Grupo EIDOS 17. Vayamos paso a paso. ejecutando la sentencia del Código fuente 127.Com_NIF = Oferta.Prv_ID = Oferta. La sentencia UPDATE UPDATE Oferta SET Of_Precio = Of_Precio + (Of_Precio * 0. UPDATE Comercial SET Com_Categoria = ((SELECT count(*) / 2 FROM Oferta where Comercial. update nos permite la utilización de las funciones de agregación.Com_NIF)) Código fuente 128 161 .Com_NIF GROUP BY Comercial. Para calcular dicha categoría podemos aplicar la siguiente fórmula: Categoria = (nº inmuebles vendidos / 2) + (nº inmuebles vendidos módulo 2) El operador de módulo o resto de la división entera se representa en T-SQL como %. entre 5 y 6 será 3. ejecutamos nuevamente el Código fuente 126.Com_NIF = Oferta.Prv_ID where Prv_Nombre = 'Barcelona' Código fuente 126 De la misma forma que para la sentencia select. SELECT count(*) cantidad.Com_NIF = Comercial. primero veamos cuantos inmuebles ha vendido cada comercial. Prv_Nombre FROM Oferta inner join Provincia on Provincia. entre 3 y 4 será 2.Prv_ID = Oferta. SELECT Of_Precio. Com_Nombre FROM Comercial left outer join Oferta on Oferta.Com_NIF) + (SELECT count(*) % 2 FROM Oferta where Comercial.Com_Nombre Código fuente 127 Por lo tanto vemos que la asignación de categorías sería 1 para Juan Alberto y Pedro. y así sucesivamente. y 4 para Luis. para el cálculo de expresiones.Prv_ID and Prv_Nombre = 'Barcelona' Código fuente 125 Y para comprobar que efectivamente se han actualizado estos registros. Ejecutemos ahora el Código fuente 128 que nos permite hacer esto.

SELECT Com_Nombre. nos encontraríamos con lo siguiente. para dividirlo por 2. como la que se muestra en el Código fuente 129 para comprobar que efectivamente la actualización se ha realizado con éxito. calcular su módulo 2 y luego sumarlo y asignarlo al campo categoría. Com_Categoria FROM Comercial Código fuente 129 162 .Bases de datos con SQL Server2000 – Transact SQL © Grupo EIDOS Lo primero que se ha hecho es para cada comercial calcular el número de ofertas que tiene relacionado. Si ejecutamos una selección.

Si ésta se omite. ejecutando el Código fuente 130. lo más sencillo.La sentencia DELETE Introducción La sentencia delete es la que nos permite borrar tuplas almacenadas en la base de datos. nos encontraremos con que se borrará la oferta cuyo código es 11 de la tabla de ofertas. se borrarán todas las filas de la tabla especificada (mucho cuidado con esto). podemos obtener el máximo valor para el atributo Of_ID. DELETE FROM tabla WHERE condicion Donde tabla especifica el nombre de la tabla de donde se desean borrar las filas que cumplen la condición especificada en la claúsula where. podemos hacer una select completa de la tabla y verificar que falta dicho registro aunque. y conociendo que el registro que hemos borrado era el último introducido. . y comprobar que no es superior a 10. Su sintaxis es la siguiente. Si por ejemplo ejecutamos el Código fuente 130. DELETE FROM Oferta WHERE Of_ID = 11 Código fuente 130 Para comprobar si se ha borrado dicho registro.

primero deberemos borrar todas las ofertas en las que haya participado dicho comercial. Recordemos al lector que estas reglas son las que permiten mantener la información de la base de datos en un estado coherente. De esta manera. nos da un error. si por ejemplo queremos borrar el comercial Luis Canto. ya que resulta que existen filas en la tabla que relaciona las ofertas y los transportes.Com_NIF and Com_Nombre = 'Luis' and Com_Apellidos = 'Canto' Código fuente 133 Sin embargo. DELETE FROM Comercial Where Com_Nombre = 'Luis' and Com_Apellidos = 'Canto' Código fuente 132 que. Para evitar esto. ejecutando el Código fuente 133. hacen referencia a comerciales que ya no existen en la base de datos. Para comprender mejor esto. ejecutaremos el Código fuente 132. si éste esta relacionado con alguna otra tabla.Bases de datos con SQL Server2000 – Transact SQL © Grupo EIDOS SELECT max(Of_ID) FROM Oferta Código fuente 131 La integridad referencial Un aspecto a tener en cuenta es el no violar las reglas de integridad referencial que sostienen la base de datos. Por lo tanto. al ejecutar este código nos encontramos en la misma situación. primero deberemos borrar éstas. es decir. como cabía esperar. Si lo hemos hecho bien. cuando pretendamos borrar una tupla de estas características.Com_NIF = Comercial. las reglas de integridad nos permiten olvidarnos a la hora de borrar un registro. supongamos que borramos todos los comerciales de la base de datos. el SGBD nos advertirá de ello y no nos dejará borrarla. que hacen referencia a dicha oferta. como muestra el Código fuente 134. Es decir. para evitar posibles inconsistencias que pudieran surgir al eliminar atributos que son clave ajena en otra relación. Esto supondría que tendríamos ofertas inconsistentes. DELETE FROM Oferta FROM Comercial Where Oferta. DELETE FROM Oferta FROM Comercial 164 . evitando esta pérdida de información.

pero permanece la estructura y sus columnas. sin preocuparnos de posibles inconsistencias. TRUNCATE TABLE quita los datos al cancelar la asignación de las páginas de datos utilizadas para almacenar los datos de la tabla y sólo se graba en el registro de transacciones la página de asignaciones quitadas. el Código fuente 137 borraría todos los datos de la tabla Cliente TRUNCATE TABLE Cliente Código fuente 137 165 . restricciones. Pero TRUNCATE TABLE es más rápida y utiliza menos recursos de los registros de transacciones y de sistema que delete. El contador utilizado por una identidad para las nuevas filas se restablece al valor de inicialización de la columna. TRUNCATE TABLE quita todas las filas de una tabla. Si desea conservar el valor del contador. se debe utilizar delete en su lugar. ejecutando el Código fuente 135. etc. La instrucción DELETE quita una a una las filas y graba una entrada en el registro de transacciones por cada fila eliminada. volvemos atrás para borrar las filas de Oferta. DELETE FROM Oferta FROM Comercial Where Oferta.Com_NIF and Com_Nombre = 'Luis' and Com_Apellidos = 'Canto' Código fuente 135 Y una vez borradas las ofertas de dicho comercial. DELETE FROM Comercial Where Com_Nombre = 'Luis' and Com_Apellidos = 'Canto' Código fuente 136 La sentencia TRUNCATE TABLE Esta sentencia funciona de la misma forma que la instrucción delete sin especificar una cláusula WHERE: ambas quitan todas las filas de la tabla. índices. La sentencia DELETE Where Oferta. ya le podemos eliminar de la base de datos.Com_NIF = Comercial. con el Código fuente 136. Por ejemplo.© Grupo EIDOS 18.Com_NIF = Comercial.Com_NIF and Com_Nombre = 'Luis' and Com_Apellidos = 'Canto' Código fuente 134 Una vez borradas las filas de OfertaTransporte.

si queremos borrar todas las ofertas de la Catalunya. ejecutando el Código fuente 139. Sin embargo.CA_ID = Provincia. borraremos las ofertas como era nuestra pretensión. para lo cual podemos volver a ejecutar una subconsulta en un segundo nivel para obtener dichas filas. podemos utilizar una subconsulta que nos devuelva los identificadores de las provincias pertenecientes a dicha comunidad.CA_Nombre = 'Catalunya' and ComunidadAutonoma.CA_ID = Provincia. utilizando para ello el operador de contenido (in). DELETE Oferta FROM (SELECT top 2 * FROM Oferta) as t Código fuente 140 Puesto que esto devuelve un error debido a la integridad referencial. DELETE FROM Oferta WHERE Prv_ID in (SELECT Prv_ID FROM ComunidadAutonoma. y al igual que hacíamos con la sentencia select. para a continuación efectuar el borrado de toda las ofertas que contengan dicho identificador.CA_Nombre = 'Catalunya' and ComunidadAutonoma. Por ejemplo. se puede utilizar el resultado de una subconsulta para borrar un conjunto de registros. Provincia WHERE ComunidadAutonoma. Para ello ejecutamos el Código fuente 138 DELETE FROM OfertaTransporte WHERE Of_ID in (SELECT Of_ID FROM Oferta WHERE Prv_ID in (SELECT Prv_ID FROM ComunidadAutonoma. Por ejemplo. Por ejemplo.Bases de datos con SQL Server2000 – Transact SQL © Grupo EIDOS Ejemplos Veamos ahora algunos ejemplos para afianzar al lector en el uso de esta sentencia. el Código fuente 140 mostraría como borrar las dos primeras ofertas. una vez borradas todos los transportes disponibles para la oferta. 166 . deberemos ejecutar primero el Código fuente 141que elimine las filas de OfertaTransporte relacionadas. primero habrá que borrar todas las filas de OfertaTransporte que estén relacionadas con éstas.CA_ID)) Código fuente 138 De esta manera y. Provincia WHERE ComunidadAutonoma. se puede indicar una consulta.CA_ID) Código fuente 139 Además de especificar una tabla en una sentencia delete.

que permita borrar dichas filas. Aquí. se utiliza para hacer un join con la tabla OfertaTransporte.© Grupo EIDOS 18. Aquí. se ha utilizado una subconsulta como tabla. se utiliza para hacer un join con la tabla OfertaTransporte. que nos servirá para luego hacer referencia a dicha subconsulta en la claúsula where. que nos servirá para luego hacer referencia a dicha subconsulta en la claúsula where. En este código. 167 . que permita borrar dichas filas. por ejemplo.Of_ID Código fuente 141 En este código. especificando para la misma un alias (t).Of_ID = OfertaTransporte. especificando para la misma un alias (t). La sentencia DELETE DELETE OfertaTransporte FROM (SELECT top 2 * FROM Oferta) as t WHERE t. por ejemplo. se ha utilizado una subconsulta como tabla.

.

de nombre ObtenerNombre. se crea un procedimiento almacenado. porque permiten almacenar funciones y procedimientos compuestos por varias instrucciones. bucles. para ampliar su potencia modularmente. De esta forma. etc. CREATE PROCEDURE ObtenerNombre @au_id varchar(11) AS SELECT au_name FROM author WHERE author. cuyo código se pasa por parámetro. cuyo código coincida con el parámetro. Los procedimientos almacenados de SQL Server.au_id = @au_id Código fuente 142 Con esta sentencia.Procedimientos almacenados y triggers Introducción Los procedimientos almacenados son conjuntos de sentencias en leguaje Transact SQL que pueden almacenarse en el propio servidor. podemos crear un procedimiento para recuperar el nombre de un autor. deberemos ejecutar el procedimiento pasándole como argumento este valor: . son más potentes. al que se le pasa un parámetro. si queremos obtener el nombre del autor cuyo código sea '123'. que realiza una consulta para obtener el nombre de la tabla author. introducir saltos. También se pueden compilar procedimiento escritos en lenguaje C. llamado @au_id. Por ejemplo. de tipo varchar(11).

y diremos sin éstos son de salida. Básicamente es similar al anterior. ObtenerNombre @au_id = '123' Código fuente 144 Parámetros por referencia Si ejecutamos las anteriores sentencias. Nótese como la forma de asignar un valor a un atributo es mediante una sentencia SELECT. La solución para este caso es utilizar la palabra reservada OUTPUT para los argumentos de salida. como resultado de la ejecución del procedimiento?. Si por ejemplo. A continuación devolvemos en el parámetro @autores el valor obtenido. utilizando @@ROWCOUNT. y a continuación proporcionamos los parámetros. CREATE SELECT SELECT SELECT SELECT RETURN PROCEDURE num_autores_libros @autores int OUTPUT. Detrás de la palabra reservada PROCEDURE damos el nombre del procedimiento almacenado. realizando un SELECT * FROM Authors. @libros int OUTPUT AS * FROM Authors @autores = @@ROWCOUNT * FROM Titles @libros = @@ROWCOUNT (0) Código fuente 145 Vamos a estudiar el anterior ejemplo. La función @@ROWCOUNT devuelve el número de filas que se han seleccionado. ObtenerNombre '123' Código fuente 143 • Pasando los argumentos nombrados. En este caso no hace falta que los parámetros vayan en el mismo orden. junto con su tipo (que en este caso es entero). Es equivalente a la sentencia que aparece en el Código fuente 146 170 . Acto seguido se realiza lo mismo para la tabla titles. obtendremos el resultado directamente en la ventana que tengamos abierta en SQL Server. en cuyo caso especificamos la palabra reservada OUTPUT a continuación. Tras la palabra reservada AS se codifica el cuerpo del procedimiento.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Las llamadas a procedimientos almacenados se pueden realizar de las siguientes formas: • Pasando los argumentos en el mismo orden que en el que se han declarado. crearemos el procedimiento almacenado que muestra el Código fuente 145. Primero contamos todas las filas de la tabla authors. Pero ¿que pasa si queremos obtener un parámetro de salida. queremos obtener el número de autores y el número de libros que tenemos en la base de datos. igualando el parámetro al valor.

La sintaxis para declarar una variable es utilizar la palabra reservada DECLARE. especificando si son de retorno. La sintaxis es utilizar la palabra reservada EXEC. seguido del nombre de la variable y el tipo. seguida del nombre del procedimiento.© Grupo EIDOS 19. Procedimientos almacenados y triggers SELECT COUNT(*) FROM Authors Código fuente 146 El Código fuente 146. SELECT autores = @num_autores. y los parámetros. Declarar las variables que vamos a utilizar para llamar al procedimiento. EXEC num_autores_libros @num_autores OUTPUT. @num_libros OUTPUT Código fuente 149 3. obtendremos como resultado el siguiente listado: autores libros ----------------------------23 18 (1 row(s) affected) 171 . separados por comas. DECLARE @num_autores int DECLARE @num_libros int Código fuente 148 2. Ejecutar el procedimiento. @libros int OUTPUT AS @autores = (SELECT COUNT(*) FROM Authors) @libros = (SELECT COUNT(*) FROM Authors) (0) Código fuente 147 Para ejecutar el anterior procedimiento. CREATE SELECT SELECT RETURN PROCEDURE num_autores_libros @autores int OUTPUT. Mostrar los resultados. por lo tanto. libros = @num_libros Código fuente 150 Tras ejecutar las anteriores sentencias. se podría sustituir por Código fuente 147. seguiremos los siguientes pasos: 1.

Por ejemplo. Figura 92 Así.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Si queremos borrar un procedimiento almacenado. Por ejemplo. 172 . podemos elaborar una consulta SELECT sobre la tabla de sistema que contiene los usuarios conectados. obtendremos una lista con todos los usuarios conectados. cada uno con su propio objetivo o fin. es decir. como podemos observar en la Figura 92. seguido del nombre del procedimiento. disponemos de otro procedimiento almacenado denominado sp_tables. Del mismo modo. si escribimos sp_who. creado en el anterior ejemplo. Si queremos obtener una lista con todas las tablas del sistema. escribiremos el Código fuente 151 DROP PROCEDURE num_autores_libros Código fuente 151 Procedimientos almacenados de sistema SQL Server nos ofrece una serie de procedimientos almacenados ya implementados. deberemos ejecutar sp_columns seguido del nombre de la tabla. ejecutaremos la sentencia DROP PROCEDURE. si queremos borrar el procedimiento almacenado. si deseamos conocer todos los atributos de una tabla. o ejecutar el procedimiento almacenado sp_who. si deseamos saber los usuarios conectados a nuestro sistema. listos para ejecutar.

© Grupo EIDOS

19. Procedimientos almacenados y triggers

Por ejemplo, para listar los atributos de la tabla authors ejecutamos sp_columns authors, y obtenemos el resultado de la Figura 93 Existe una gran variedad de procedimientos almacenados, como por ejemplo para crear dispositivos, para comprobar el espacio usado por una tabla, etc. Aquí sólo hemos visto dos ejemplos de aplicación.

Figura 93

Extended stored procedures
Una de las principales ventajas que ofrece SQL Server es que permite la ejecución de procedimientos almacenados escritos en otro lenguaje de programación, como por ejemplo C, aprovechando de este modo toda la potencia que ofrece un compilador de este estilo. De todos es conocida la potencia que ofrece el lenguaje C, ya que es un compilador a bajo nivel. Esto es, permite interaccionar con el hardware, obtener datos del Sistema Operativo, etc. La técnica que permite el aprovechamiento de un lenguaje externo a SQL Server, para el diseño de procedimientos almacenados se denomina Extended Stored Procedures. Este es un caso un poco más complicado que el manejo de procedimientos almacenados intrínsecos al propio SQL Server. Los Extended Stored Procedures se implementan como DLLs, que serán privadas a SQL Server, y cuya gestión del espacio de memoria corresponde a éste. Una DLL (Dinamic Link Library) es un conjunto de funciones, que se cargan dinámicamente en memoria, esto es, se cargan en memoria cuando vayan a ser usadas, y se descargan cuando no se necesiten. Si por ejemplo, uno de estos procedimientos intenta acceder a una dirección que cae fuera del espacio de

173

Bases de datos con SQL Server 2000 – Transact SQL

© Grupo EIDOS

direcciones permitido, SQL Server atrapa la excepción, mata la tarea, y libera los bloqueos, continuando normalmente con su trabajo. Para registrar una Extended Stored Procedure, el administrador del sistema deberá ejecutar la sentencia en Transact SQL que aparece en el Código fuente 152.

sp_addextendedproc nombre_función, nombre_DLL Código fuente 152

Para ejecutar una de estas funciones en una base de datos distinta de aquella en la que se ha registrado, se deberá preceder el nombre de la base de datos al nombre de la función. Hay que destacar que estos procedimientos únicamente podrán ser ejecutados y registrados por el administrador del sistema. Si éste desea permitir la ejecución a los demás usuarios, deberá ejecutar el Código fuente 153.

GRANT EXEC ON procedimiento TO PUBLIC Código fuente 153

Esta sentencia SQL otorga (GRANT) privilegios de ejecución (EXEC) sobre el procedimiento especificado, a todos los usuarios de la base de datos. Si sólo deseamos otorgar este privilegio a un usuario, deberemos especificar su identificador de usuario tras TO.

Triggers
Los disparadores de procedimiento, más comúnmente conocidos como triggers, son una especie de procedimientos almacenados, a diferencia que se ejecutan cuando ocurre un evento sobre alguna tabla. Entendemos por evento, cualquier acción del tipo: • • • Inserción Borrado Actualización

La sintaxis de la sentencia de creación de triggers es la siguiente: CREATE TRIGGER nombre ON tabla FOR accion AS codigo donde acción especifica el evento que debe ocurrir para que se dispare el trigger, y que puede ser: • • •
174

UPDATE: actualización. INSERT: inserción. DELETE: borrado.

© Grupo EIDOS

19. Procedimientos almacenados y triggers

Por ejemplo, si queremos crear un trigger llamado modificación_autor, sobre la tabla Authors, que muestre un mensaje cada vez que se actualiza una fila de la tabla, deberemos escribir el Código fuente 154.

CREATE TRIGGER modificacion_autor ON authors FOR UPDATE AS print "Han actualizado la tabla de autores" Código fuente 154

Para comprobar el funcionamiento de este trigger, podemos actualizar cualquier fila de la tabla de autores, por ejemplo con la sentencia que aparece en el Código fuente 155.

UPDATE authors SET au_fname

= 'Miguel' WHERE au_id = '267-41-2394' Código fuente 155

Con esto conseguimos dos cosas, actualizar el nombre del autor cuyo código es el especificado a Miguel, y obtener el mensaje que se muestra como ejecución del trigger de actualización. Sin embargo, los triggers en SQL Server tienen una serie de limitaciones: 1. No se puede disparar un trigger dentro de otro trigger, ya que daría lugar a un bucle infinito 2. Por esta razón, un trigger no puede ejecutar instrucciones DDL (lenguaje de definición de datos) 3. No se pueden ejecutar sentencias como SELECT INTO o de creación de dispositivos dentro de un trigger Del mismo modo, para borrar un trigger, deberemos ejecutar la sentencia DROP TRIGGER trigger. Por ejemplo, si queremos borrar el trigger anteriormente creado, ejecutaremos el Código fuente 156

DROP TRIGGER modificacion_autor Código fuente 156

175

La sentencia IF . que permite al usuario que los usa abstraerse de la complejidad interna que puede encerrar. ELSE Esta sentencia permite evaluar una expresión y provocar la entrada o ejecución de un bloque u otro.Ejemplos prácticos de uso de procedimientos almacenados Introducción Los procedimientos almacenados es una de las principales funcionalidades que ofrece SQL-Server. en cuyo caso la condición es verdadera. pueden ser llamados desde otras aplicaciones. Por ejemplo. y se ejecutará el insert.. dependiendo de que la condición sea verdadera o falsa. siendo el servidor el encargado de realizar las operaciones. descargando de trabajo al cliente. . Los procedimientos almacenados suelen utilizar sentencias de diverso tipo de T_SQL. como pueden ser las de control de flujo. que veremos en detalle mediante algunos ejemplos prácticos. las de iteración. Para ello se comprueba que el número de filas que devuelve el select sea cero. con los parámetros adecuados... etc. El Código fuente 157 muestra un procedimiento almacenado encargado de insertar un nuevo tipo de transporte si no está dado de alta en la base de datos.

para comprobar como funciona. Podemos hacerlo un poco más elegante.. 'Metro' exec sp_Insertar_TipoTransporte 4. Para ello ejecutamos el Código fuente 158. exec sp_Insertar_TipoTransporte 1. Para ejecutar ahora el procedimiento. sólo se ha insertado el último registro. y es que se ha encerrado entre las palabras begin. y devolver un parámetro que nos indique si ha habido error o no. cuyo tipo debe coincidir con el tipo del parámetro de salida declarado en el procedimiento. @TT_Nombre varchar(40). @TT_Nombre) end else set @error = 'S' Código fuente 160 Podemos observar una novedad. además del uso de la sentencia set para asignar un valor a un parámetro o variable.. y ‘N’ si se ha insertado el registro con éxito. que devolverá ‘S’ si se ha producido error. necesitamos un parámetro más de llamada. ejecutamos el siguiente código. CREATE PROCEDURE sp_Insertar_TipoTransporte @TT_ID int. y otro que no exista. SELECT * FROM TipoTransporte Código fuente 159 Y como podemos comprobar.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS CREATE PROCEDURE sp_Insertar_TipoTransporte @TT_ID int. @error char(1) output AS if (select count(*) from TipoTransporte where TT_ID = @TT_ID) = 0 begin set @error = 'N' insert into TipoTransporte values (@TT_ID. 'Tranvía' Código fuente 158 Para comprobar lo que ha ocurrido en la tabla de tipos de transporte. @TT_Nombre varchar(40) AS if (select count(*) from TipoTransporte where TT_ID = @TT_ID) = 0 insert into TipoTransporte values (@TT_ID. @TT_Nombre) Código fuente 157 Probemos a insertar un tipo de transporte que exista.end el bloque que deseamos se ejecute cuando se cumple la condición. 178 .

Si dicho atributo es nulo. declare @error char(1) exec sp_Insertar_TipoTransporte 5. querrá decir. al ser un inner join. si ejecutamos este otro código. efectivamente.. con el fin de mostrar un mensaje determinado. para obtener el identificador de la provincia que coincide con el nombre que se pasa como parámetro. Ejecutemos el procedimiento para comprobar si existen comerciales para la provincia de Barcelona. 'Metro'. @error output select @error Código fuente 162 Otro ejemplo nos muestra como comprobar si existen filas para un parámetro determinado. se devuelve una ‘S’. Ejemplos prácticos de uso de procedimientos almacenados declare @error char(1) exec sp_Insertar_TipoTransporte 1. 179 . utilizando case. Por ejemplo.© Grupo EIDOS 20...Prv_ID and Provincia.else es la sentencia case. Sin embargo.. se devolverá una ‘N’. lo que indica que se ha producido un error.else. 'Aeropuerto'.Prv_Nombre = @Prv) > 0 print 'Hay comerciales asociados a la provincia de ' + @Prv else print 'No hay comerciales asociados a la provincia de ' + @Prv Código fuente 163 En este código podemos comprobar como se obtiene el número de registros de un inner join. al no existir todavía en la base de datos. @error output select @error Código fuente 161 Al ejecutar este código. muy útil sobre todo cuando tenemos muchos if anidados. mostramos el parámetro de salida y vemos como. el código expuesto antes utilizando if. lo que indica que el registro se ha insertado correctamente. equivaldría al siguiente. CREATE PROCEDURE sp_Hay_Comerciales @Prv varchar(40) AS if (select count(*) from Provincia inner join Comercial on Comercial. exec sp_Hay_Comerciales 'Barcelona' Código fuente 164 La sentencia CASE Una variante a la instrucción if. o bien no existe ningún comercial asociado a ella. que o bien no existe la provincia.Prv_ID = Provincia.

cuyos valores no conocemos a priori.La variable condicion almacena la claúsula where y la variable join los join declare @condicion varchar(255) declare @join varchar(255) set @condicion = '' set @join = '' -.Si se ha especificado la variable @Prv. mientras que si especifica el código postal. uno es la provincia y otro es el código postal.Si se ha especificado el cod postal. la instrucción exec se utiliza para ejecutar un procedimiento almacenado. por este atributo. sino que además sirve para evaluar una expresión de tipo carácter. además. @CP varchar(5) AS -.Prv_ID = Cliente. Recibe dos parámetros.Prv_ID = Provincia. concatenar la condición if not @CP is null begin if @condicion <> '' set @condicion = @condicion + ' and ' 180 . pero no sólo eso.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS CREATE PROCEDURE sp_Hay_Comerciales2 @Prv varchar(40) AS select case (select count(*) from Provincia inner join Comercial on Comercial. el siguiente código muestra como ejecutar un select de todas las provincias. se realizará una búsqueda de todos los clientes que sean de esta provincia. El siguiente código mostraría un procedimiento almacenado que se encarga de realizar búsquedas de clientes. Por ejemplo.Prv_Nombre = ' + '''' + @Prv + '''' set @join = ' inner join Provincia on Provincia. Exec (‘select * from Provincia’) Código fuente 166 Esto puede resultar muy útil para montar sentencias en tiempo de ejecución.Prv_Nombre = @Prv) when 0 then 'No hay comerciales asociados a la provincia de ' + @Prv else 'Hay comerciales asociados a la provincia de ' + @Prv end Código fuente 165 Ejecución dinámica de sentencias: la instrucción EXEC Como hemos visto. Si se especifica únicamente la provincia. se realizará una búsqueda.Prv_ID' end -. CREATE PROCEDURE sp_Clientes @Prv varchar(40). o para los cuales deseamos realizar un tratamiento distinto dependiendo de los valores que tomen. montar la condicion y el join if not @Prv is null begin set @condicion = ' Provincia.Prv_ID and Provincia.

null Código fuente 168 Si especificamos el parámetro provincia = Madrid. en el caso de que se especifique como parámetro el nombre de la provincia. y otra almacenará el join que se deberá realizar con la tabla de provincia. para evaluar la expresión resultante. 28023 Código fuente 170 Conversión de tipos Muchas veces nos encontraremos la necesidad de convertir un valor de un tipo a otro tipo para operar con él. Cast (expresion as tipo) y la de convert. se ejecuta la sentencia exec. Dichas instrucciones son cast y convert. Convert (tipo. La sintaxis de la expresión cast es la siguiente. obtendremos todos los clientes de la provincia de Madrid exec sp_Clientes ‘Madrid’. una almacenará la condición. dependiendo de los parámetros que se indiquen. que se ira concatenando. expresion) 181 . Ejemplos prácticos de uso de procedimientos almacenados set @condicion = @condicion + ' Cli_CodPostal = ' + '''' + @CP + '''' end if @condicion <> ‘’ set @condicion = ‘ where ‘ + @condicion exec ('select * from cliente ' + @join + @condicion) Código fuente 167 Manejamos dos variables. exec sp_Clientes 'Madrid'. obtendremos lo siguiente.© Grupo EIDOS 20. Es entonces cuando intervienen dos instrucciones que nos permiten realizar esto. Una vez montadas estas cadenas. sin especificar ninguno de los parámetros. null Código fuente 169 Si además especificamos el parámetro codigo postal. Si ejecutamos el anterior procedimiento almacenado. obtendremos todos los clientes exec sp_Clientes null.

Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Por ejemplo. En el siguiente ejemplo. mientras que la claúsula continue. CREATE PROCEDURE sp_ActualizaComercial AS WHILE (SELECT Com_Categoria FROM Comercial) <> '6' BEGIN UPDATE Comercial SET Com_Categoria = cast(Com_Categoria as int) * 2 IF (SELECT MAX(Com_Categoria) FROM Comercial) > 6 BREAK ELSE CONTINUE END Código fuente 173 182 . se recorre los comerciales. Cast (‘01/01/01’ as datetime) Código fuente 171 O un carácter a entero cast (‘3’ as int) Código fuente 172 La sentencia WHILE La instrucción while permite iterar un numero de veces que no conocemos a priori. que también es optativa. indica al bucle que se reinicie. y va duplicando la misma. Su sintaxis es la siguiente. mientras que la categoría sea distinta de 6. podemos utilizarlo para convertir un tipo de datos carácter a fecha. hasta que deje de cumplirse la condición boleana. WHILE expresion sentencias [BREAK] [CONTINUE] La claúsula break es optativa y indica al bucle que deje de ejecutarse. hasta que alguno supera el valor de 6.

sino que simplemente se ejecuta para cambiar o comprobar los datos que se van a insertar. se ejecutarían las sentencias definidas para el trigger en concreto de esa tabla específica. si por ejemplo se ejecuta una inserción. Por ejemplo. El bloque de sentencias permite prácticamente cualquier tipo de ellas dentro del lenguaje T-SQL. . Recordamos cual es su sintaxis: CREATE TRIGGER nombre ON tabla FOR [DELETE | INSERT | UPDATE] AS sentencias Las palabras reservadas DELETE. no se podrá utilizar la sentencia select.Triggers en SQL-Server 2000 Introducción Como ya se ha comentado. actualizar o borrar. o un borrado de una tabla. Así. pero con ciertas limitaciones. que se ejecutan cuando ocurre una acción dentro de la base de datos. los triggers o desencadenadores son una especie de procedimientos almacenados. INSERT y UPDATE corresponden a cada una de las acciones para las cuales se puede definir un desencadenador dentro de la tabla especificada. ya que un trigger no puede devolver datos al usuario. una actualización.

Si se supera el nivel de anidamiento permitido. si queremos recuperar los datos de la tabla que estamos borrando. se provoca la llamada de este último que. Desencadenadores recursivos: se permite la recursividad entre las llamadas a los triggers. Así. volverá a su estado previamente definido una vez concluya la ejecución del mismo 184 . es decir. y que contiene. se ejecutarán ambos triggers cuando ocurra dicho evento sobre la tabla. podemos hacer referencia a un par de tablas lógicas. y así sucesivamente. se cancelará la ejecución de los triggers. puede hacer referencia a objetos que se encuentran fuera de la misma La misma acción del desencadenador puede utilizarse para definir más de un trigger sobre la misma tabla La opción SET elegida dentro de la ejecución de un desencadenador. bien de forma directa. es decir. por ejemplo. entre los cuales cabe destacar los siguientes: • Desencadenadores múltiples: para una misma tabla. un trigger puede llamar a su vez a otro. cuya estructura es similar a la tabla donde se esta ejecutando el trigger. puede provocar la ejecución de otro trigger.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Las tablas deleted e inserted Dentro de la definición de un trigger. • • Limitaciones de los triggers Aunque ya se han comentado algunas de las limitaciones a la hora de programar triggers. dentro del trigger. los datos que van a ser añadidos o borrados. si definimos un trigger para insert. Desencadenadores anidados: si un trigger cambia una tabla en la que se encuentra definido otro trigger. se pueden definir distintos triggers para la misma acción. se deberá ejecutar el siguiente código: SELECT * FROM deleted Código fuente 174 Tipos de desencadenadores SQL-Server permite la definición de varios tipos de triggers. veamos en detalle las restricciones que implica la definición de triggers: • • • • Un trigger sólo se puede aplicar a una tabla Aunque un trigger se defina dentro una sola base de datos. si a su vez vuelve a modificar otra tabla. y resulta que dicha tabla ya tenía definido un trigger para esa misma acción. La utilidad de estas dos tablas es la de realizar comprobaciones entre los datos antiguos y los nuevos. precisamente. bien de forma indirecta. es decir. es una copia de la tabla en la cual se van a insertar o borrar los datos.

© Grupo EIDOS 21. UPDATE. no se permite la utilización de las sentencias del DDL dentro de la definición de un trigger En una vista no se puede utilizar un desencadenador Resolución diferida de nombres La resolución diferida de nombres es una utilidad que permite escribir triggers que hagan referencia a tablas que no existen en el momento de la compilación.au_id = x. CREATE TRIGGER trigger1 on authors FOR INSERT.au_id GO Código fuente 175 Ejemplos Veamos a continuación algunos ejemplos que complementen lo visto hasta ahora. como se muestra en el siguiente código. El siguiente código. si queremos que se envíe el mensaje cada vez que se cambia algo en la tabla de ofertas.. 'Tenemos una nueva oferta en nuestra base de datos.au_fname. el siguiente código hace referencia a una tabla x. DELETE AS SELECT a. DROP TRIGGER enviar_correo GO CREATE TRIGGER enviar_correo ON Oferta FOR INSERT.. CREATE TRIGGER enviar_correo ON Oferta FOR INSERT AS EXEC master.' GO Código fuente 176 Sin embargo. x. UPDATE. 185 . deberemos reescribir el trigger para las acciones update y delete.info FROM authors a INNER JOIN x ON a.xp_sendmail 'Pepe'. que no existe en el momento de escribir el trigger.au_lname. muestra la forma de enviar un mensaje de correo electrónico a una persona.xp_sendmail 'Pepe'. Triggers en SQL – Server 2000 • • Así mismo. cuando se añade una nueva oferta. a. Por ejemplo. DELETE AS EXEC master.

186 . CREATE TRIGGER empleado_modificar ON employee FOR INSERT. @emp_lvl tinyint. y job_id que almacena el identificador del trabajo que se va a actualizar. Ahora se comprueba si el trabajo que estamos asignando es el 1. 1) ROLLBACK TRANSACTION END ELSE IF NOT (@emp_lvl BETWEEN @min_lvl AND @max_lvl) BEGIN RAISERROR ('El nivel para el trabajo:%d debe estar entre %d y %d. que almacenará el nivel para el empleado. 1. se muestra como crear un trigger que.job_id FROM employee e INNER JOIN inserted i ON e. @max_lvl = max_lvl.emp_id JOIN jobs j ON j. A continuación realizamos un join entre la tabla de empleados y la tabla inserted o. se lanza un error con la sentencia RAISERROR. en caso de que sea verdadero.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS 'La tabla de ofertas ha cambiado' GO Código fuente 177 En el Código fuente 178. @max_lvl tinyint. @min_lvl.job_id IF (@job_id = 1) and (@emp_lvl <> 10) BEGIN RAISERROR ('Debe especificar el nivel 10 para el trabajo 1'. @job_id = i. utilizando la tabla inserted para comprobar los valores que se van a añadir o modificar.emp_id = i. Todo esto sirve para encontrar los valores de la tabla de trabajos que corresponden al trabajo que vamos a asignar al empleado.job_lvl. emp_lvl. y se cancela la transacción con ROLLBACK TRANSACTION. posibilite la cancelación de la acción. @max_lvl) ROLLBACK TRANSACTION END Código fuente 178 Primero declaramos las variables min_lvl y max_lvl. @emp_lvl = i. entre la tabla de empleados tal y como está antes de ejecutar el trigger. lo que es lo mismo. 16. UPDATE AS /* Obtener el nivel para el trabajo actual */ DECLARE @min_lvl tinyint.'.job_id = i. @job_id. y a continuación con la tabla de trabajos. 16. Para ello comprobamos esta situación mediante un if y. entre la antigua y la nueva). y la tabla de empleados tal y como quedaría después de ejecutarlo (en otras palabras. que almacenarán los valores mínimo y máximo permitidos para un trabajo. si el nivel del trabajo no está dentro de los valores permitidos. @job_id smallint SELECT @min_lvl = min_lvl. en cuyo caso el valor para el nivel debería ser 10.

que cada %d que aparece dentro de la cadena de texto será sustituido respectivamente por el valor de cada una de las tres últimas variables que aparecen dentro de dicha sentencia. 187 . Para los desconocedores del lenguaje C.© Grupo EIDOS 21. simplemente. quizá la última sentencia RAISERROR no les sea demasiado clara. Destacar. Triggers en SQL – Server 2000 En otro caso se comprueba que el nivel de la tarea esté dentro de los límites permitidos para el empleado. Si esto no se cumple se volverá a lanzar un error. y se cancelará la transacción.

.

en el que la principal división se establece entre el administrador del sistema y el resto de usuarios. debido a aspectos físicos.Seguridad Introducción El de la seguridad es un tema muy importante. • En este capítulo nos centraremos en la seguridad lógica. para la protección de la información. el borrado de una tabla. donde la amenaza de potenciales accesos indebidos es muy grande. sobre todo en entornos grandes. Podemos hablar de seguridad a dos niveles: • Seguridad física: entendemos por seguridad física aquella que persigue salvaguardar los datos de agresiones externas. mientras que un usuario corriente sólo podrá . mantenimientos de dispositivos duplicados con mirror. Seguridad lógica: la seguridad lógica afecta a la protección de los datos de accesos u operaciones no deseados. etc. como por ejemplo un incendio o una inundación. Concesión de privilegios SQL Server mantiene un sistema de perfiles. y puede realizar "casi" cualquier operación. una consulta a información no autorizada por parte de un usuario. como por ejemplo. o parte de sus atributos. El administrador del sistema actúa al nivel de superusuario. como por ejemplo la destrucción de la base de datos. ya que la seguridad física afecta a aspectos de administración (copias de seguridad.) que escapan a los objetivos del presente curso. etc.

o a los objetos que le permita el administrador u otro usuario. No sólo se pueden conceder permisos en el ámbito de tabla. GRANT ALL TO PUBLIC Código fuente 180 Cuidado con esta sentencia ya que es muy peligroso dejar que cualquier usuario haga lo que quiera. deberemos escribir lo que indica el Código fuente 181.. este control corresponde al administrador del sistema. los permisos pueden ser propagados en cascada. borrado. CREATE TABLE TO Pepe Código fuente 179 Si queremos otorgar todos los permisos a todos los usuarios. De todas maneras. si otro usuario desea acceder a dicho objeto. para que éste a su vez pueda dar permiso a otros. que normalmente suele ser el superusuario.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS realizar operaciones que afecten a sus objetos. si queremos otorgar el permiso de crear bases de datos y tablas al usuario Pepe. en lugar de sobre las acciones. En este caso. GRANT SELECT ON authors TO PUBLIC Código fuente 181 190 . La sentencia que permite otorgar privilegios es la siguiente: GRANT sentencia TO usuarios Por ejemplo. bases de datos. Los objetos de SQL Server (tablas. a menos que el propietario o el administrador le dé permiso.) tienen un propietario. deberemos escribir la sentencia que muestra Código fuente 179 GRANT CREATE DATABASE. un usuario puede dar permiso a otro usuario. Del mismo modo. o el usuario que lo haya creado. . deberemos escribir la sentencia que aparece en el Código fuente 180. En principio. actualización) sobre una serie de atributos de una tabla. Del mismo modo se pueden establecer privilegios sobre los objetos. Por ejemplo. Los permisos se pueden establecer en el ámbito de un usuario (conceder un privilegio a un usuario) o en el ámbito de grupo o público (accesible por todos). esto es. sino también en el ámbito de vista. o procedimientos almacenados.. la sintaxis es la mostrada GRANT permisos (columnas) ON tabla TO usuario La sentencia GRANT permite establecer los permisos deseados (inserción. a unos determinados usuarios. si deseamos que todos los usuarios puedan consultar la tabla de autores. no podrá hacerlo.

Con esta sentencia podemos quitar permisos a los usuarios sobre un objeto. y usuarios establece una lista de usuarios a los cuales se les aplicará dicha sentencia. Para revocar todos los permisos. GRANT EXECUTE ON procedure TO usuario WITH GRANT OPTION Código fuente 184 Revocación de privilegios La sentencia homóloga a la concesión de privilegios es REVOKE. La sintaxis para quitar permisos sobre la ejecución de sentencias es la siguiente: REVOKE sentencia FROM usuarios donde sentencia especifica aquellas cuyos permisos se revocan. GRANT SELECT. debemos adjuntar la opción WITH GRANT OPTION. 191 . Por ejemplo. Por ejemplo. deberemos ejecutar el Código fuente 182. GRANT SELECT (au_lname) ON authors TO PUBLIC Código fuente 182 Y si deseamos que además de consultar se pueda actualizar. REVOKE CREATE DATABASE FROM alberto Código fuente 185 Estamos impidiendo al usuario alberto la posibilidad de crear bases de datos. deberemos especificar ALL como sentencia a aplicar. y que éste a su vez pueda conceder este privilegio a otros usuarios. si queremos conceder el privilegio de ejecución de un procedimiento almacenado a un usuario. UPDATE ON authors TO PUBLIC Código fuente 183 Si queremos propagar los privilegios. Seguridad Con esto lo que hacemos es conceder el permiso SELECT sobre la tabla Authors. Si queremos restringir el SELECT al campo au_lname.© Grupo EIDOS 22. debemos escribir la sentencia mostrada en el Código fuente 184. si ejecutamos el Código fuente 185. o para ejecutar ciertas sentencias. a todos los usuarios. la sentencia en cuestión es la que muestra el Código fuente 183.

sino también a todos los usuarios a los que éste a otorgado dicho permiso. REVOKE [GRANT OPTION FOR] permisos [(atributos)] ON tabla FROM usuarios [CASCADE] AS papel Código fuente 187 La opción GRANT OPTION FOR es opcional.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Así mismo. pudiendo restringirlos a una serie de atributos o a una o varias tablas. éstos conservarán los suyos. La opción CASCADE es opcional. REVOKE ALL FROM PUBLIC Código fuente 186 La sentencia para aplicar revocación de permisos a objetos aparece en el Código fuente 187. y permite revocar privilegios en cascada. escribimos lo que indica el Código fuente 188. REVOKE SELECT (au_lname. REVOKE SELECT (au_lname. deberemos establecer public en la lista de usuarios. ejecutaremos el Código fuente 190. el Código fuente 186 revoca todos los permisos a todos los usuarios. es decir. La opción permisos permite especificar los permisos que se revocarán. y permite revocar la propagación en cadena de permisos a usuarios. y a todos los que éstos concedieron permisos. au_fname) ON authors FROM Pepe CASCADE Código fuente 190 192 . au_fname) ON authors FROM Pepe Código fuente 189 Y si queremos revocar dicho permiso no sólo al usuario Pepe. REVOKE INSERT ON authors FROM Pepe Código fuente 188 Si no queremos que dicho usuario consulte los atributos au_lname y au_fname de dicha tabla. para que la sentencia tenga efecto para todos los usuarios de la base de datos. la opción papel permite eliminar la ambigüedad que se puede originar cuando un usuario pertenece a varios grupos. Por ejemplo. Por último. la sentencia a ejecutar aparece en el Código fuente 189. al usuario Pepe. pero no podrán autorizar a terceros. o tiene varios perfiles. es decir. a los usuarios especificados. si queremos revocar los permisos de inserción de filas en la tabla autores. Por ejemplo.

au_fname) ON authors TO conflictivo Código fuente 192 Mantenimiento de vistas Otro método para controlar la seguridad y el acceso indebido a los datos almacenados. Corresponde al administrador en este caso el estudio de las consultas que se pueden realizar con relación a los usuarios del sistema. no se le podrán conceder privilegios para la creación de bases de datos a dicho usuario. y no queremos que cree bases de datos. las vistas se corresponden con el esquema externo de la base de datos. bastará con revocarle el privilegio a hacerlo. Del mismo modo podemos actuar para denegarle el permiso de acceder a determinados campos de una tabla. Lo que permite es que dichos usuarios no obtengan privilegios. si queremos que un usuario no acceda a determinados datos. También se dijo que podía haber más de un esquema externo. mientras no se revoque dicha denegación. Si por ejemplo. por error. como por ejemplo a los atributos au_lname y au_fname de la tabla de autores. Una vista es un conjunto de información que es accesible por uno o varios usuarios. DENY SELECT (au_lname. y otorgar permisos sobre las vistas a éstos. Pues bien. la respuesta es fácil. lo recomendable es denegar el permiso a dicho usuario. La sintaxis del comando para la creación de vistas es la siguiente: 193 . consiste en mantener vistas de la base de datos. le daremos vistas que no consulten dicha información. DENY CREATE DATABASE TO conflictivo Código fuente 191 De esta manera. es decir la porción de la base de datos que es accesible a los usuarios. le concede dicho permiso. hasta que no se revoque dicha denegación. Como ya se vio en la parte anterior sobre diseño de bases de datos. tenemos un usuario de la base de datos un tanto conflictivo. lo que nos lleva a pensar que la base de datos puede mantener varias vistas a la vez. Pero el problema surge cuando el administrador del sistema se olvida de este detalle y. Puesto que una vista se puede contemplar como una consulta a una parte de la información. Seguridad Denegación de permisos Otra opción es la de denegar un permiso a uno o varios usuarios. Para evitar que esto suceda. La sintaxis para denegar permisos es la siguiente: DENY sentencia TO usuarios Y para objetos: DENY permisos [(atributos)] ON tabla TO usuarios [CASCADE] El funcionamiento es similar al ya visto en las anteriores sentencias. El lector se preguntará ¿por qué una vista impide realizar accesos indebidos?.© Grupo EIDOS 22.

es decir. si queremos crear una vista sobre el atributo au_lname de la tabla authors. ya que permite controlar mejor los usos indebidos de estas sentencias. deberá ejecutar la vista.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS CREATE VIEW vista [(atributos)] [WITH ENCRYPTION] AS sentencia [WITH CHECK OPTION] La opción WITH ENCRYTION permite encriptar. ya que permite establecer más fácilmente los niveles de seguridad. escribiendo la sentencia que muestra el Código fuente 194 SELECT * FROM autores Código fuente 194 Recomendaciones Por último. actualización y/o borrado de filas. de forma jerárquica incluso. existen una serie de recomendaciones. Establecer perfiles y grupos de usuarios. 194 . CREATE VIEW autores (au_lname) AS SELECT au_lname FROM authors Código fuente 193 Si un usuario quiere consultar ahora los autores de la base de datos. Usar triggers para evitar ciertas operaciones no deseadas. para de esta manera saber en todo momento quien está haciendo qué. Proporcionar a los usuarios procedimientos almacenados para la inserción. ocultar. mientras que la opción WITH CHECK OPTION permite hacer visibles las modificaciones realizadas tras la ejecución de la vista. el código de la vista. Por ejemplo. que todo administrador que se precie debe tener en cuenta a la hora de implementar la seguridad de una base de datos: • • • • Proporcionar un único identificador a cada usuario. escribimos el Código fuente 193.

tenemos las siguientes entidades: • • • ave: cod_ave. el nombre científico. así como si es un ave migratoria o no. la clase a la que pertenece y el tipo de árbol en el que anida. y en un árbol pueden anidar varias especies (N-M). Por consiguiente. para recopilar los conocimientos aprendidos a lo largo del curso. desc_region Las relaciones que tenemos son las siguientes: • • ave-árbol: un ave puede anidar en varios tipos de árboles. De cada clase de árbol. el tipo de hoja. clase. y la región de la cual es autóctono.Ejemplo práctico de implementación Introducción En este capítulo. árbol-región: un árbol puede ser autóctono de varias regiones. observaciones árbol: cod_arbol. nombre. estudiaremos un ejemplo. Se desea almacenar la información de cada una de las especies del país. nombre. tipo_hoja región: cod_region. . se desea conocer su nombre. El problema en sí es mantener una base de datos de ornitología (ciencia que estudia las aves). De cada especie se quiere conocer el nombre de la misma. migratoria. nom_cientifico. y en una región puede haber distintas clases de árboles (N-M).

cuya primera etapa es el paso a tablas. Figura 95 El siguiente paso en el diseño es realizar el diseño físico. Con esto. también engloba al diseño lógico específico. Para implementar el esquema en Transact SQL. a la que denominaremos ornitología. y las relaciones N-M generan también tabla. al usar un SGBD concreto para la implementación. seleccionándola de la lista desplegable que aparece en la parte superior derecha del Query Analizer.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Con la anterior información. utilizaremos el Query Analizer de SQL Server. con las claves de ambas entidades como atributos. Lenguaje de definición de datos Lo primero que haremos será crear la base de datos. Cada entidad genera una tabla. Destacar que lo que aquí entendemos por diseño físico. Lo que realizaremos es codificar las instrucciones necesarias en Transact SQL. nos conectamos a ella. ya que en nuestro caso no se aplicarán métodos de normalización o particionamiento. nos queda el esquema lógico que muestra la Figura 95. Figura 94 Una vez realizado el diseño conceptual. para obtener el esquema físico. para lo cual escribimos el Código fuente 195. 196 . CREATE DATABASE ornitologia Código fuente 195 Una vez creada la base de datos. con sus atributos. podemos obtener el diagrama entidad-relación que vemos en la Figura 94. el siguiente paso es realizar el diseño lógico.

se utilizará un campo bit. nombre varchar(30) NOT NULL.© Grupo EIDOS 23. Para especificar si un ave es migratoria o no. y arbol_region: CREATE TABLE ave_arbol ( cod_ave smallint NOT NULL. que son ave_arbol. CREATE TABLE ave ( cod_ave smallint NOT NULL. 197 . desc_region varchar(30) NOT NULL) Código fuente 198 Y por último las tablas que las relacionan. clase varchar(10). el siguiente paso es crear los índices para ellas. cod_region smallint NOT NULL) Código fuente 199 Una vez creadas las tablas. y que utilizará el campo cod_ave. es decir. cod_arbol smallint NOT NULL) CREATE TABLE arbol_region ( cod_arbol smallint NOT NULL. nombre varchar(30) NOT NULL. nom_cientifico varchar(30). Análogamente. Empezaremos por crear la tabla ave. CREATE TABLE arbol ( cod_arbol smallint NOT NULL. no se podrá insertar filas que no tengan valores nulos para dichos atributos. Empezaremos por crear un índice único que será la clave de la tabla ave. es decir. creamos la tabla arbol. un 0 para indicar que el ave no es migratoria. al que llamaremos clave. tipo_hoja varchar(10)) Código fuente 197 Seguimos con la tabla de regiones. y un 1 si lo es. CREATE TABLE region ( cod_region smallint NOT NULL. Ejemplo práctico de implementación A continuación crearemos las tablas obtenidas en el esquema lógico. migratoria bit) Código fuente 196 En la anterior sentencia cabe destacar que los atributos cod_ave y nombre han sido declarados como no nulos.

donde los índices de clave única serán por cod_arbol para la tabla arbol. de momento. es labor del administrador el decidir a quien y sobre que objetos otorga qué permisos. A continuación utilizaremos el Lenguaje de Manipulación de Datos para introducir información en el esquema. Empezaremos añadiendo los siguientes datos: • Tabla ave Cod_ave Nombre 1 2 Flamenco Pato salvaje Nom_cientifico Clase Zancuda Migratoria Observaciones Si Migran en grupo hacia lugares cálidos Palmípedo No 198 . Pero eso no es problema. por cod_arbol y cod_region para la tabla.cod_region) Código fuente 201 Oh.arbol_region. y por cod_ave y cod_arbol para la tabla ave_arbol: ALTER ALTER ALTER ALTER TABLE TABLE TABLE TABLE arbol ADD CONSTRAINT clave_ab PRIMARY KEY (cod_arbol) region ADD CONSTRAINT clave_re PRIMARY KEY (cod_region) ave_arbol ADD CONSTRAINT clave_aa PRIMARY KEY (cod_ave. Nosotros. mediante la sentencia ALTER. ya que podemos modificar cómodamente el esquema de dicha tabla. y para realizar algunas consultas. para definir el esquema.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS ALTER TABLE ave ADD CONSTRAINT clave_av PRIMARY KEY (cod_ave) Código fuente 200 Análogamente hacemos con las demás tablas. crearemos una vista para consultar todas las aves que son migratorias CREATE VIEW migratorias AS SELECT nombre FROM ave WHERE migratoria = 1 Código fuente 203 Lenguaje de manipulación de datos Hasta ahora hemos estado utilizando el Lenguaje de Definición de Datos. para introducir un nuevo campo. ALTER TABLE ave ADD observaciones text NULL Código fuente 202 Por último. !vaya!. nos hemos olvidado de definir un atributo para la tabla ave.cod_arbol) arbol_region ADD CONSTRAINT clave_ar PRIMARY KEY (cod_arbol. por cod_región para la tabla región.

migratoria. 'Migran en grupo hacia lugares cálidos') INSERT INTO ave (cod_ave. migratoria) VALUES (2. 'Golondrina'. (1. (4. observaciones) VALUES (3. nombre. 'Zancuda'. 'Perenne') tipo_hoja) tipo_hoja) tipo_hoja) tipo_hoja) Código fuente 205 199 . nombre. 'Perenne') INTO arbol (cod_arbol. 'Pato salvaje'. 'Encina'. 1. nombre.© Grupo EIDOS 23. nombre. nombre. nombre. 'Naranjo'. 'Golondrina común'. Ejemplo práctico de implementación 3 4 Mirlo Blanco Golondrina Golondrina común Tabla 33 Si Si Emite un sonido muy peculiar Famosas por los versos de Becquer INSERT INTO ave (cod_ave. 'Caduca') INTO arbol (cod_arbol. clase. 'Flamenco'. clase. 'Roble'. 1. migratoria. observaciones) VALUES (1. migratoria. nombre. (3. 'Caduca') INTO arbol (cod_arbol. (2. observaciones) VALUES (4. nom_cientifico. nombre. 'Palmipedo'. 1. 'Mirlo Blanco'. 'Emite un sonido muy peculiar') INSERT INTO ave (cod_ave. 0) INSERT INTO ave (cod_ave. 'Pino'. 'Famosas por los versos de Becquer') Código fuente 204 • Tabla árbol Cod_arbol Nombre Tipo_hoja 1 2 3 4 Encina Roble Naranjo Pino Caduca Perenne Caduca Perenne Tabla 34 INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INTO arbol (cod_arbol.

cod_region) (cod_arbol. 1) (cod_arbol. (2. cod_region) (cod_arbol. cod_region) Código fuente 207 200 . cod_region) (cod_arbol. sur y nor-noroeste y robles en la región centro. Lo que tenemos que hacer es dar de alta estas filas en la tabla arbol_region. naranjos en la región Levante. cod_region) (cod_arbol. (5. cod_region) (cod_arbol. 5) INTO arbol_region (1. 'Levante') desc_region) desc_region) desc_region) desc_region) desc_region) Código fuente 206 Supongamos ahora que nos dicen que puede haber pinos en las regiones centro. 'Sur') INTO region (cod_region. 'Centro') INTO region (cod_region. con los valores correspondientes a cada código de arbol y región. 'Nor-noroeste') INTO region (cod_region. 4) INTO arbol_region (3. 1) INTO arbol_region (1. (4. cod_region) (cod_arbol. 1) INTO arbol_region (4. (3. 3) INTO arbol_region (4. encinas en las regiones centro. cod_region) (cod_arbol. 'Pirineos') INTO region (cod_region. (1.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS • Tabla región Cod_region Desc_region 1 2 3 4 5 Centro Sur Nor-noroeste Pirineos Levante Tabla 35 INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INTO region (cod_region. 3) INTO arbol_region (2. nor-noroeste y Pirineos. INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INSERT VALUES INTO arbol_region (4. 2) INTO arbol_region (1.

y que los patos salvajes anidan en los estanques donde preferentemente haya encinas. para obtener el código de los árboles cuya región es centro. Ejemplo práctico de implementación Supongamos ahora que nos dicen que el mirlo blanco anida en los naranjos y en los pinos. INSERT VALUES INSERT VALUES INTO ave_arbol (cod_ave. cuyo atributo migratoria tenga el valor true. Si ahora queremos obtener la descripción del árbol. primero se pone la condición de que la región debe ser centro. 1) Código fuente 208 Puesto que de momento no hemos encontrado ningún mirlo blanco. hacemos un join contra la tabla arbol_region. cod_arbol) VALUES (2. encina y roble.cod_region AND arbol_region. 201 .desc_region = 'centro' AND region. 3) INTO ave_arbol (cod_ave. UPDATE ave SET nombre = 'Mirlo común' WHERE nombre = 'Mirlo blanco' Código fuente 209 Supongamos ahora que queremos realizar las siguientes consultas. 4) INSERT INTO ave_arbol (cod_ave. Para ello. cuyas sentencias se especifican a continuación: • Todos los árboles de la región centro: SELECT nombre FROM arbol. • El número de aves que son migratorias. Para ello deberemos contar todas las filas de la tabla ave.cod_region = arbol_region. deberemos realizar otro join contra la tabla árbol. con la sentencia que aparece en el Código fuente 209. Para ello debemos actualizar la fila correspondiente.© Grupo EIDOS 23. arbol_region. Lo que hay que hacer es crear las filas correspondientes a cada uno de los códigos en la tabla ave_arbol. El resultado obtenido son los árboles pino. Con las filas obtenidas. cambiaremos este ave por el mirlo común. cod_arbol) (3. region WHERE region. cod_arbol) (3.cod_arbol Código fuente 210 Lo que hace la anterior sentencia es obtener el atributo desc_arbol de la tabla arbol.cod_arbol = arbol.

ave WHERE arbol. podemos aprovechar la vista anterior.tipo_hoja = 'caduca' AND arbol. obtenemos que dichas aves corresponden al mirlo blanco y al pato salvaje Si ahora queremos consultar todas las aves que son migratorias. SELECT * FROM migratorias Código fuente 213 202 . La anterior explicación se resume en la sentencia mostrada en el Código fuente 212. ave_arbol. • El nombre de las aves que anidan en árboles de hoja caduca ordenados alfabéticamente. deberemos realizar un join de las filas obtenidas.cod_ave = ave. para hacerlo ejecutamos el Código fuente 213. SELECT ave. con la tabla ave.cod_ave ORDER BY ave.cod_arbol = ave_arbol.nombre FROM arbol. para obtener así el código de las aves que anidan en dichos árboles. Acto seguido. si queremos obtener el nombre de las aves. Lo que debemos hacer es seleccionar primero todas las filas cuyo atributo tipo_hoja para luego hacer el join de estas filas con la tabla ave_arbol por el campo cod_arbol.cod_arbol AND ave_arbol. por el atributo cod_ave y proyectar sobre nombre.nombre Código fuente 212 Como resultado del Código fuente 212.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS SELECT count(*) FROM ave WHERE migratoria = 1 Código fuente 211 El resultado obtenido es el de 3 aves.

la evolución siguió otra rama alternativa. dieron lugar a uno nuevo. mediante referencias a los mismos..”. El modelo en red nació como una ampliación del modelo jerárquico. cuya simplicidad y potencia revolucionaron el mercado de las bases de datos. Sin embargo. Sería algo del estilo “empresa – empleado – empresa . Sin embargo. el relacional. A pesar de ello. dando lugar a las denominadas bases de datos orientadas a objetos. Las relaciones entre los objetos se establecían de una manera natural. sino grafos. lo cual dificulta ampliamente la definición y el manejo del esquema. era una especie de clasificación del modo “pais – comunidad – provincia – localidad” o “empresa – departamento – empleado”.. como consecuencia de una necesidad de simplificación de los primeros modelos que se usaron como base. Aunque fueron muchos los que apostaron por éstas. El primero nació como una conceptualización de la forma de entender las relaciones entre los objetos. que permitía navegar entre ellos para obtener la información que se necesitaba. la realidad es que en la actualidad su uso no supera el 5% de la cuota de mercado con respecto al modelo relacional.Presente y futuro de las bases de datos La evolución de las bases de datos en los últimos años. no ha sido sino hasta hace unos pocos años cuando este modelo vio la luz. el modelo relacional. en el cual ya no se tienen árboles. los primeros modelos que surgieron fueron el jerárquico y el modelo en red. . es decir. la evolución de estos modelos. ha permitido el afianzamiento de un modelo que se ha tomado como base de la práctica totalidad de los SGBD existentes en la actualidad. Como ya se ha comentado. Para que el lector lo comprenda mejor. una clasificación natural.

Por ejemplo. De esta forma se tienen relaciones en forma de tablas. Además. cabe imaginar. no paran de surgir nuevos estudios y propuestas de modelos que amplían los ya existentes. en un futuro no muy lejano. clientes.) información de una manera más útil. cuyos atributos pueden ser a su vez referencias a objetos. entre otras.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Debido a lo anterior. que tendría el método alta(). Tomando como base el relacional. 204 . y así un sinfín de posibilidades. ventas. permite una mejor gestión de los mismos. duplicidades e información irrelevante. joven. el concepto de data warehousing (en lo sucesivo DW) se refiere a la posibilidad de integrar toda esta información. Como el lector ya habrá podido comprobar. lo cual desbarata prácticamente todo el proceso de normalización. mediante herramientas específicas (OLAP. que implica una carga. con la peculiaridad que el acceso se realiza en varias dimensiones de una forma más eficaz (por ejemplo las ventas por proveedores en cada región). tediosa y difícil. une a éste la funcionalidad que ofrece la orientación a objetos. De esta forma se puede obtener. posibles clientes potenciales para una campaña comercial. que aparece dispersa en el ámbito del negocio. se pueden utilizar los denominados data marts. se necesitará un lenguaje especial para definir y manejar la información. Así nace el modelo objeto-relacional. como puede imaginar el lector. ROLAP. bases de datos fuzzy (o que manejan información imprecisa. y que se prevé tenga un mayor impacto si cabe. en estos modelos ni siquiera se cumple la 1FN. caro. es el data warehousing y el data mining. para su mejor gestión. Así por ejemplo. etc. podemos encontrar bases de datos espaciales (para manejo de información en tres dimensiones). que en un principio es gestionada desde ámbitos distintos. Surge entonces el SQL:1999 como lenguaje estándar para el acceso y definición de este tipo de esquemas. por ejemplo. por ejemplo. de tal manera que dicha información pueda ser utilizada más provechosamente. Sin embargo. proveedores. este proceso. es una tarea ardua. para obtener. se puede tener el atributo domicilio que se puede descomponer en calle. o personalizar el tipo de información que un cliente puede recibir. consiste en la navegación a través de los datos para inferir conocimiento mediante técnicas de Inteligencia Artificial. de una forma más eficaz y eficiente. Por ejemplo. una empresa que dispone de cantidades ingentes de información (empleados. para evitar incoherencias. que no aparece de manera explícita en el mismo. que se ejecutaría cada vez que se da de alta un nuevo domicilio. Una vez que se tiene el DW. y se resume en la Figura 96. provincia y localidad. Una de las técnicas más importantes de extracción de información es la denominada data minning o minería de datos (en lo sucesivo DM). En cambio. y que ya disponen de su propio lenguaje). Por data warehousing se entiende el almacenamiento masivo de los datos que gestiona una empresa. y puede no tener relación ninguna entre sí (cada departamento manejaría únicamente la información relevante al mismo). que debido al avance y mejora de los SGBD actuales. Pues bien. Como su propio nombre indica. que son una especie de vistas con la información que interesa obtener. Así por ejemplo. como por ejemplo alto. filtrado y proceso de los datos. lo que más expectación esta suscitando actualmente. Esta técnica es muy útil sobre todo en el ámbito del marketing y publicidad. que no se encuentra de manera explícita. se pueden aplicar procesos que permitan una obtención de información añadida. además de incorporar sus propios métodos. compras). Por otro lado. fueron muchos los que pensaron que no sería mala idea unir lo mejor de ambos modelos: el relacional y el orientado a objetos.

SQL Server 2000 ya nos permite adentrarnos es este mundo. Sin embargo. Figura 97 205 . debido a su elevado precio.© Grupo EIDOS 24. Presente y futuro de las bases de datos Figura 96 Ya existen en el mercado varios productos que soportan tanto el DW como el DM. pero que. ofreciéndonos diversas posibilidades de las ya mencionadas. hacen que todavía sea un mercado que no se encuentre al alcance de todo el mundo. pero que se espera crezca positivamente en un futuro no muy lejano. como resume la Figura 97.

.

se puede decir que Power Designor es una herramienta CASE para el diseño de bases de datos. mientras que el diseño físico comprende la definición de índices. Además nos permite pasar fácilmente del esquema conceptual. las relaciones entre éstas y su cardinalidad.Diseño conceptual con Power Designor Introducción Empezaremos dando respuesta a la pregunta "¿qué es Power Designor?". Power Designor abarca dos de las tres grandes etapas del diseño de un esquema relacional: 1. El diseño conceptual 2. Pues bien. con sólo conocer su esquema físico. y en general todos los aspectos relacionados con esta fase de diseño. los atributos y sus tipos. es decir. En nuestro caso. de forma clara y sencilla. evitándole tareas engorrosas. la redundancia controlada de datos. sino que también se ofrece la posibilidad de generar un script (trozo de código) que es capaz de crear el esquema físico para una plataforma y un SGBD concreto.. etc. las claves. Una herramienta CASE es aquella que permite al usuario la realización de unas determinadas tareas de forma fácil y precisa. Y no solo esto. Power Designor permite al usuario establecer el diseño de un esquema relacional. como el paso del diseño conceptual al físico. obtener el esquema conceptual de una base de datos. Los tipos de archivos manejables por Power Designor son dos: . etc. y realizar ingeniería inversa. El diseño físico El diseño conceptual permite establecer la definición de las tablas. al esquema físico.

y se deberá especificar si la entidad generará tabla en el esquema físico. AppModeler: para la modelación del esquema físico. o hacer doble click sobre dicha entidad. un código que representará de manera unívoca a la entidad. La pantalla que nos aparece se muestra en la Figura 99. Para ello tenemos dos formas: pulsar el botón de definición de entidades y hacer click izquierdo sobre la entidad. Figura 98 Para crear una nueva entidad. Comprende la etapa de diseño del ciclo de vida del software. y hacer click con el botón izquierdo del ratón en cualquier parte de la pantalla. es decir. Extensión PDM: contiene la definición del esquema físico (Physical Data Model) Power Designor se compone de cuatro módulos: • • • • Data Architect: se encarga de la definición de los esquemas conceptual y físico. MetaWorks: útil para el trabajo en red de varios diseñadores. Una vez que tengamos creada la entidad. En ella se deberá teclear el nombre que le demos a la entidad. es decir. Creación de una entidad Para entrar en la aplicación. Extensión CDM: contiene la definición del esquema conceptual (Conceptual Data Model) 2. las 208 . Es en el que nos centraremos. Acto seguido nos sale una pantalla en blanco. Pulsando el botón Rules se podrán definir las Bussiness Rules o Reglas de Negocio. etc. claves de la entidad. Para crear un nuevo esquema conceptual. ejecutar el módulo DataArchitect. atributos y tipos. es decir. su apariencia se muestra en la Figura 98. diagramas de flujo de datos. su nombre. se deberá pulsar el botón de creación de entidades. ProcessAnalist: para realizar el diseño de procesos.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS 1. acceder al menú File-New. Nos aparecerá una pantalla en blanco junto con una barra de herramientas. se deberán definir sus propiedades.

habrá que pulsar el botón New. Ej: la suma total de los pedidos realizados por un cliente.000 euros" o "un proveedor sólo puede atender a un cliente" son ejemplos de reglas de negocio. "Un cliente no puede pedir un crédito superior a 1..© Grupo EIDOS Apéndice A. Diseño conceptual con Power Designor restricciones que determinar el comportamiento de las entidades y/o sus relaciones. y el tipo de ésta. • La pantalla para la asignación de reglas de negocio a una entidad aparece en la Figura 100 Para añadir una regla.. Hecho: Describen los hechos o forma de funcionar de la empresa. Figura 99 Las reglas de negocio pueden ser de los siguientes tipos: • • • Validación: Especifican las restricciones que puede tener un valor en el esquema.. será preciso pulsar el botón List.. Si queremos introducir una nueva regla. Si todavía no se ha introducido ninguna. Ej: un cliente puede realizar uno o más pedidos. Definición: Especifican características o propiedades de un objeto en el sistema de información. Ej: un cliente es una persona identificada por su DNI y por su nombre. Pulsando el botón Define se visualizará la siguiente pantalla. en la 209 . bastará con pulsar el Botón Add. Fórmula: Definen los cálculos a realizar en el sistema de información. y nos aparecerá una lista con todas las reglas definidas. La pantalla que nos permite definir las reglas de negocio es la que se muestra en la Figura 101. para hacerlo. En este apartado también se definen las reglas de integridad referencial. especificar el nombre y el código de la regla. Ej: el crédito de un cliente no puede superar el 20% de su compra.

dependiendo del tipo de regla que hayamos escogido. lo que implica una ganancia de tiempo no tan drástica.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS que podremos teclear la descripción de la regla o la formula aplicable. sin duda. Figura 100 Figura 101 La principal ventaja de ejecutar una expresión en el servidor radica en la velocidad de ejecución de la misma. aunque la mayor desventaja es. 210 . Además se puede especificar si la expresión a evaluar se desea ejecutar en el cliente o en el servidor. la probabilidad de cargar al servidor con demasiado trabajo.

para lo cual pulsamos el botón Atributtes. Figura 103 211 . Pulsar el botón Add.. en la que podremos incluir nuevos atributos para dicha entidad.. cuyo aspecto se muestra en la siguiente figura. Para ello se dispone de dos opciones: 1. o 2.© Grupo EIDOS Apéndice A. lo cual permitirá seleccionar un atributo de entre los ya existentes en el sistema de información. Pulsar el botón New e introducir el nombre. Diseño conceptual con Power Designor Figura 102 Volvemos a la pantalla de definición de entidades para determinar los atributos de la entidad. Se mostrará entonces una nueva ventana. código y tipo de dato.

000 (para los móviles) y 999. En la lista desplegable etiquetada como Domain se puede seleccionar el dominio que se va asignar a ese atributo.999 (para los fijos). Ésta tiene un aspecto muy parecido al de todas las pantallas de definición vistas hasta ahora.. Power Designor nos permite escoger entre una amplia gama de tipos de datos. Dentro de esta pantalla también se puede especificar el dominio de un atributo. e introducir otro tipo de restricciones como son el caso de las mayúsculas o minúsculas en los caracteres. En la carpeta de Validation Rules (Figura 106). pulsando el botón . es decir. o como obligatorio (mandatory) en cuyo caso dicho campo deberá tener siempre un valor no nulo. En nuestro caso se ha optado por la expresión ofrecida por defecto. o no permitir la modificación del atributo. En el caso de que no tengamos definido ningún dominio todavía. En la carpeta de Standard Parameters es donde se especificará el rango que tomará el atributo. que variará entre 600. como la Figura 105. simplemente es un valor que no tiene valor (valga la redundancia). introduciéndolos en la lista de la derecha. es donde se permite la definición de restricciones mas especificas. código y tipo de dato de éste. Dichos atributos serán traducidos a los tipos específicos del SGBD con el que se vaya a trabajar (recordar que en la definición del esquema conceptual no se tiene por qué saber la implementación física que se va a realizar).. La utilidad de ambos es la de disponer de un editor que permite la introducción de textos explicatorios y/o aclaratorios. La segunda es el tipo de atributo.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS De esta pantalla cabe destacar dos cosas. Recuérdese que un valor nulo no es ni el cero ni el espacio en blanco. entidades y otros. también se puede introducir directamente la lista de valores que puede tomar. que permite establecer las principales características del dominio. La definición en si del dominio se establece al pulsar el botón Check en el que se mostrará una nueva pantalla.999. se deberá pulsar el botón New e introducir el nombre. es decir. En este caso se ha introducido un dominio para los números telefónicos. Se ha visto hasta ahora que en la mayoría de las pantallas aparecen dos botones (o carpetas) con los nombres Description y Annotation.. en las definiciones de atributos. ese atributo será clave para dicha entidad. se podrá acceder a la pantalla que permite hacerlo. el rango de valores que puede tomar. dejando al usuario la posibilidad de especificar su longitud y precisión.000. 212 . Una es la posibilidad de determinar un atributo como identificador (identifier). Figura 104 Para incluir un nuevo dominio.

Para crear una relación entre dos entidades pulsaremos el botón de relación entre entidades de la paleta de herramientas. Acto seguido haremos click derecho con el ratón en la entidad origen y.© Grupo EIDOS Apéndice A. Diseño conceptual con Power Designor Figura 105 Figura 106 Creación de relaciones Se hablará en este apartado de las relaciones entendidas como la "unión" o relación entre dos entidades. 213 .

lo moveremos hasta la entidad destino. cada ocurrencia de la entidad proveedor puede relacionarse con una (cardinalidad mínima) o varias (cardinalidad máxima) ocurrencias de la entidad cliente. En el sentido contrario. estamos diciendo que la cardinalidad máxima será uno. obteniendo algo parecido a la Figura 108.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS sin soltarlo. Figura 108 Es aquí donde se deberá establecer la cardinalidad máxima y mínima de la relación en ambos sentidos. La Figura 107 muestra la relación existente entre las entidades cliente y proveedor. Figura 107 Una vez definida la relación. podemos decir que un proveedor puede distribuir a uno o más clientes. un cliente sólo puede abastecerse de un proveedor. Para establecer la cardinalidad máxima. se dispone de unos botones de selección. bajo 214 . Nuevamente. se estará indicando que la cardinalidad máxima es muchos (o N). Para determinar la cardinalidad mínima. haremos doble click sobre la relación. para obtener el cuadro de diálogo de definición de propiedades. el siguiente paso es establecer la cardinalidad de la misma. Por ejemplo. mientras que si se selecciona la opción Many. Es decir. se dispone de otros botones de selección. Si escogemos la opción One. lo que implica cardinalidad mínima y máxima uno. bajo el nombre de Cardinality.

con los detalles de cada pedido. motocicleta con atributo cilindrada y bicicleta con atributo num_cambios. Nuevamente nos encontramos en esta ventana con el botón Rules. modelo. modelo. Pero si nos damos cuenta. Por ejemplo. modelo y precio. con atributos privados o específicos a cada una. precio y cilindrada y la entidad bicicleta con los atributos marca. De esta forma se tendrá una relación vehículo con los atributos marca. y la entidad linea_pedido. y a continuación pinchar en las demás relaciones llevándolas hasta el punto de unión. de las que heredarán las entidades automóvil con atributo num_puertas. modelo y precio. 215 . en el cual podremos establecer las reglas de negocio. Figura 109 Para establecer una relación de herencia. quiere decir que la cardinalidad mínima es cero. Como ya se estudio en anteriores temas. sin saber a que pedido corresponde. Si por ejemplo se tiene la entidad pedido con los pedidos realizados por un cliente. El ejemplo se representa como indica la Figura 109. precio y num_puertas. se deberá escoger en la paleta el botón relación de herencia. pinchar en la relación padre. una relación de este tipo indica que depende de otra relación para su identificación. Para indicar una relación de este tipo. las tres relaciones tienen tres atributos en común. podemos tener tres entidades: automóvil con los atributos marca. bastará con seleccionar la caja de selección denominada Is dependent.© Grupo EIDOS Apéndice A. Un tipo especial de relación es la relación de dependencia. Ni que decir tiene. modelo. Consiste en la propiedad que tienen algunas entidades de heredar el comportamiento de otras. ya que no se sabrá a que línea de pedido nos estamos refiriendo. además de disponer de otras dos carpetas para introducir cualquier descripción que se nos ocurra. marca. Podemos aprovechar esta ventaja para definir una relación de herencia. mientras que si se escoge la opción Mandatory se obliga a que la cardinalidad mínima será uno. suponiendo que estas son características básicas de cualquier vehículo. la entidad motocicleta con los atributos marca. precio y num_cambios. que estas relaciones. esta última entidad tiene una relación de dependencia con aquella. Si indicamos la opción Optional. heredan o importan los atributos de la entidad padre. La relación de herencia Otro tipo especial de relación es la relación de herencia. seleccionar una relación. Diseño conceptual con Power Designor el nombre Existence.

.

los tipos de datos del mismo.Diseño físico con Power Designor Paso del esquema conceptual al esquema físico Una vez realizado el diseño del esquema conceptual. En la carpeta Generation se nos sigue preguntando una serie de parámetros. permite especificar el nombre de los índices primarios y ajenos (campos que son clave en otras entidades) que se generarán para cada tabla. con extensión . Automáticamente aparece una pantalla. será preciso generar el esquema físico y cambiarlo según nuestras pretensiones y/o necesidades. En la segunda carpeta se nos da la opción de preservar ciertos cambios. sobre todo. para determinar las restricciones del SGBD. Por ejemplo. etc. pulsaremos el botón OK y. Una vez que estemos seguros de haber dado las opciones correctas. Cabe destacar que Power Designor no da la posibilidad de realizar la fase intermedia de diseño lógico. tras un breve período de tiempo nos aparecerá un mensaje con el resultado de la generación. Justo debajo se nos preguntará por el nombre del fichero en el que se guardará el modelo físico. las etiquetas. Por ejemplo. Para generar el esquema físico a partir del conceptual. como por ejemplo los gráficos.PDM. se puede seleccionar la opción de menú Dictionary . o las reglas de negocio. como la mostrada en la Figura 110. En la parte superior se especifica el SGBD específico sobre el cual se generará el esquema físico. Esto es importante. sino que ésta está divida entre las fases de diseño conceptual y diseño físico. También se puede decir si las reglas de actualización o de borrado se propagarán a todas las tablas o sólo a la que afecte. etc. si algo ha .Generate Physical Model o pulsar las teclas Ctrl-G. si queremos realizar un particionamiento vertical. el siguiente paso es obtener el esquema físico.

en otro caso tendremos el correspondiente esquema físico.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS fallado. se deberá revisar nuevamente el esquema conceptual. Figura 110 Modificación de las tablas Figura 111 218 .

podremos adecuarlo a nuestro gusto. es decir.). editor. de la velocidad del hardware. Recuérdese. etiquetas. para de esta forma. Columnas La edición de columnas consiste en borrar. A esta funcionalidad se accede pulsando el botón Extended. Diseño físico con Power Designor Una vez generado el esquema físico. sin 219 . de la concreción física de las entidades diseñadas en el esquema conceptual. y las restricciones del SGBD. etc. Figura 112 Indices La definición de los índices de una tabla es otra de las características del diseño físico ya estudiadas.. que estudiaremos a continuación en detalle. Otra funcionalidad que ofrece Power Designor es la definición de atributos extendidos. En este caso ya podemos hablar de tablas. ante el cual aparece la Figura 112. que permite la determinación de ciertas características correspondientes a los atributos de una tabla. el valor inicial o por defecto del mismo. comentarios que se mostrarán a la hora de visualizarlos. insertar y/o cambiar la definición uno o más atributos de las tablas. etc. como pueden ser la forma de visualización (lista desplegable. Podemos empezar modificando las características de las tablas. En ella podemos especificar varias características. apareciéndonos la Figura 111. para lo que será necesario hacer doble click sobre una de ellas. De esta manera será preciso realizar un estudio detallado de las consultas que se realizarán a la base de datos. teniendo en cuentas las necesidades del sistema. cabeceras. etc. del número de actualizaciones.© Grupo EIDOS Apéndice B. cuyo cometido es el aumento de eficiencia a la hora de realizar las consultas. conseguir una mayor eficiencia. La forma de hacerlo es similar a la pantalla mostrada en el anterior tema acerca de la definición de atributos. salvo que en esta se puede determinar un atributo como clave ajena (atributo que es clave en otra tabla).

Figura 113 Para definir un nuevo índice. sus campos no pueden tener valores duplicados. se pulsará el botón Add y se seleccionarán los atributos que se desean añadir. a la hora de realizar actualizaciones. y especificaremos su tipo. que son clave en otra tabla. Es el índice que se seguirá por defecto. usado para recorrer los cluster de una base de datos (se remite al lector al capítulo de diseño físico). que puede ser ascendente o descendente. Para acceder a la pantalla de definición de índices. Cluster: índice cluster. 220 .Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS embargo. Foreign key: es el índice que hace referencia a campos de la tabla. Unique: índice único. es preciso realizar un estudio detallado de las transacciones que se darán en la base de datos. Dicha pantalla tiene la apariencia de la Figura 113. Además se puede especificar la ordenación del índice. pulsaremos el botón New. Para añadir campos a un índice. En el botón Alternate Keys se pueden especificar claves alternativas o secundarias. es decir. la desventaja que supone el tener una tabla de índices demasiado extensa. se deberá pulsar el botón Indexes. teclearemos su nombre. que sirven para identificar una ocurrencia de una entidad en la base de datos. y define los atributos que son clave en la tabla. de entre los siguientes: • • • • Primary key: índice por clave primaria. Este es otro tipo de claves. Por lo tanto. además de las primarias.

Este código es dependiente del SGBD. y define la acción que tendrá lugar ante ciertos eventos. pero cuya finalidad es la misma: modificar el aspecto de visualización de estos atributos. La Figura 115 muestra un ejemplo de definición de trigger. Triggers Como su propio nombre indica. accesible mediante el botón Triggers. Diseño físico con Power Designor Atributos extendidos Como ya se ha visto. etc. nos podemos encontrar con otra pantalla. pulsando el botón Extended. como por ejemplo. Figura 114 Como se puede observar. es decir. pero nos permite establecer las fuentes (tipo de letra. En esta funcionalidad. los triggers son disparadores. se pueden determinar las acciones que tendrán lugar cuando ocurra un determinado evento. estilo. ni nada por el estilo. y cuyo aspecto es el mostrado en la Figura 114. Sin embargo.) con las cuales se mostrarán las tablas. permite la modificación de ciertas características de éstos. al insertar una tupla en la base de datos. totalmente distinta a la mostrada anteriormente. trozos de código que se ejecutan cuando ocurre un determinado evento. la funcionalidad que ofrece Power Designor sobre atributos extendidos. en ella no se pueden definir formas de visualización de los atributos. tamaño. 221 . ni valores iniciales.© Grupo EIDOS Apéndice B.

pulsando el botón con dicho nombre. y a continuación pincharemos en Para definir una vista en Power Designor. Es decir. pulsando el botón Query. Recuérdese la definición de vista recogida en el capítulo de introducción. se agrupa todo un conjunto de funciones que define el rango de valores que puede tomar un determinado atributo. No se ahondará más en este tema. y todas las reglas que debe verificar una tabla. pulsando el botón Tables. ya que ya se ha estudiado en el capítulo sobre diseño conceptual. 222 . y nos aparecerá una pantalla como la que aparece en la Figura 116. En ella podemos definir las tablas que implica. y cada una de ellas podrá ser accedida por uno o varios usuarios. pulsaremos el botón cualquier punto de la pantalla. Una vista permite la introducción de un nivel de seguridad. La query se podrá definir mediante el lenguaje SQL. y la query o consulta. bastará con hacer doble click sobre ella. simplemente se le ofrecerán vistas que no impliquen dicha tabla. Además se puede dar la opción de modificar el contenido de las tablas (opción Updatable) o simplemente consultar (opción Query Only). Si no queremos que un usuario acceda a una determinada tabla. una porción de la base de datos. Creación de vistas Se entiende por vista.Bases de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Figura 115 Restricciones Bajo el nombre restricción. Para editarla. accesible por un usuario. y cuyo comportamiento es similar en el diseño físico. y cuyo conjunto correspondía a la definición del nivel externo de la base de datos. que afecten a un determinado número de tablas. se definirán consultas.

© Grupo EIDOS Apéndice B. Diseño físico con Power Designor Figura 116 223 .

.

Cliente: de que se desea conocer su código de cliente. y creamos un nuevo modelo conceptual (. Para ello desea tener almacenados todos los pedidos. El funcionamiento de Enterprise SL es el siguiente. para realizar pedidos de forma automática. de cara al euro y al año 2000. cada vez que las existencias son inferiores a las 10 unidades de cada producto. ciudad y provincia. de cara a Hacienda. Por otra parte. dirección. Existen una serie de proveedores que abastecen a dicha empresa. Además desea conocer en todo momento la disponibilidad de productos en el almacén. nombre. A su vez. Enterprise SL es una empresa de venta al público. vamos a tratar de resolver un planteamiento utilizando esta herramienta. Para ello nos ha encargado que diseñemos una base de datos que permita la introducción y recuperación eficiente de datos. Lo primero realizar es un diseño del esquema conceptual. apellidos. quiere informatizar su sistema. NIF. provincia y teléfono. dirección. ciudad.CDM). A continuación empezamos a definir entidades: • • • • Proveedor: nos interesa saber su código de proveedor. Para ello abrimos la utilidad DataArchitect de S-Designar. CIF. nombre. Pedido: código de pedido. desea simplificar el tema de la facturación. . Enterprise SL desea tener almacenados los datos de todos sus clientes. Producto: código de producto.Ejemplo de diseño con Power Designor Para irnos familiarizándonos con el uso de S-Designar. descripción y existencias.

Santa Cruz de Tenerife. Esto implica la creación de otras dos nuevas entidades: • • Provincia: código de provincia y descripción. en la ventana que nos aparece teclearemos el nombre de la entidad (Proveedor). Sta. Nos decantaremos por esta última opción. Empezaremos por la entidad proveedor. un código (que será también CIF) y un tipo de dato (tipo carácter de longitud 10. El siguiente paso es definir los atributos de cada una de ellas. ya que evitará el tener diferentes definiciones para una misma ciudad (Ej.. Tipificar las ciudades y provincias.: Sta. o 2. Cruz Tenerife. Cruz Trfe. o hacer click con el botón derecho del ratón. Empezamos creando las entidades. Ciudad: código de ciudad y descripción. Para crear un nuevo atributo pulsamos el botón New y le damos un nombre (CIF). 226 . Pulsamos el botón entidad en la paleta de componentes y acto seguido pulsamos seis veces en cualquier punto de la pantalla. Factura: IVA e importe en pesetas y euros. y acto seguido pulsamos el botón Attributes. teniendo en cuenta que la clave de dicha entidad será el atributo cod_proveedor. La definición completa es la mostrada en la Figura 117 Ahora se nos plantean dos opciones: 1. A10). Ya tenemos creadas las seis entidades. por lo que tacharemos la caja de selección correspondiente a Identifier de dicho atributo. Etc. Así procederemos con el resto de atributos.). Para quitar la selección se puede pulsar el botón flecha en la paleta. Para ello hacemos doble click sobre cualquiera de las entidades y.Base de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS • • Linea_pedido: código de la línea de pedido y cantidad. Dejar que el usuario introduzca la ciudad y la provincia como texto libre.

La definición de la entidad ciudad queda como indica la Figura 119.© Grupo EIDOS Apéndice C. En la Figura 118 mostraremos como quedaría la pantalla de definición de la entidad provincia. Ejemplo de diseño con Power Designor Por lo tanto creamos dos entidades más. Figura 119 227 . Figura 118 El atributo cod_provincia será la clave de la entidad. El atributo desc_provincia será un texto de 20 caracteres. siguiendo el mismo proceso indicado anteriormente. y será de tipo numérico de dos dígitos.

Figura 120 Lo único a destacar aquí es la clave de la entidad. y pasamos a ahora a hacerlo con cliente.Base de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Seguimos definiendo entidades. y los atributos obligatorios que son Nombre y Apellidos. Figura 121 Hacemos lo mismo con la entidad linea_pedido. que es el atributo cod_cliente. 228 . En la Figura 121 definimos los atributos de la entidad Pedido.

© Grupo EIDOS Apéndice C. Figura 123 Y concluimos definiendo la entidad factura. máxime cuando se sabe el cambio de pesetas a euros. Ejemplo de diseño con Power Designor Figura 122 También definimos la entidad producto. con lo que ya tenemos una regla de negocio para la entidad factura. Para crearla. Lo único que se deberá realizar para calcularlo será dividir el importe en pesetas por 166. ya que ello supone un desperdicio de memoria. como se observa en la Figura 124 En esta última definición. pulsamos el 229 .386. cabe destacar que se ha optado por no almacenar el importe en euros en un nuevo campo.

Base de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS botón Rules. pulsamos el botón Define y tecleamos lo que muestra la Figura 125. sólo nos queda añadirla a la entidad. para lo que pulsaremos el botón Add en la pantalla y escogeremos dicha regla. 230 . Para definirla. Figura 124 Figura 125 Una vez definida. y en la pantalla que nos aparece pulsamos List. Le damos el nombre Pesetas_a_euros. y decimos que es de tipo Formula.

© Grupo EIDOS Apéndice C. que debe quedar como la Figura 127. Ejemplo de diseño con Power Designor Figura 126 Una vez definidas todas las entidades. La cardinalidad máxima es N y la mínima es 1. pulsaremos el botón de relación en la paleta de componentes. el siguiente paso es crear las relaciones entre ellas. obtenemos la pantalla de definición. y un producto puede ser abastecido por varios proveedores: relación N-M. y a continuación uniremos ambas entidades. Para crear una relación entre ambas entidades. Podemos observar varias relaciones entre pares de entidades: • Un proveedor puede abastecer a la empresa de varios productos. Haciendo doble click sobre la relación creada. Figura 127 231 .

pero un pedido sólo puede ser realizado por un cliente. si no se sabe el pedido al que corresponde. Figura 128 • Un pedido puede tener muchas líneas de pedido. Esto implica una relación 1-N. no se puede identificar una línea de pedido. Figura 129 232 . pero una línea de pedido sólo puede corresponder a un pedido. y la ventana queda como la Figura 128. es decir. Además. la relación en el sentido de linea_pedido es dependiente.Base de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS • Un cliente puede realizar muchos pedidos.

Figura 130 • Un cliente puede tener varias facturas. Ejemplo de diseño con Power Designor • En una línea de pedido sólo puede haber un producto. mientras que un producto puede estar en varias líneas de pedido. sin embargo una factura sólo puede corresponder a un cliente. Figura 131 233 .© Grupo EIDOS Apéndice C.

y una ciudad sólo puede pertenecer a una provincia. Figura 133 234 . pero como mínimo una. La cardinalidad mínima es uno. pero un proveedor sólo puede pertenecer a una ciudad. ya que no nos interesa tener almacenadas las ciudades sin proveedores.Base de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS • Una provincia puede tener muchas ciudades. Figura 132 • Una ciudad puede tener varios proveedores.

que queda como muestra la Figura 135. podemos saber su provincia.© Grupo EIDOS Apéndice C. Ejemplo de diseño con Power Designor • Una ciudad puede tener varios clientes. ya que sabiendo la ciudad a la que pertenece el cliente. ya tenemos el esquema conceptual. Obsérvese. Figura 135 235 . pero un cliente sólo puede pertenecer a una ciudad. en la Figura 134 como no se ha incluido una relación entre provincia y cliente. Figura 134 Pues bien.

denominada RELATION_63. por ejemplo Microsoft Access 95. Para ello pulsamos Ctrl-G y escogemos un SGBD. Figura 136 En él podemos observar como se ha añadido una nueva relación. y que almacena los productos que han sido abastecidos por cada proveedor. fruto de la relación N-M entre las entidades producto y proveedor. Las flechas representan las operaciones de join que hay que realizar para obtener la información de una tabla. el siguiente paso es obtener el esquema físico. Figura 137 236 . Pulsamos Ok. El esquema físico queda como aparece la Figura 136.Base de datos con SQL Server 2000 – Transact SQL © Grupo EIDOS Una vez obtenido el esquema conceptual.

Para ello pulsamos el botón vista en la paleta de componentes. y añadiremos un nuevo atributo. Básicamente. 237 . Figura 138 No se preocupe demasiado si no entiende la anterior consulta. Ejemplo de diseño con Power Designor Lo primero que realizaremos será cambiar el nombre de la relación RELATION_63. Para definirla. compruebe el stock que queda. ya que no queda muy estético. y tecleamos el nuevo atributo. Para ello hacemos doble click en dicha entidad. hacemos doble click sobre ella. lo que hace es recuperar todos los productos cuyo stock es menor de 10 unidades. y establecemos una consulta SQL. para que la secretaria encargada de realizar los pedidos.© Grupo EIDOS Apéndice C. pulsamos el botón New. Le daremos el nombre de Proveedor-Producto. que será la fecha en la que se ha realizado la venta. Crearemos ahora una vista. pulsamos el botón Columns. ya que en la siguiente parte se estudiará a fondo la sintaxis de lenguaje SQL. y pinchamos en cualquier punto de la pantalla.

.

con un profesor a su disposición. Si quiere hacer algún comentario. tutorías. exámenes y un completo plan formativo con otros textos. o tiene cualquier tipo de problema. Este libro tiene soporte de formación virtual a través de Internet. envíelo a la dirección de correo electrónico lalibreriadigital@eidos.es .es.eidos.eidos. © Grupo EIDOS http://www. Si quiere información más precisa de las nuevas técnicas de programación puede suscribirse gratuitamente a nuestra revista Algoritmo en: http://www.com.lalibreriadigital.Si quiere ver más textos en este formato.almagesto. Si desea inscribirse en alguno de nuestros cursos o más información visite nuestro campus virtual en: http://www. sugerencia. visítenos en: http://www.com.es/alquimia donde podrá encontrar artículos sobre tecnologías de la sociedad del conocimiento.com.algoritmodigital. No deje de visitar nuestra reviata Alquimia en http://www.

Sign up to vote on this title
UsefulNot useful