NOTAS PARA EL CURSO

SQL Server

Compilado por:
Jazmin Cabello Pérez,
Julia Basurto Madrid

Dirección General de Servicios de Cómputo Académico

Dirección de Cómputo para la Docencia
Subdirección de Planeación Académica
UNIVERSIDAD NACIOINAL AUTÓNOMA DE MÉXICO
Dirección General de Servicios de Cómputo Académico

SQL SERVER 2000

Compilado por:
Jazmin Cabello Pérez y Julia Basurto Madrid.

La titularidad de los derechos de autor de este manual corresponde a la Universidad

Nacional Autónoma de México.

Junio 2007
INDICE

1. CONCEPTOS BÁSICOS DE SQL............................................................................................... 3

1.1 Requerimientos Informáticos.................................................................................................. 3
1.2. Componentes del SQL.......................................................................................................... 4
1.3 Características generales ...................................................................................................... 6

2. ARQUITECTURA........................................................................................................................ 8
2.1 Bases de datos del sistema. .................................................................................................. 8
2.2 Tablas del sistema ................................................................................................................. 8
2.3 Principales procedimientos almacenados del sistema............................................................ 9

3. CREACIÓN DE BASES DE DATOS Y OBJETOS..................................................................... 12

3.1 Creación de bases de datos................................................................................................. 12
3.2 Objetos de la base de datos................................................................................................. 13
3.3 Tipos de datos y tipos de datos definidos por el usuario. ..................................................... 14
3.4 Creación de tablas. .............................................................................................................. 16
3.5 Creación de reglas y datos .................................................................................................. 16
3.6 Integridad de datos: llaves, constraints e índices. ................................................................ 20
3.7 Tablas temporales. .............................................................................................................. 23
3.8 Vistas. .................................................................................................................................. 25

4. CONSULTAS BÁSICAS............................................................................................................ 27
4.1 Instrucciones para la selección, ordenamiento y agrupación de la información.................... 27
4.2 Instrucciones para la inserción, actualización y borrado de información............................... 30
4.3 Funciones matemáticas, de cadena, fechas y otras. ............................................................ 32

5. CONSULTAS AVANZADAS CON SQL ..................................................................................... 35

5.1 Subconsultas. ...................................................................................................................... 35
5.2 Inner joins y outer joins. ....................................................................................................... 38

6. TRANSACT SQL Y PROCEDIMIENTOS ALMACENADOS ...................................................... 42

6.1 Características y ventajas. ................................................................................................... 42
6.2 Comando Set. ...................................................................................................................... 43
2 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

6.3 Estructuras de control. ......................................................................................................... 45

6.4 Variables locales y globales. ................................................................................................ 46
6.5 Utilización de parámetros..................................................................................................... 47
6.6 Transacciones...................................................................................................................... 49
6.7 Recopilación. ....................................................................................................................... 50

7. FUNCIONES DEFINIDAS POR EL USUARIO .......................................................................... 51

7.1 Características y definición. ................................................................................................. 51

8. TRIGGERS ............................................................................................................................... 55
8.1 Características y beneficios. ................................................................................................ 55
8.2 Observaciones sobre integridad referencial. ........................................................................ 56
8.3 Utilización de los triggers ..................................................................................................... 57
SQL Server 2000 3

CONCEPTOS
B ÁSICOS DE SQL

L as aplicaciones en red son cada día más numerosas y versátiles. En muchos casos, el esquema básico
de operación es una serie de scripts que rigen el comportamiento de una base de datos.
Debido a la diversidad de lenguajes y de bases de datos existentes, la manera de comunicar entre unos y
otras sería realmente complicada de gestionar de no ser por la existencia de estándares que permiten
realizar las operaciones básicas de una forma universal.
Es de eso de lo que trata el Structured Query Language que no es más que un lenguaje estándar de
comunicación con bases de datos. Por tanto es un lenguaje normalizado que permite trabajar con cualquier
tipo de lenguaje (ASP o PHP) en combinación con varios tipos de base de datos (MS Access, SQL Server,
MySQL).
El hecho de que sea estándar no quiere decir que sea idéntico para cada base de datos. En efecto,
determinadas bases de datos implementan funciones específicas que no tienen necesariamente que
funcionar en otras.
Aparte de esta universalidad, el SQL posee otras dos características muy apreciadas. Por una parte,
1
presenta una potencia y versatilidad notables que contrasta, por otra, con su accesibilidad de aprendizaje .

1.1 Requ erimi en to s I nformáticos

Requerimientos de procesador: Intel 486 DX PC (o similar) o superior

Requerimientos de Memoria: 8 Mb en RAM para Windows 3.1

16 MB para Windows 95 y Windows NT

Requerimientos de Software: MS-DOS 6.0 o superior

Windows 3.1
Windows 95
Windows NT 3.51 o 4.0

1
Que es y para que sirve el SQL (n.d.). Disponible en URL http://www.desarrolloweb.com/articulos/262.php
4 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Requerimientos aproximados de 25 Mb de espacio libre

espacio en Disco duro:

Requerimientos previos para la Open Client de Sybase

instalación:

Los requerimientos mínimos del hardware y software para la instalación del programa
 PC con procesador Pentium® II/III de 350 MHz.
 Tarjeta de video SVGA a 800x600 píxeles (256 colores) o superior.
 Ratón.
 64 MB de memoria RAM (128MB recomendado).
 20 MB de espacio libre en disco en Disco Duro.
 Tarjeta de red 10/100 para la conexión por red al equipo servidor de datos (LAN o RAS).
 El sistema CADECO® es una aplicación construida para ejecutar en plataformas Windows de 32
bits, por lo que requiere para su funcionamiento el sistema operativo Microsoft® Windows 98 o NT®,
Win2000 Server.
A su vez cada computadora debe tener su correspondiente licencia de cliente tanto para NT como para SQL
2
Server (CALs)

1.2. Compon en tes del S QL

El lenguaje SQL está compuesto por comandos, cláusulas, operadores y funciones de agregado. Estos
elementos se combinan en las instrucciones para crear, actualizar y manipular las bases de datos.

Comandos
Existen dos tipos de comandos SQL:
 Los DLL que permiten crear y definir nuevas bases de datos, campos e índices.
 Los DML que permiten generar consultas para ordenar, filtrar y extraer datos de la base de datos.

Comandos DLL

Comando Descripción

CREATE Utilizado para crear nuevas tablas, campos e índices.

DROP Empleado para eliminar tablas e índices.

ALTER Utilizado para modificar las tablas agregando campos o cambiando la definición de los
campos.

2
Requerimientos (n.d.). Disponible en URL http://www.dist-soft.com/page6.html (Abril 2007)
SQL Server 2000 5

Comandos DML

Comando Descripción

SELECT Utilizado para consultar registros de la base de datos que satisfagan un criterio determinado.

INSERT Utilizado para cargar lotes de datos en la base de datos en una única operación.

UPDATE Utilizado para modificar los valores de los campos y registros especificados.

DELETE Utilizado para eliminar registros de una tabla de una base de datos.

Cláusulas
Las cláusulas son condiciones de modificación utilizadas para definir los datos que desea seleccionar o
manipular.

Comando Descripción

FROM Especifica la tabla de la cual se van a seleccionar los registros.

WHERE Utilizada para especificar las condiciones que deben reunir los registros que se van a
seleccionar.

GROUP BY Separa los registros seleccionados en grupos específicos.

HAVING Utilizada para expresar la condición que debe satisfacer cada grupo.

ORDER BY Ordena los registros seleccionados de acuerdo con un orden específico.

Operadores Lógicos

Operador Uso

AND Es el “y” lógico. Evalúa dos condiciones y devuelve un valor de verdad sólo si ambas son ciertas.

OR Es el “o” lógico. Evalúa dos condiciones y devuelve un valor de verdad si alguna de las dos es
cierta.

NOT Negación lógica. Devuelve el valor contrario de la expresión.

6 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Operadores de Comparación

Operador Uso

< Menor que.

> Mayor que

<> Distinto de.

<= Menor ó Igual que.

>= Mayor ó Igual que.

BETWEEN Específica un intervalo de valores.

LIKE Utilizado en la comparación de un modelo.

In Especifica registros de una base de datos.

Funciones de Agregado
Las funciones de agregado se usan dentro de una cláusula SELECT en grupos de registros para devolver
un único valor que se aplica a un grupo de registros.

Comando Descripción

AVG Calcula el promedio de los valores de un campo determinado.

COUNT Devuelve el número de registros de la selección.

SUM Devuelve la suma de todos los valores de un campo determinado.

MAX Utilizada para devolver el valor más alto de un campo.

MIN Utilizada para devolver el valor más bajo de un campo especificado.

1.3 Característi cas g en eral es

El SQL es un lenguaje de acceso a bases de datos que explota la flexibilidad y potencia de los sistemas
relacionales permitiendo gran variedad de operaciones sobre los mismos. Es un lenguaje declarativo de alto
nivel o de no procedimiento, que gracias a su fuerte base teórica y su orientación al manejo de conjuntos
de registros, y no a registros individuales, permite una alta productividad en codificación. De esta forma una
sola sentencia puede equivaler a uno o más programas que utilizasen un lenguaje de bajo nivel orientado a
registro.
SQL Server 2000 7

Funcionalidad
El SQL proporciona funcionalidad más allá de la simple consulta (o recuperación) de datos. Asume el papel
de lenguaje de definición de datos (LDD), lenguaje de definición de vistas (LDV) y lenguaje de manipulación
de datos (LMD). Además permite la concesión y denegación de permisos, la implementación de
restricciones de integridad y controles de transacción, y la alteración de esquemas. Las primeras versiones
del SQL incluían funciones propias de lenguaje de definición de almacenamiento (LDA) pero fueron
suprimidas en los estándares más recientes con el fin de mantener el lenguaje sólo a nivel conceptual y
externo.

Modos de uso
El SQL permite fundamentalmente dos modos de uso:
 Un uso interactivo, destinado principalmente a los usuarios finales avanzados u ocasionales, en el
que las diversas sentencias SQL se escriben y ejecutan en línea de comandos, o un entorno
semejante.
 Un uso integrado, destinado al uso por parte de los programadores dentro de programas escritos
en cualquier lenguaje de programación anfitrión. En este caso el SQL asume el papel de
sublenguaje de datos.
En el caso de hacer un uso embebido del lenguaje se pueden utilizar dos técnicas alternativas de
programación. En una de ellas, en la que el lenguaje se denomina SQL estático, las sentencias utilizadas
no cambian durante la ejecución del programa. En la otra, donde el lenguaje recibe el nombre de SQL
dinámico, se produce una modificación total o parcial de las sentencias en el transcurso de la ejecución del
programa. La utilización de SQL dinámico permite mayor flexibilidad y mayor complejidad en las sentencias,
pero como contra punto se obtiene una eficiencia menor y el uso de técnicas de programación más
complejas en el manejo de memoria y variables.

Optimización
SQL es un lenguaje declarativo, es decir que especifica que es lo que se quiere y no cómo conseguirlo, por
lo que una sentencia no establece explícitamente un orden de ejecución. El orden de ejecución interno de
una sentencia puede afectar gravemente a la eficiencia del SGBD, por lo que se hace necesario que éste
lleve a cabo una optimización antes de la ejecución de la misma. Muchas veces, el uso de índices acelera
una instrucción de consulta, pero ralentiza la actualización de los datos, dependiendo del uso de la
aplicación, se priorizará el acceso indexado o una rápida actualización de la información. La optimización
difiere sensiblemente en cada motor de base de datos y depende de muchos factores. Existe una
ampliación de SQL conocida como FSQL (Fuzzy SQL, SQL difuso) que permite el acceso a bases de datos
difusas, usando la lógica difusa. Este lenguaje ha sido implementado a nivel experimental y está
3
evolucionando rápidamente .

3
SQL (n.d.). Disponible en URL htttp://es.wikipedia.org/wiki/SQL. (Mayo 2007)
8 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

ARQUITECTURA

2.1 Bases d e d atos del si stema 4 .

Base de datos del Descripción
sistema

master Registra toda la información del sistema para una instancia de SQL Server.

msdb La utiliza el Agente SQL Server para programar alertas y trabajos.

model Se utiliza como plantilla para todas las bases de datos creadas en la instancia
de SQL Server. Las modificaciones hechas a la base de datos model, como el
tamaño de la base de datos, la intercalación, el modelo de recuperación y otras
opciones de base de datos, se aplicarán a las bases de datos que se creen con
posterioridad.
Resource Base de datos de sólo lectura que contiene objetos del sistema que se incluyen
con SQL Server 2005. Los objetos del sistema persisten físicamente en la base
de datos Resource, pero aparecen lógicamente en el esquema sys de cada
base de datos.
tempdb Área de trabajo que contiene objetos temporales o conjuntos de resultados
intermedios.

2.2 Tablas d el si stema

Se refiere al tipo de modelado de los datos, donde se guardan los datos recolectados por un programa. Su
estructura general se asemeja a la vista general de un programa de Hoja de cálculo.
Las tablas se componen de dos estructuras:
 Campo: corresponde al nombre de la columna. Debe ser único y además tener un tipo de dato
asociado.
 Registro: corresponde a cada fila que compone la tabla. Allí se componen los datos y los registros.
Eventualmente pueden ser nulos en su almacenamiento.

4
Bases de datos del sistema (n.d.). disponible en URL http://msdn2.microsoft.com/es-es/library/ms178028.aspx. (Abril
2007)
SQL Server 2000 9

En la definición de cada campo, debe existir un nombre único, con su tipo de dato correspondiente. Esto es
útil a la hora de manejar varios campos en la tabla, ya que cada nombre de campo debe ser distinto entre
sí.
A los campos se les puede asignar, además, propiedades especiales que afectan a los registros insertados.
El campo puede ser definido como índice o autoincrementable, lo cual permite que en el primer caso los
datos de ese campo cambien solos, de lo contrario son el principal indicador a la hora de ordenar los datos
contenidos.
Cada tabla creada debe tener un nombre único en cada Base de Datos, haciéndola accesible mediante su
nombre o su sinónimo (dependiendo del tipo de base de datos elegida).

La estructura de las tablas viene dado por la forma de un archivo plano, los cuales en un inicio se
5
componían de un modo similar .

2.3 P rin cip al es pro cedi mi ento s al macenado s d el

sistema.
Un procedimiento almacenado es un elemento de base de datos reutilizable almacenado que realiza alguna
operación en la base de datos. Un procedimiento almacenado contiene código SQL que puede, entre otras
cosas, insertar, actualizar o eliminar registros. Los procedimientos almacenados también pueden alterar la
estructura de la base de datos. Por ejemplo, puede utilizar un procedimiento almacenado para añadir una
columna de tabla o incluir borrar una tabla.
Un procedimiento almacenado también puede llamar a otro procedimiento almacenado, así como aceptar
entradas y devolver múltiples valores al procedimiento llamado en forma de parámetros de salida.
Un procedimiento almacenado es reutilizable en el sentido de que se puede reutilizar una versión compilada
del procedimiento para ejecutar una operación de base de datos varias veces. Si sabe que una tarea de
base de datos se va a ejecutar muchas veces o que distintas aplicaciones van a ejecutar la misma tarea, el
uso de un procedimiento almacenado para ejecutar dicha tarea puede agilizar las operaciones de base de
datos.
Cuando se crea un procedimiento, SQL Server verifica la sintaxis de los comandos Transact-SQL que
incluye. Si la sintaxis es incorrecta, SQL Server generará un mensaje de error “sintax incorrect” (sintaxis
incorrecta), y el procedimiento no será creado. Si el procedimiento pasa el chequeo de sintaxis, el
procedimiento se guarda, escribiéndose su nombre y otras informaciones (tal como un número
autogenerado de identificación) en la tabla SysObject. El texto usado para crear el procedimiento se escribe
en la tabla SysComments de la base de datos actual.
El siguiente comando SELECT consulta a la tabla SysObjects en la base de datos Pubs para mostrar el
número de identificación del procedimiento almacenado ByRoyalty:
SELECT [name].[id] FROM [pubs].[dbo].[SysObjects]
WHERE [name] = ‘byroyalty’
Esta consulta retorna lo siguiente: name id

byroyalty 581577110

5
Procedimientos almacenados (n.d.). Disponible en URL
http://livedocs.adobe.com/dreamweaver/8_es/using/wwhelp/wwhimpl/common/html/wwhelp.htm?context=LiveDocs_Parts&file=42_rad_
6.htm. (Mayo 2007).
10 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Usando la información retornada de la tabla SysObjects, el próximo comando SELECT consulta a la tabla
SysComments al usar el número de identificación del procedimiento almacenado ByRoyalty:
SELECT [text] FROM [pubs].[dbo].[SysComments]
WHERE [id] = 581577110
Esta consulta retorna el texto del procedimiento almacenado, cuyo número de identificación es el
581577110.
Usar el procedimiento almacenado de sistema sp_helptext es una mejor opción para mostrar el texto usado
para crear un objeto (tal como un procedimiento almacenado no encriptado), dado el texto es retornado en
múltiples filas.
Métodos para crear procedimientos almacenados
SQL Server provee muchos métodos que se pueden usar para crear un procedimiento almacenado: el
comando Transact-SQL CREATE PROCEDURE, SQL-DMO (usando el objeto StoredProcedure), a través
del árbol de consola del Enterprise Manager, el asistente para crear procedimientos almacenados (al cual
se puede acceder a través del Enterprise Manager).
El comando CREATE PROCEDURE
Se puede usar el comando CREATE PROCEDURE, o su versión abreviada, CREATE PROC, para crear un
procedimiento almacenado en el Query Analyzer o una herramienta de comando como sql. Cuando utiliza
CRETE PROC, se pueden realizar las siguientes tareas:
Especificar agrupamientos de procedimientos almacenados.
 Definir parámetros de entrada-salida, sus tipos de datos, y sus valores por defecto. Cuando se
definen parámetros de entrada y salida, estos siempre van precedidos por el signo @, seguido del
nombre del parámetro y luego una designación del tipo de dato. Los parámetros de salida deben
incluir la palabra clave OUTPUT para diferenciarlos de los de entrada.
 Usar códigos de retorno para mostrar información acerca del éxito o falla de una tarea.
 Controlar si un plan de ejecución debería ser guardado temporalmente (en el caché) para un
procedimiento.
 Encriptar el contenido del procedimiento almacenado por razones de seguridad.
 Especificar las acciones que deberá tomar el procedimiento almacenado cuando se ejecute.
Proveer de contexto a un procedimiento almacenado
Con la excepción de los procedimientos almacenados temporarios, un procedimiento almacenado se crea
siempre en la base de datos actual. Por lo tanto, siempre se deberá especificar la base de datos actual
usando el comando USE nombre_base seguido por el comando GO antes de crear un procedimiento
almacenado- Se puede usar la lista desplegable Change Database en el Query Analizer para seleccionar la
base de datos actual.
El script siguiente selecciona la base Pubs y luego crea un procedimiento llamado ListAuthorNames (lista de
los nombres de los autores), que pertenece a dbo:
USE Pubs
GO
CREATE PROCEDURE [dbo].[ListAuthorNames]
AS
SELECT [au_fname], [aufname] FROM [pubs].[dbo].[authors]
En necesario observar que el nombre del procedimiento está totalmente calificado en el ejemplo siguiente:
Un nombre de procedimiento almacenado totalmente incluye el nombre de su propietario (en este caso dbo)
y el nombre del procedimiento, ListAuthorNames. Se especifica dbo como propietario, si se quiere asegurar
que la tarea del procedimiento almacenado correrá sin importar la tabla propietaria en la base de datos. El
SQL Server 2000 11

nombre de la base de datos no es parte del nombre totalmente calificado de un procedimiento almacenado
cuando se usa el comando CREATE PROCEDURE.
Crear procedimientos almacenados temporarios
Para crear un procedimiento almacenado temporal local, se agrega adelante del nombre del procedimiento
el símbolo #. Este signo numeral instruye al SQL Server para que cree el procedimiento en la TempDB.
Para crear un procedimiento almacenado temporario global, se agrega adelante del nombre del
procedimiento un doble símbolo numeral ##, que también será creado en la TempDB. SQL Server ignora la
base de datos actual cuando crea un procedimiento temporario. Por definición, un procedimiento
almacenado sólo puede existir en la TempDb. Para crear un procedimiento almacenado directamente en la
TempDB que no es ni local ni global haga que la TempDB sea la base de datos actual y luego cree el
procedimiento. El ejemplo siguiente crea un procedimiento almacenado temporario local, un procedimiento
almacenado temporario global y un procedimiento directamente en la TempDB:
 crear un procedimiento temporario local
CREATE PROCEDURE #localtemp
AS
SELECT * from [pubs].[dbo].[authors]
GO
 crear un procedimiento temporario global
CREATE PROCEDURE #globaltemp
AS
SELECT * from [pubs].[dbo].[authors]
GO
 crear un procedimiento almacenado temporario que sea local en tempdb
USE TEMPDB
GO
CREATE PROCEDURE directtemp
AS
SELECT * from [pubs].[dbo].[authors]
GO
Nombres de bases de datos totalmente calificados son especificados en los comandos SELECT. Si el
procedimiento no se ejecuta en el contexto de una base de datos específica, luego nombre de bases de
datos totalmente calificadas aseguran que se está referenciando a la base de datos apropiada.
En la tercera parte del ejemplo, cuando se crea un procedimiento almacenado temporario directamente en
la base de datos TempDB, se debe hacer a la base de datos TempDB la base actual antes de crearlo, o se
debe calificar totalmente el nombre ([TempDb].[dbo].[directtemp]). Tal como los procedimientos
almacenados del sistema, que se guardan en la base Masters, los procedimientos almacenados
temporarios locales y globales están disponibles para ser usados por su nombre corto (sin importar la base
6
de datos actual )

6
TEMA 2: Creando, ejecutando, modificando y borrando procedimientos almacenados (n.d.). Disponible en URL
http://www.sqlmax.com/centro/moduloIV_2.asp?MX=. (Abril 2007)
 CREACIÓN DE BASES
DE D ATOS Y OBJETOS

3.1 Creación de bases d e d atos.

L a mayoría de los sistemas SQL actuales incluyen un menú, o un botón para crear bases de datos.
Muestran un cuadro de dialogo para que el usuario escriba el nombre de la nueva base de datos, el
nombre de usuario y sus password. Evidentemente, quien desee crear una nueva base de datos debe tener
los privilegios para hacerlo, eso es cuestión del administrador del sistema, él es quien gestiona los
privilegios de los usuarios.
Cuando el sistema SQL no tiene una interfaz visual para crear bases de datos, puede usarse la sentencia
CREATE DATABASE, que tiene la siguiente sintaxis:
CREATE DATABASE nombre_de_la_base_de_datos;
Por ejemplo:
CREATE DATABASE Pagos;
Existen algunas consideraciones a tomarse cuando se crea una base de datos.
Primero, no todos los sistemas dan soporte a esta sentencia de la misma forma, algunos ni siquiera la
toman en cuenta y devuelven un mensaje de error. Es muy probable que aquellos sistemas que no acepten
esta sentencia tengan una forma más visual de construir una base de datos, por ejemplo: InterBase 4.2.
Segundo, muchos sistemas de gestión de bases de datos relacionales permiten especificar un tamaño de
base de datos en términos de espacio en disco duro, como los megabytes. Se necesita entender cómo es
que un sistema de bases de datos almacena datos en disco para estimar un tamaño preciso necesario para
la nueva base de datos.
Algunos sistemas gestionan el espacio sin hacer muchas preguntas y por lo que apartan al usuario de la
necesidad de hacer estas estimaciones.
Tercero, se debe diseñar apropiadamente la base de datos. Antes que nada, los conocimientos teóricos
sobre bases de datos y sobre normalización de bases de datos tienen que estar bien asentados. De no ser
así, seguramente la base de datos fracasara en su desempeño y estructura.
Aspectos a tomar en cuenta cuando se diseña una base de datos:
1. Seguridad
2. Espacio disponible en disco
3. Velocidad en búsquedas
4. Velocidad en actualización de datos
5. Velocidad en carga de tablas vinculadas
6. Soporte del sistema de gestión de bases de datos relacionales para tablas temporales
SQL Server 2000 13

La normalización de una base de datos consiste en el seccionamiento de información en componentes con

la finalidad de evitar la repetición innecesaria de datos. Cada nivel de normalización reduce la repetición de
datos. Normalizar la información es un proceso complejo que bien logrado brinda beneficios importantes al
desempeño de consultas de datos y al aprovechamiento del espacio disponible en disco.
Una herramienta útil en el diseño de bases de datos es el Diccionario de Datos.

Diccionario de Datos7
Un Diccionario de Datos es una forma de documentación para el diseñador de bases de datos. Su utilidad
básica se describe en las siguientes funciones:
1. Describir el propósito de la BD y quienes serán sus usuarios.
2. Documentar las especificaciones detrás de la BD misma: en qué dispositivo estará almacenada, cuál
será el tamaño estándar de la BD junto con sus archivos lógicos (aquellos que almacenan información
sobre operaciones en algunos sistemas de gestión de BD).
3. Almacenar código fuente de SQL referente a la instalación y desinstalación de la BD, incluida también
documentación respecto al uso de herramientas de importar/exportar.
4. Proveer una detallada descripción de cada tabla dentro de la BD y explicar su propósito en términos
de procesos de negocios.
5. Documentar la estructura interna de cada tabla, incluyendo todos sus campos y sus tipos de datos con
comentarios, todos los índices y todas las vistas.
6. Contener todo el código fuente SQL para todos los procedimientos y triggers.
7. Describir reglas como pueden ser el uso de valores no nulos, valores únicos.
Algunos programas CASE auxilian al diseñador de BD en la creación y mantenimiento de un Diccionario de
Datos.

3.2 Obj eto s d e la base d e d atos.

Tablas:
Las tablas son la parte fundamental de cualquier base de datos ya que contienen la información en la que
se basa el resto de los objetos.
Se tienen dos modos para trabajar en una tabla: Diseño y Hoja de Datos. El modo diseño sirve para definir
la estructura y contenido de los campos que van a componer la tabla y la Hoja de datos nos permite
gestionar los datos. [7]

Formularios y páginas de acceso a datos:

Un formulario es una ventana que permite mostrar y editar la información por medio de diferentes controles
(botones, cuadros de texto, etiquetas, etc.).
El formulario en sí no almacena información, solo que permite acceder a los datos que están guardados en
una tabla.
La ventaja de usar formularios consiste en que se puede trabajar simultáneamente con datos de más de
una tabla en un único formulario.

7
TEMA 2: Creando, ejecutando, modificando y borrando procedimientos almacenados (n.d.). Disponible en URL
http://www.sqlmax.com/centro/moduloIV_2.asp?MX=. (Abril 2007)
14 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

La página de acceso a datos se parece a un formulario pero se guarda en un documento HTML y hace
posible el acceso a la base de datos desde una Intranet o desde Internet.

Informes:
Permiten imprimir la información de base de datos en una forma eficaz y además, permite combinar los
datos de varias tablas en un documento único.

Consultas:
Facilitan la obtención de la información que se quiere ver de las bases de datos y organizarla para su uso
en informes.
Una consulta consiste de uno o más criterios para seleccionar los datos que nos interesan.

3.3 Tipo s d e d ato s y ti po s de d ato s d efi nido s

por el u su ari o.
Tipo de Datos Longitud Descripción

Para consultas sobre tabla adjunta de productos de bases de datos

BINARY 1 byte
que definen un tipo de datos Binario.

BIT 1 byte Valores Si/No ó True/False

BYTE 1 byte Un valor entero entre 0 y 255.

COUNTER 4 bytes Un número incrementado automáticamente (de tipo Long)

Un entero escalable entre 922.337.203.685.477,5808 y

CURRENCY 8 bytes
922.337.203.685.477,5807.

DATETIME 8 bytes Un valor de fecha u hora entre los años 100 y 9999.

Un valor en punto flotante de precisión simple con un rango de -

SINGLE 4 bytes 3.402823*1038 a -1.401298*10-45 para valores negativos,
1.401298*10- 45 a 3.402823*1038 para valores positivos, y 0.

Un valor en punto flotante de doble precisión con un rango de -

1.79769313486232*10308 a -4.94065645841247*10-324 para
DOUBLE 8 bytes
valores negativos, 4.94065645841247*10-324 a
1.79769313486232*10308 para valores positivos, y 0.

SHORT 2 bytes Un entero corto entre -32,768 y 32,767.

LONG 4 bytes Un entero largo entre -2,147,483,648 y 2,147,483,647.

1 byte por
LONGTEXT De cero a un máximo de 1.2 gigabytes.
carácter
SQL Server 2000 15

Tipo de Datos Longitud Descripción

Según se
LONGBINARY De cero 1 gigabyte. Utilizado para objetos OLE.
necesite

1 byte por
TEXT De cero a 255 caracteres.
carácter

La siguiente tabla recoge los sinónimos de los tipos de datos definidos:

Tipo de Dato Sinónimos

BINARY VARBINARY

BOOLEAN
LOGICAL
BIT
LOGICAL1
YESNO

BYTE INTEGER1

COUNTER AUTOINCREMENT

CURRENCY MONEY

DATE
DATETIME TIME
TIMESTAMP

FLOAT4
SINGLE IEEESINGLE
REAL

FLOAT
FLOAT8
DOUBLE IEEEDOUBLE
NUMBER
NUMERIC

INTEGER2
SHORT
SMALLINT

INT
LONG INTEGER
INTEGER4

GENERAL
LONGBINARY
OLEOBJECT

LONGCHAR
LONGTEXT MEMO
NOTE
16 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Tipo de Dato Sinónimos

ALPHANUMERIC
TEXT CHAR - CHARACTER
STRING - VARCHAR

VARIANT (No Admitido) VALUE

3.4 Creación de tabl as.

Creación de tablas8
Para crear una tabla se utiliza la orden CREATE TABLE, cuya sintaxis es:
CREATE TABLE <nombre_tabla>
(
<columna1> <tipo_dato> [NOT NULL],
<columna2> <tipo_dato> [NOT NULL],
........................
)
Donde:
 nombre_tabla será el nombre de la tabla.
 columna1, columna2, . . . son los nombres de las columnas que contendrá cada fila.
 tipo_dato indica el tipo de dato (VARCHAR, NUMBER, . . .) de cada columna.
Ejemplo:
CREATE TABLE ALUMNOS
(
NUMERO_MATRICULA NUMBER(6) NOT NULL,
NOMBRE VARCHAR(15) NOT NULL,
FECHA_NACIMIENTO DATE,
DIRECCION VARCHAR(10),
LOCALIDAD VARCHAR(10)
)

3.5 Creación de re glas y d ato s

CREATE RULE -- Crea una nueva regla

8
Creación de tablas (n.d.). Disponible en URL http://www.astable.org/sql/SQL/node11.html (Abril 2007)
SQL Server 2000 17

Sintaxis

CREATE RULE name AS ON event

TO object [ WHERE condition ]
DO [ INSTEAD ] [ action | NOTHING ]

Inputs

name El nombre de la regla a crear.

event Event puede ser select, update, delete o insert.

object Object puede ser table o table.column.

condition Cualquiera cláusula SQL WHERE. new o current pueden aparecer en lugar de
una variable de instancia*** siempre que una variable de instancia es admisible
en SQL.

action Cualquiera cláusula SQL. new o current pueden aparecer en lugar de una
variable de instancia*** siempre que una variable de instancia sea admisible en
SQL. [10]

Salidas

CREATE Mensage devulte si la regla es creada con éxito.

Descripción
El Postgres rule system permite que una acción alternativa sea realizada en updates, inserts o deletes en
tablas o clases. Actualmente se utilizan reglas para implementar vistas de tablas.
El significado de una regla es que cuando una instancia individual es accedida, actualizada, insertada o
borrada, existe una instancia actual (para consultas, actualizaciones y borrados) y una nueva instancia (para
actualizaciones y añadidos). Si el event especificado en la cláusula ON y la condition especificada en la
cláusula WHERE son verdaderas para la instancia actual la parte action de la regla es ejecutada. Antes, sin
embargo, los valores de los campos de la instancia actual y/o la nueva instancia son sustituidos por
current.attribute-name y new.attribute-name.
La parte action de la regla se ejecuta con el mismo identificador de comando y transacción que el comando
de usuario que causó la activación. [9]
Notas: Es pertinente la precaución con reglas de SQL. Si el mismo nombre de clase o variable de instancia
aparece en el event, la condition y la parte action de la regla, son considerados todos diferentes tuplas.
De forma más precisa, new y current son las únicas tuplas que son compartidas entre cláusulas. Por
ejemplo, las siguientes dos reglas tienen la misma semántica.

ON UPDATE TO emp.salary WHERE emp.name = "Joe"

DO UPDATE emp ( ... ) WHERE ...
18 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

ON UPDATE TO emp-1.salary WHERE emp-2.name = "Joe"

DO UPDATE emp-3 ( ... ) WHERE ...

Cada regla puede tener el tag opcional INSTEAD. Sin este tag, la action será realizada en adición al
comando de usuario cuando el event en la parte condition de la regla aparezcan. Alternativamente, la parte
action será realizada en lugar del comando del usuario. En este último caso la instead of the user
command. En este caso, la action puede ser la palabra clave NOTHING.
Cuando se elige entre los sistemas de reescritura y reglas de instancia para una aplicación particular de una
regla, recuérdese que en el sistema de reescritura, current se refiere a la relación y algunos cualificadores
mientras que en el sistema de instancias se refiere a una instancia (tupla).
Es muy importante notar que el sistema de reescritura nunca detectará ni procesará reglas circulares. Por
ejemplo, aunque cada una de las siguientes dos reglas con aceptadas por Postgres, el comando de
recogida causará la caída de Postgres. [9]
Ejemplo 1. Ejemplo de combinación circular de reglas.

CREATE RULE bad_rule_combination_1 AS

ON SELECT TO emp
DO INSTEAD SELECT TO toyemp;

CREATE RULE bad_rule_combination_2 AS

ON SELECT TO toyemp
DO INSTEAD SELECT TO emp;

Este intento de obtención de datos desde EMP provocará la caída de Postgres.

SELECT * FROM emp;

Es necesario tener permiso de definición de reglas en una clase para poder definir una regla en el. Se debe
utilizar el comando GRANT y REVOKE para modificar estos permisos.
El objeto en una regla SQL no puede ser una referencia a un array y no puede tener parámetros.
Aparte del campo "oid", los atributos del sistema no pueden ser referenciados en ningún lugar en una regla.
Entre otras cosas esto significa que las funciones de instancias (por ejemplo, foo(emp) donde emp es una
clase) no pueden ser llamadas en ningún lugar dentro de una regla.
El sistema almacena el texto de la regla y los planes de consulta como atributos de texto. Esto implica que
la creación de reglas puede fallar si la regla más sus varias internas representaciones exceden algún valor
que es del orden de una página. [9]

Uso
Hacer que Sam obtenga el mismo ajuste de salario que Joe:

CREATE RULE example_1 AS

ON UPDATE emp.salary WHERE current.name = "Joe"
SQL Server 2000 19

DO UPDATE emp (salary = new.salary)

WHERE emp.name = "Sam";

Al mismo tiempo que Joe recibe un ajuste de salario, el evento será verdadero y la instancia actual de Joe y
la nueva instancia propuesta están disponibles para las rutinas de ejecución. Por lo tanto, este nuevo salario
es sustituido en la parte de acción de la regla que es subsiguientemente ejecutada. Esto propaga el salario
de Joe a Sam.
Hacer que Bill obtenga el salario de Joe cuando es accedido:

CREATE RULE example_2 AS

ON SELECT TO EMP.salary
WHERE current.name = "Bill"
DO INSTEAD
SELECT (emp.salary) from emp
WHERE emp.name = "Joe";

Denegar a Joe el acceso al salario de empleados en el departamento de calzado (current_user devuelve el

nombre del usuario actual):

CREATE RULE example_3 AS

ON SELECT TO emp.salary
WHERE current.dept = "shoe" AND current_user = "Joe"
DO INSTEAD NOTHING;
9
Crear una vista de empleados trabajando en el departamento de juguetes .

CREATE toyemp(name = char16, salary = int4);

CREATE RULE example_4 AS

ON SELECT TO toyemp
DO INSTEAD
SELECT (emp.name, emp.salary) FROM emp
WHERE emp.dept = "toy";

Todos los nuevos empleados deben hacer 5.000 o menos.

CREATE RULE example_5 AS

ON INERT TO emp WHERE new.salary > 5000
DO UPDATE NEWSET salary = 5000;

9
Manual del usuario de PostgreSQL (n.d.). Disponible en URL http://es.tldp.org/Postgresql-es/web/navegable/user/sql-createrule.html
(Mayo 2007).
20 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

3.6 In teg rid ad de dato s: ll aves, con strain ts e í ndi ces.

El término integridad de datos se refiere a la corrección y completitud de los datos en una base de datos.
Habla de las herramientas que permiten mantener los datos libres de modificaciones accidentales o
intencionales. Cuando los contenidos de una base de datos se modifican con sentencias INSERT, DELETE
O UPDATE, la integridad de los datos almacenados puede perderse de muchas maneras diferentes. Por
ejemplo:
Pueden añadirse datos no válidos a la base de datos, tales como un pedido que especifica un producto no
existente.
Pueden modificarse datos existentes tomando un valor incorrecto, como por ejemplo si se reasigna un
vendedor a una oficina no existente.
Los cambios en la base de datos pueden perderse debido a un error del sistema o a un fallo en el suministro
de energía.
Los cambios pueden ser aplicados parcialmente, como por ejemplo si se añade un pedido de un producto
sin ajustar la cantidad disponible para vender.
Una de las funciones importantes de una Base de Datos relacional es preservar la integridad de sus datos
almacenados en la mayor medida posible. Para ello se utilizan estructuras como constraints, llaves e
índices.

Constraints
Son reglas que ofrecen una garantía de integridad en la información vinculada.
Existen 5 tipos de constraints:
 Primary key
La clave primaria se utiliza para identificar en forma única cada línea en la tabla. Puede ser parte de
un registro real, o puede ser un campo artificial (uno que no tiene nada que ver con el registro real).
Una clave primaria puede consistir en uno o más campos en una tabla. Cuando se utilizan múltiples
campos como clave primaria, se les denomina claves compuestas.
Las claves primarias pueden especificarse cuando se crea la tabla (utilizando CREATE TABLE) o
cambiando la estructura existente de la tabla (utilizando ALTER TABLE).
El siguiente es un ejemplo para la especificación de una clave primaria cuando se crea una tabla en
sql server:
SQL Server:
CREATE TABLE Customer
(SID integer PRIMARY KEY,
Last_Name varchar(30),
First_Name varchar(30));

 Foreign key
Una clave externa es un campo (o campos) que señala la clave primaria de otra tabla. El propósito de
la clave externa es asegurar la integridad referencial de los datos. En otras palabras, sólo se permiten
los valores que se esperan que aparezcan en la base de datos.
Por ejemplo, digamos que se tienen dos tablas, una tabla CUSTOMER que incluye todos los datos
del CUSTOMER, y la tabla ÓRDENES que incluye los pedidos del CUSTOMER. La restricción aquí
es que todos los pedidos deben asociarse con un CUSTOMER que ya se encuentra en la tabla
CUSTOMER. En este caso, se coloca una clave externa en la tabla ORDERS y se relaciona con la
SQL Server 2000 21

clave primaria de la tabla CUSTOMER. De esta forma, se asegura que todos los pedidos en la tabla
ORDERS estén relacionados con un CUSTOMER en la tabla CUSTOMER. En otras palabras, la tabla
ORDERS no puede contener información de un CUSTOMER que no se encuentre en la tabla
CUSTOMER.
La estructura de estas dos tablas será la siguiente:

Tabla CUSTOMER Tabla ORDERS

nombre de columna característica nombre de columna característica

SID Clave Primaria Order_ID Clave Primaria
Last_Name Order_Date

First_Name Customer_SID Clave Externa

Amount

En el ejemplo anterior, la columna Customer_SID en la tabla ORDERS es una clave externa señalando la
columna SID en la tabla CUSTOMER.
A continuación se muestra cómo especificar la clave externa a la hora de crear la tabla ORDERS:
SQL Server:
CREATE TABLE ORDERS
(Order_ID integer primary key,
Order_Date datetime,
Customer_SID integer references CUSTOMER(SID),
Amount double);

 Unique key
La restricción UNIQUE asegura que todos los valores en una columna sean distintos.
Por ejemplo, en la siguiente instrucción,
CREATE TABLE Customer
(SID integer Unique,
Last_Name varchar (30),
First_Name varchar(30));
La columna “SID” no puede incluir valores duplicados, mientras dicha restricción no se aplica para
columnas “Last_Name” y “First_Name”.
Una columna que se especifica como clave primaria también puede ser única. Al mismo tiempo, una
columna que es única puede o no ser clave primaria.
 Not Null
En forma predeterminada, una columna puede ser NULL. Si no desea permitir un valor NULL en una
columna, querrá colocar una restricción en esta columna especificando que NULL no es ahora un
valor permitido.
Por ejemplo, en la siguiente instrucción,
CREATE TABLE Customer
(SID integer NOT NULL,
Last_Name varchar (30) NOT NULL,
22 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

First_Name varchar(30));
Las columnas “SID” y “Last_Name” no incluyen NULL, mientras que “First_Name” puede incluir
NULL.
 Check
La restricción CHECK asegura que todos los valores en una columna cumplan ciertas condiciones.
Por ejemplo, en la siguiente instrucción,
CREATE TABLE Customer
(SID integer CHECK (SID > 0),
Last_Name varchar (30),
First_Name varchar(30));
La columna “SID” sólo debe incluir enteros mayores a 0. Las constraints tienen tres propósitos básicos:
1. Forzar integridad. Una constraint con estado ENABLED evita que, sobre las tablas, puedan
modificarse valores de forma que no se satisfaga la regla de la constraint.
Las constraints pueden estar ENABLED o DISABLED (habilitadas o deshabilitadas). Las constraints
habilitadas cumplen éste propósito. Ningún dato introducido o modificado viola la integridad de la regla
de la constraint. De este modo, sobre una primary key ENABLED no se permite un insert sobre una fila
ya existente. No obstante, si la constraint está en el estado ENABLED NOVALIDATE, no se
permitirán cambios que violen la regla, pero no se verificarán que los datos existentes la cumplan.
2. Validar la información. Una constraint con estado DISABLED VALIDATE realiza una validación
sobre los datos, certificando que la información contenida en las tablas satisface la regla de la
constraint.
Las constraints pueden tener un estado VALIDATE o NOVALIDATE independientemente de si están
ENABLED o DISABLED.
Las constraints con VALIDATE cumplen este propósito 2: la información existente está validada. No
obstante, si la constraint está deshabilitada con DISABLED VALIDATE, no se permitirán cambios sobre
las columnas afectadas, ya que aunque la constraint no está habilitada, certifica que los datos existentes
son válidos y cumplen con la regla de la constraint.
3. Asumir la validez de la información. Una constraint con estado RELY no verifica la información, ni
fuerza la integridad para las modificaciones y asume que los datos introducidos satisfacen la regla de la
constraint.
Entonces, las constraints pueden estar en estado RELY o NORELY (también conocido como BELIEF)
cuando las constraints están en estado DISABLED NOVALIDATE.
Las constraints en ese estado cumplen con este propósito 3: Asumen que la información es correcta y
aportan al optimizador información válida para el uso de vistas materializadas, optimización de se desea,
etc. De este modo, por ejemplo, al optimizador le puede resultar mucho más fácil encontrar tablas FACT
o DIMENSION por las constraints de foreign key entre las tablas.
Las constraints DISABLED NOVALIDATE RELY ni validan la información de la tabla, ni comprueban que
las modificaciones cumplen las reglas de las restricciones.
SQL Server 2000 23

Indices10
Es fácil encontrar bases de datos con tablas cuyo tamaño va aumentando de manera considerable
pudiendo contener hasta millones de registros. En estos casos el acceso a determinada información, puede
ser lento y costoso. Habrá operaciones de consulta que obliguen a recorrer la tabla entera, desde su primer
registro hasta el último, esto repercute directamente en la velocidad de la aplicación, convirtiéndola en una
aplicación lenta y pesada. De ahí la importancia del diseño de la base de datos.
Para acelerar el acceso a la información se cuenta con los índices, un índice almacena una serie de claves
que permite al servidor acelerar sus consultas. El índice no sólo sirve para aumentar la velocidad, sirve
además para fijar un orden en los registros, tener registros únicos, etc., de modo que cuando se modifica el
contenido de una tabla en la cual afecta algún índice, SQL SERVER debe modificar los datos de la tabla y
los índices que afectan a la misma.
Un índice tiene un funcionamiento similar al índice de un libro, guardando parejas de elementos: el elemento
que se desea indexar y su posición en la base de datos. Para buscar un elemento que esté indexado, sólo
hay que buscar en el índice dicho elemento para, una vez encontrado, devolver el registro que se encuentre
en la posición marcada por el índice.
Los índices se pueden construir sobre árboles B, B+, B* o sobre una mezcla de ellos.
Para los índices en SQL
 Almacena los datos en páginas de 8 KB
 Un header de 96 bytes vincula estas páginas.
 Los datos en las páginas se almacenan en orden (según la llave de búsqueda).
 El parámetro fill factor se usa para mantener las páginas ordenadas de forma eficiente.
 Al crear el índice ordena las páginas de manera tal que cada una deje cierto porcentaje mínimo
desocupado.
 Un Árbol-B mantiene el índice de las páginas de datos.
 Para crear un índice se usa create index, por ejemplo
create <<modif.>> index mi_indice on tabla atributo
en donde <<modif.>> puede ser unique, clustered, nonclustered.
• unique: virtualmente equivalente a una llave primaria
• clustered: ordena la tabla por el atributo indicado a lo más una por tabla
• nonclustered: no ordena la tabla, pueden ser muchas por tabla.

3.7 Tablas temporal es. 11

En el mundo de las bases de datos es muy común la utilización de tablas temporales. A pesar de que este
tipo de estructuras ralentizan el funcionamiento de las consultas, los programadores no pueden evitar
recurrir a ellas porque muchas veces facilitan la resolución de problemas. Almacenar datos para usarlos

10
Pérez Rojas, Jorge (2006). Bases de Datos – Indexación y Hashing. Disponible en URL
(http://ing.utalca.cl/~jperez/bd/documentos/indices.pdf. (Mayo 2007).
Índice (bases de datos) (n.d.). Disponible en URL http://es.wikipedia.org/wiki/%C3%8Dndice_(base_de_datos). (Mayo 2007).
11
Manivesa, Cesar. Tablas temporales en el SQL Server. Disponible en URL
http://www.programacion.net/bbdd/articulo/man_tablastemp/. (Mayo 2007).
24 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

posteriormente, guardar resultados parciales, analizar grandes cantidades de filas. Hay muchos casos en
los que se pueden necesitar estas tablas temporales.
Tipos de tablas temporales
Las tablas temporales son de dos tipos en cuanto al alcance la tabla. Tenemos tablas temporales locales y
tablas temporales globales.
#locales: Las tablas temporales locales tienen una # como primer carácter en su nombre y sólo se
pueden utilizar en la conexión en la que el usuario las crea. Cuando la conexión termina la tabla temporal
desaparece.
##globales Las tablas temporales globales comienzan con ## y son visibles por cualquier usuario
conectado al SQL Server. Además, estás tablas desaparecen cuando ningún usuario está haciendo
referencias a ellas, no cuado se desconecta el usuario que la creo.
Temp Realmente hay un tipo más de tablas temporales. Si se crea una tabla dentro de la base de datos
temp es una tabla real en cuanto a que se puede utilizar como cualquier otra tabla en cualquier base de
datos, y es temporal en cuanto a que desaparece en cuanto se apaga el servidor.
Funcionamiento de tablas temporales
Crear una tabla temporal es igual que crear una tabla normal. Por ejemplo:
CREATE TABLE #TablaTemporal (Campo1 int, Campo2 varchar(50))
Y se usan de manera habitual.
INSERT INTO #TalbaTemporal VALUES (1,'Primer campo')
INSERT INTO #TalbaTemporal VALUES (2,'Segundo campo')
SELECT * FROM #TablaTemporal
Como vemos no hay prácticamente limitaciones a la hora de trabajar con tablas temporales (una limitación
es que no pueden tener restricciones FOREING KEY).
Optimizar el uso de tablas temporales
El uso que se le puede dar a este tipo de tablas es infinito, pero siempre teniendo en cuenta unas cuantas
directivas que deben seguirse para que ralenticen el trabajo lo menos posible.
Por ejemplo no es mala costumbre crear las tablas temporales con comandos DDL como en el ejemplo
anterior (CREATE TABLE) y luego rellenarlas comandos INSERT o con INSERT INTO. Es cierto que eso
mismo se puede lograr en un único paso con SELECT INTO, pero esta opción es peor porque los bloqueos
que se adquieren sobre objetos del sistema duran más tiempo.
Como siempre es mejor pedir los campos que se quieren y no poner el típico SELCT * FROM... De la misma
manera es muy recomendable calificar las filas que se quieren y no tener filas que no se van a utilizar en
tablas temporales.
Otra buena costumbre es borrar nosotros nuestras tablas. Es cierto que al acabar la conexión las tablas
temporales locales desaparecen, pero si se tiene un conjunto de sentencias largo y se crea una tabla
temporal al principio y se va a utilizar en el resto del tiempo no tiene sentido tener esa tabla ahí ocupando
espacio y memoria.
Si las tablas temporales son grandes una opción para aumentar el rendimiento es crear un índice que ayude
a recuperar los datos de esa tabla (para tablas pequeñas es un gasto inútil porque nunca se usarán los
índices).
Colocar la base de datos tempdb en un disco dedicado solo para esta función aumentará el rendimiento
global del sistema si se hace un uso intensivo de tablas temporales.
Y por último pero no menos importante, no crear tablas temporales dentro de transacciones ni dentro de
triggers. Ya que la concurrencia de la base de datos sufrirá mucho.
SQL Server 2000 25

3.8 V istas. 12
Creación de vistas
A veces, para obtener datos de varias tablas se construye una sentencia SELECT compleja y, si en otro
momento se necesita realizar esa misma consulta, se tiene que construir de nuevo la sentencia SELECT
anterior. Sería bastante cómodo obtener los datos de una consulta compleja con una simple sentencia
SELECT. Las vistas solucionan ese problema. Mediante una consulta simple de una vista cabe la
posibilidad de obtener datos de una consulta compleja. Una vista es una tabla lógica que permite acceder a
la información de una o varias tablas. No contiene información por si misma, sino que su información está
basada en la que contiene una o varias tablas, llamadas tablas base. Si se suprime una tabla, su vista
asociada se invalida. Las vistas tienen la misma estructura que una tabla: filas y columnas y se tratan de
forma muy semejante. El formato para crear una vista es el siguiente:
CREATE VIEW <nombre_vista>
[( columna1 [,( <columna2) ]]
AS <consulta>
Donde:
 nombre_vista es el nombre de la vista.
 columna1, columna2,. . . son los nombres de las columnas que contendrá la vista. Si no se ponen,
se asumirán los nombres de las columnas que devuelva la consulta.
 AS consulta determinará las columnas y tablas que contendrá la vista.
Ejemplo: Crear por ejemplo una vista que contenga parte de las columnas de una tabla EMPLEADO:
CREATE VIEW DEP_30
AS SELECT APELLIDO, OFICIO, SALARIO FROM EMPLEADO WHERE NRO_DEPT=30
De esta manera, se obtiene una vista que contendrá los datos de las columnas APELLIDO, OFICIO y
SALARIO de las filas cuyo NRO_DEPT sea igual a 30.
Se pudo haber creado dando otros nombres a las columnas:
CREATE VIEW DEP_30 (APELL, OFIC, SAL)
AS SELECT APELLIDO, OFICIO, SALARIO FROM EMPLEADO WHERE NRO_DEPT=30

Se puede visualizar los nombres de las vistas creadas con sus textos de la siguiente manera:
SELECT VIEW_NAME, TEXT FROM USER_VIEWS

Borrado de vistas
Es posible borrar las vistas con la orden DROP VIEW:
DROP VIEW <nombre_vista>
Ejemplo:
DROP VIEW DEP_30

12
Creación y uso de vistas (n.d.). Disponible en URL http://www.astable.org/sql/SQL/node23.html
26 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Operaciones sobre vistas

Las operaciones que se pueden realizar sobre vistas son las mismas que las que se pueden llevar a cabo
sobre las tablas. En el caso de las consultas:
 Consulta Se realiza del mismo modo que la consulta de una tabla.
SELECT <columna1>, <columna2>, . . .
FROM <nombre_vista> WHERE <condición>
Ejemplo: Consultar los apellidos de los ENCARGADOS de la vista DEP_30 creada anteriormente de la
siguiente manera:
SELECT APELL
FROM DEP_30
WHERE OFIC='ENCARGADO'
SQL Server 2000 27

CONSU LTAS BÁSICAS

4.1 Instru cci on es para la s elección, orden ami en to y

agrup aci ón d e l a in fo rmaci ón 13 .
Consultas de Selección

L as consultas de selección se utilizan para indicar al motor de datos que devuelve información de las
bases de datos, esta información es devuelta en forma de conjunto de registros que se pueden
almacenar en un objeto recordset. Este conjunto de registros es modificable.
La sintaxis básica de una consulta de selección es la siguiente:

SELECT Campos FROM Tabla;

En donde campos es la lista de campos que se deseen recuperar y tabla es el origen de los mismos, por
ejemplo:

SELECT Nombre, Telefono FROM Clientes;

Esta consulta devuelve un recordset con el campo nombre y teléfono de la tabla clientes.
Criterios de Selección
Antes de comenzar hay que destacar tres detalles de vital importancia. El primero de ellos es que cada vez
que se desee establecer una condición referida a un campo de texto la condición de búsqueda debe ir
encerrada entre comillas simples; la segunda es que no se posible establecer condiciones de búsqueda en
los campos memo y; la tercera y última hace referencia a las fechas.
Las fechas se deben escribir siempre en formato mm-dd-aa en donde mm representa el mes, dd el día y aa
el año, hay que prestar atención a los separadores -no sirve la separación habitual de la barra (/), hay que
utilizar el guión (-) y además la fecha debe ir encerrada entre almohadillas (#). Por ejemplo si deseamos
referirnos al día 3 de Septiembre de 1995 deberemos hacerlo de la siguiente forma;
#09-03-95# ó #9-3-95#.

Operadores Lógicos
Los operadores lógicos soportados por SQL son: AND, OR, XOR, Eqv, Imp, Is y Not.
A excepción de los dos últimos todos poseen la siguiente sintaxis:
<expresión1> operador <expresión2>

13
Casares, Claudio. Tutorial de SQL. Disponible en URL http://www.asptutor.com/zip/sql.pdf. (Mayo 2007)
28 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

En donde expresión1 y expresión2 son las condiciones a evaluar, el resultado de la operación varía en
función del operador lógico. La tabla adjunta muestra los diferentes posibles resultados:

<expresión1> Operador <expresión2> Resultado

Verdad AND Falso Falso
Verdad AND Verdad Verdad
Falso AND Verdad Falso
Falso AND Falso Falso
Verdad OR Falso Verdad
Verdad OR Verdad Verdad
Falso OR Verdad Verdad
Falso OR Falso Falso
Verdad XOR Verdad Falso
Verdad XOR Falso Verdad
Falso XOR Verdad Verdad
Falso XOR Falso Falso
Verdad Eqv Verdad Verdad
Verdad Eqv Falso Falso
Falso Eqv Verdad Falso
Falso Eqv Falso Verdad
Verdad Imp Verdad Verdad
Verdad Imp Falso Falso
Verdad Imp Null Null
Falso Imp Verdad Verdad
Falso Imp Falso Verdad
Falso Imp Null Verdad
Null Imp Verdad Verdad
Null Imp Falso Null
Null Imp Null Null

Si a cualquiera de las anteriores condiciones se le antepone el operador NOT el resultado de la operación

será el contrario al devuelto sin el operador NOT.
El último operador denominado Is se emplea para comparar dos variables de tipo objeto <Objeto1> Is
<Objeto2>. este operador devuelve verdad si los dos objetos son iguales

SELECT * FROM Empleados WHERE Edad > 25 AND Edad < 50;
SELECT * FROM Empleados WHERE (Edad > 25 AND Edad < 50) OR Sueldo = 100;
SELECT * FROM Empleados WHERE NOT Estado = 'Soltero';
SQL Server 2000 29

SELECT * FROM Empleados WHERE (Sueldo > 100 AND Sueldo < 500) OR (Provincia =
'Madrid' AND Estado = 'Casado');

Intervalos de Valores
Para indicar que se desean recuperar los registros según el intervalo de valores de un campo se emplea el
operador Between cuya sintaxis es:
campo [Not] Between valor1 And valor2 (la condición Not es opcional)

En este caso la consulta devolvería los registros que contengan en "campo" un valor incluido en el intervalo
valor1, valor2 (ambos inclusive). Si se antepone la condición Not devolverá aquellos valores no incluidos en
el intervalo.

SELECT * FROM Pedidos WHERE CodPostal Between 28000 And 28999;

(Devuelve los pedidos realizados en la provincia de Madrid)

SELECT IIf(CodPostal Between 28000 And 28999, 'Provincial', 'Nacional')

FROM Editores;
(Devuelve el valor 'Provincial' si el código postal se encuentra en el
intervalo,'Nacional' en caso contrario).

Ordenar los Registros

Adicionalmente se puede especificar el orden en que se desean recuperar los registros de las tablas
mediante la cláusula ORDER BY Lista de Campos. En donde Lista de campos representa los campos a
ordenar. Ejemplo:
SELECT CodigoPostal, Nombre, Telefono FROM Clientes ORDER BY Nombre;
Esta consulta devuelve los campos CodigoPostal, Nombre, Telefono de la tabla Clientes ordenados por el
campo Nombre.
Se pueden ordenar los registros por más de un campo, como por ejemplo:
SELECT CodigoPostal, Nombre, Telefono FROM Clientes ORDER BY CodigoPostal,
Nombre;
Incluso se puede especificar el orden de los registros: ascendente mediante la cláusula ASC (se toma este
valor por defecto) ó descendente (DESC).
SELECT CodigoPostal, Nombre, Telefono FROM Clientes ORDER BY CodigoPostal DESC ,
Nombre ASC. [14]

Agrupación de Información
La sentencia "Select" posibilita agrupar uno o más conjuntos de filas. El agrupamiento se lleva a cabo
mediante la cláusula "GROUP BY" por las columnas especificadas y en el orden especificado. Formato:
SELECT…
FROM…
GROUP BY COLUMNA1, COLUMNA2, COLUMNAN…
HAVING CONDICION
GROUP BY …
30 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Los datos seleccionados en la sentencia "Select" que lleva el "Group By" deben ser:
 Una constante.
 Una función de grupo (SUM, COUNT, AVG…)
 Una columna expresada en el Group By.
La cláusula Group By sirve para calcular propiedades de uno o más conjuntos de filas. Si se selecciona más
de un conjunto de filas, Group By controla que las filas de la tabla original sean agrupadas en un temporal.
La cláusula Having se emplea para controlar cual de los conjuntos de filas se visualiza. Se evalúa sobre la
tabla que devuelve el Group By. No puede existir sin Group By.
Having es similar al Where, pero trabajo con grupos de filas; pregunta por una característica de grupo, es
decir, pregunta por los resultados de las funciones de grupo, lo cual Where no pude hacer. [14]

4.2 Instru cci on es para la i n serci ón, actualiz ación y

borrad o d e in fo rmació n.
Inserción
INSERT INTO agrega un registro en una tabla. Se la conoce como una consulta de datos añadidos. Esta
consulta puede ser de dos tipos: Insertar un único registro ó Insertar en una tabla los registros contenidos
en otra tabla.
Para insertar un único Registró.
En este caso la sintaxis es la siguiente:
INSERT INTO tabla (columna1, columna2, …) VALUES (valor1, valor2, …);
Esta consulta graba en el campo1 el valor1, en el campo2 y valor2 y así sucesivamente. Hay que prestar
especial atención a acotar entre comillas simples (') los valores literales (cadenas de caracteres) y las
fechas indicarlas en formato mm-dd-aa y entre caracteres de almohadillas (#).
Para insertar Registros de otra Tabla:
En este caso la sintaxis es:
INSERT INTO Tabla [IN base_externa] (campo1, campo2, ..., campoN) SELECT
TablaOrigen.campo1, TablaOrigen.campo2, ..., TablaOrigen.campoN FROM TablaOrigen
En este caso se seleccionarán los campos 1,2, ..., n de la tabla origen y se grabarán en los campos 1,2,.., n
de la Tabla. La condición SELECT puede incluir la cláusula WHERE para filtrar los registros a copiar. Si
Tabla y TablaOrigen poseen la misma estructura se puede simplificar la sintaxis a:
INSERT INTO Tabla SELECT TablaOrigen.* FROM TablaOrigen
De esta forma los campos de TablaOrigen se grabarán en Tabla, para realizar esta operación es necesario
que todos los campos de TablaOrigen estén contenidos con igual nombre en Tabla. Con otras palabras que
Tabla posea todos los campos de TablaOrigen (igual nombre e igual tipo).
En este tipo de consulta hay que tener especial atención con los campos contadores o autonuméricos
puesto que al insertar un valor en un campo de este tipo se escribe el valor que contenga su campo
homólogo en la tabla origen, no incrementándose como le corresponde.
Se puede utilizar la instrucción INSERT INTO para agregar un registro único a una tabla, utilizando la
sintaxis de la consulta de adición de registro único. En este caso, su código específica el nombre y el valor
de cada campo del registro. Debe especificar cada uno de los campos del registro al que se le va a asignar
SQL Server 2000 31

un valor así como el valor para dicho campo. Cuando no se especifica dicho campo, se inserta el valor
predeterminado o Null. Los registros se agregan al final de la tabla.
También se puede utilizar INSERT INTO para agregar un conjunto de registros pertenecientes a otra tabla o
consulta utilizando la cláusula SELECT. FROM como se mostró anteriormente en la sintaxis de la consulta
de adición de múltiples registros. En este caso la cláusula SELECT especifica los campos que se van a
agregar en la tabla destino especificada. La tabla destino u origen puede especificar una tabla o una
consulta.
Si la tabla destino contiene una clave principal, hay que asegurarse que es única, y con valores no-Null; si
no es así, no se agregarán los registros. Si se agregan registros a una tabla con un campo Contador, no se
debe incluir el campo Contador en la consulta. Se puede emplear la cláusula IN para agregar registros a
una tabla en otra base de datos.
Se pueden averiguar los registros que se agregarán en la consulta ejecutando primero una consulta de
selección que utilice el mismo criterio de selección y ver el resultado. Una consulta de adición copia los
registros de una o más tablas en otra. Las tablas que contienen los registros que se van a agregar no se
verán afectadas por la consulta de adición. En lugar de agregar registros existentes en otra tabla, se puede
especificar los valores de cada campo en un nuevo registro utilizando la cláusula VALUES. Si se omite la
lista de campos, la cláusula VALUES debe incluir un valor para cada campo de la tabla, de otra forma fallará
INSERT. [14]

INSERT INTO Clientes SELECT Clientes_Viejos.* FROM Clientes_Nuevos;

INSERT INTO Empleados (Nombre, Apellido, Cargo)
VALUES ('Luís', 'Sánchez', 'Becario');
INSERT INTO Empleados SELECT Vendedores.* FROM Vendedores
WHERE Fecha_Contratacion < Now() - 30;

Actualización
UPDATE crea una consulta de actualización que cambia los valores de los campos de una tabla
especificada basándose en un criterio específico. Su sintaxis es:
UPDATE Tabla SET Campo1=Valor1, Campo2=Valor2, ... CampoN=ValorN WHERE
Condición;
UPDATE es especialmente útil cuando se desea cambiar un gran número de registros o cuando éstos se
encuentran en múltiples tablas. Puede cambiar varios campos a la vez. El ejemplo siguiente incrementa los
valores Cantidad pedidos en un 10 por ciento y los valores Transporte en un 3 por ciento para aquellos que
se hayan enviado al Reino Unido.:
UPDATE Pedidos SET Pedido = Pedidos * 1.1, Transporte = Transporte * 1.03
WHERE PaisEnvío = 'ES';
UPDATE no genera ningún resultado. Para saber qué registros se van a cambiar, hay que examinar primero
el resultado de una consulta de selección que utilice el mismo criterio y después ejecutar la consulta de
actualización.

UPDATE Empleados SET Grado = 5 WHERE Grado = 2;

UPDATE Productos SET Precio = Precio * 1.1 WHERE Proveedor = 8 AND Familia = 3;

Si en una consulta de actualización suprimimos la cláusula WHERE todos los registros de la tabla señalada
serán actualizados.

UPDATE Empleados SET Salario = Salario * 1.1 [14]

32 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Borrado
DELETE crea una consulta de eliminación que elimina los registros de una o más de las tablas listadas en la
cláusula FROM que satisfagan la cláusula WHERE. Esta consulta elimina los registros completos, no es
posible eliminar el contenido de algún campo en concreto. Su sintaxis es:

DELETE Tabla.* FROM Tabla WHERE condición.

DELETE es especialmente útil cuando se desea eliminar varios registros. En una instrucción DELETE con
múltiples tablas, debe incluir el nombre de tabla (Tabla.*). Si especifica más de una tabla desde la que
eliminar registros, todas deben ser tablas de muchos a uno. Si desea eliminar todos los registros de una
tabla, eliminar la propia tabla es más eficiente que ejecutar una consulta de borrado.
Se puede utilizar DELETE para eliminar registros de una única tabla o desde varios lados de una relación
uno a muchos. Las operaciones de eliminación en cascada en una consulta únicamente eliminan desde
varios lados de una relación. Por ejemplo, en la relación entre las tablas Clientes y Pedidos, la tabla Pedidos
es la parte de muchos por lo que las operaciones en cascada solo afectaran a la tabla Pedidos. Una
consulta de borrado elimina los registros completos, no únicamente los datos en campos específicos. Si
desea eliminar valores en un campo especificado, crear una consulta de actualización que cambie los
valores a Null.
Una vez que se han eliminado los registros utilizando una consulta de borrado, no puede deshacer la
operación. Si se quiere saber qué registros se eliminarán, primero hay que examinar los resultados de una
consulta de selección que utilice el mismo criterio y después ejecutar la consulta de borrado. Se debe tener
copias de seguridad de los datos en todo momento. Si se eliminan los registros equivocados se podrán
recuperar desde las copias de seguridad.
DELETE * FROM Empleados WHERE Cargo = 'Vendedor'. [17, 18]14

4.3 Fun cio nes matemáti cas, de cadena, fechas y

otras.
Funciones para el manejo de fechas:

SYSDATE= Devuelve la fecha del sistema.

ADD_MONTHS (fecha, n)= Devuelve la fecha "fecha" incrementada en "n" meses.

LASTDAY (fecha)= Devuelve la fecha del último día del mes que contiene "fecha".

MONTHS_BETWEEN (fecha1, fecha2)= Devuelve la diferencia en meses entre las fechas

"fecha1" y "fecha2".

NEXT_DAY (fecha, cad)= Devuelve la fecha del primer día de la semana indicado por
"cad" después de la fecha indicada por "fecha".

14
Álvarez Marañón, Gonzalo (1997 – 2002). Acceso a BD. Disponible en URL http://www.iec.csic.es/criptonomicon /bd/repaso.html.
(Mayo 2007).
SQL Server 2000 33

Funciones que devuelven valores de caracteres:

CHR(n) = Devuelve el carácter cuyo valor en binario es equivalente a "n".

CONCAT (cad1, cad2)= Devuelve "cad1" concatenada con "cad2".

LOWER (cad)= Devuelve la cadena "cad" en minúsculas.

UPPER (cad)= Devuelve la cadena "cad" en mayúsculas.

INITCAP (cad)= Convierte la cadena "cad" a tipo titulo

LPAD (cad1, n[,cad2])= Añade caracteres a la izquierda de la cadena hasta que tiene
una cierta longitud.

RPAD (cad1, n[,cad2])= Añade caracteres a la derecha de la cadena hasta que tiene una
cierta longitud.

LTRIM (cad [,set])= Suprime un conjunto de caracteres a la izquierda de la cadena.

RTRIM (cad [,set])= Suprime un conjunto de caracteres a la derecha de la cadena.

REPLACE (cad, cadena_busqueda Sustituye un carácter o caracteres de una cadena

[, cadena_sustitucion])= con 0 o mas caracteres.

SUBSTR (cad, m [,n])= Obtiene parte de una cadena.

TRANSLATE (cad1, cad2, cad3)= Convierte caracteres de una cadena en caracteres

diferentes, según un plan de sustitución marcado por el
usuario.

Funciones que devuelven valores numéricos:

ASCII(cad)= Devuelve el valor ASCII de la primera letra de la cadena "cad".

INSTR (cad1, cad2 [, comienzo [,m]])= Permite una búsqueda de un conjunto de

caracteres en una cadena pero no suprime ningún
carácter después.

LENGTH (cad)= Devuelve el numero de caracteres de cad.

Funciones cadenas15:
 CONCAT(cadena1,cadena2) Devuelve una cadena resultante de concatenar 'cadena1' y 'cadena2'.
 LOWER(ch) Devuelve la cadena 'ch' con todas sus letras convertidas a minúsculas.
 UPPER(ch) Devuelve la cadena 'ch' con todas sus letras convertidas a mayúsculas.

15
. Funciones de cadenas de caracteres (n.d.). Disponible en URL http://www.astable.org/sql/SQL/node48.html. (Mayo 2007)
34 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Funciones aritméticas
 ABS(n) Devuelve el valor absoluto de n.
 POWER(n, exp) Devuelve la potencia de un número.
 AVG(n) Calcula el valor medio de n, ignorando los valores nulos.
SELECT AVG(EDAD) FROM EMPLEADOS
 COUNT(* | expresión) Cuenta el número de veces que 'expresión' evalúa algún dato.
SELECT COUNT(*) FROM EMPLEADOS
 MAX(expresión) Calcula el valor máximo de 'expresión'.
SELECT MAX(SALARIO) FROM EMPLEADOS
 MIN(expresión) Calcula el valor mínimo de 'expresión'.
SELECT MIN(SALARIO) FROM EMPLEADOS
 SUM(expresión) Calcula la suma de valores de 'expresión'.
SELECT SUM(SALARIO) FROM EMPLEADOS
 DISTINCT En las funciones de grupo se pueden indicar DISTINCT y ALL como argumentos. Su
uso más normal es en COUNT
SELECT COUNT(OFICIO) FROM EMPLEADOS
SELECT COUNT(DISTINCT OFICIO) FROM EMPLEADOS
SELECT SUM

Otras funciones
DUMP( columna ) Retorna información de almacenamiento para la columna indicada.
GREATEST( expr1, expr2 , ... Retorna la expresión mayor.
 CONSU LTAS AVA NZADAS
CON SQL 16

5.1 S ub con sul tas.

U na subconsulta es una instrucción SELECT anidada dentro de otra instrucción SELECT: SELECT
INTO, INSERT INTO, DELETE, o UPDATE o dentro de otra subconsulta. Los formatos para las
instrucciones de subconsultas son las siguientes:
WHERE expression [NOT] IN (subconsulta)
WHERE expression operador_comparacion [ANY | ALL] (subconsulta)
WHERE [NOT] EXISTS (subconsulta )
Una subconsulta puede devolver:
1. Una sola columna o un solo valor en cualquier lugar en donde pueda utilizarse una expresión de
un sólo valor y puede compararse usando los siguientes operadores: =,<,>,<=,>= ,<>,!> y !<.
2. Una sola columna o muchos valores que se pueden utilizar con el operador de comparación de
listas IN en la cláusula WHERE.
3. Muchas filas que pueden utilizarse para comprobar la existencia, usando la palabra EXISTS en la
cláusula WHERE.
Se puede usar el predicado ANY o SOME, para recuperar registros de la consulta principal, que
satisfagan la comparación con cualquier otro registro recuperado en la subconsulta.
Ejemplo: El siguiente ejemplo muestra los titulos que recibieron adelanto superior a la cantidad
adelantada mínima pagada por Algodata Infosystem
USE pubs
go
SELECT title
FROM titles
WHERE advance > ANY
(SELECT advance
FROM publishers INNER JOIN titles
ON titles.pub_id = publishers.pub_id
AND pub_name = ‘Algodata Infosystems’)

En ejemplo anterior se usa el operador de comparación >, es así que, >ALL significa mayor que
cualquier valor; es decir, mayor que el valor máximo. Por ejemplo, >ALL (1, 2, 3,....7) significa mayor
que 7. De manera similar, >ANY significa mayor que, como mínimo, un valor, es decir, mayor que el
mínimo. En consecuencia, >ANY (1, 2, 3, ... 7) significa mayor que 1.

16
Reyes Paredes P.” Subconsultas para SQL Server”. “Cómo aprovechar la funcionalidad de una subconsulta”. 2005.
<http://www.elguille.info/colabora/NET2005/Percynet_Subconsultas_en_SQL_Server.htm> (04/Oct/2005)
36 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

En el proceso de trabajo con subconsultas, necesariamente manejaremos dos tipos de consultas:

consultas internas y consultas externas. Las consultas internas no es más que las subconsultas
propiamente dichas y las consultas externas es aquella que hace uso de los resultados devueltos por la
consulta interna o subconsulta. También se hará uso del predicado IN. La consulta externa usa el
predicado IN para operar con los valores devueltos por la subconsulta. Ejemplo:
Lista los campos ProductID, ProductName,UnitsInStock,UnitPrice de todos los productos vendidos en
una cantidad mayor e igual a 100
SELECT ProductID, ProductName,UnitsInStock,UnitPrice
FROM Products
WHERE ProductID IN
( SELECT ProductID
FROM [ORDER DETAILS]
WHERE Quantity>=100 ) ORDER BY ProductName
Por otra parte, cuando se presenta una subconsulta con la palabra clave EXISTS, funciona como una
prueba de existencia. La cláusula WHERE de la consulta externa comprueba la existencia de las filas
devueltas por la subconsulta. La subconsulta en realidad no produce ningún dato, devuelve el valor
TRUE o FALSE.

Subconsultas en las instrucciones UPDATE, DELETE e INSERT

Es posible anidar las subconsultas en este tipo de instrucciones. Para entender mejor esta parte
haremos uso de unos ejemplos.
INSERT

UPDATE

DELETE
SQL Server 2000 37

Rendimiento y resultados
En muchos casos puede usarse una operación de combinación en lugar de una consulta, no obstante
algunas instancias pueden procesarse sólo con una subconsulta. En ocasiones una operación de
combinación puede producir un mejor rendimiento que una subconsulta, pero por lo general se observa
muy poca diferencia en el rendimiento. Sin embargo, el uso de grandes anidamientos de subconsultas
puede afectar seriamente el rendimiento. De manera general la utilización de combinaciones producirá
los mejores resultados. Veamos un ejemplo:
Haciendo uso de una subconsulta podríamos realizar la siguiente consulta:

Formulando la anterior subconsulta como una combinación:

La subconsulta siempre está encerrada entre paréntesis y a menos que se vaya a ejecutar una
subconsulta correlacionada termina antes de que se procese la consulta externa. Una subconsulta
puede contener otra subconsulta, y esta subconsulta puede, a su vez, contener otra subconsulta, y así
sucesivamente. Los recursos del sistema (como la memoria disponible) limitan el número de
subconsultas que pueden procesarse. Se puede anidar subconsultas hasta 32 niveles, pero esto como
se menciono anteriormente, depende de los recursos disponibles del sistema. He aquí otro “botón” como
ejemplo:
Lista los campos CATEGORYID,CATEGORYNAME de la tabla categorías donde el producto de dicha
categoría tiene los campos UNITPRICE y QUANTITY iguales y además UNITPRICE está entre 4 y 42.
Toda esta información será ordenada descendentemente por el campo CATEGORYNAME.
SELECT CATEGORYID,CATEGORYNAME
FROM CATEGORIES
WHERE CATEGORYID IN
(SELECT CATEGORYID
FROM PRODUCTS
WHERE UNITPRICE IN
(SELECT QUANTITY
FROM [ORDER DETAILS]
WHERE UNITPRICE BETWEEN 40 AND 42)
)
ORDER BY CATEGORYNAME DESC
38 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Formulando la anterior subconsulta como una combinación

5.2 Inn er j oin s y ou ter joi n s.

Habitualmente cuando necesitamos recuperar la información de una base de datos nos encontramos
con que dicha información se encuentra repartida en varias tablas, referenciadas a través de varios
códigos. De este modo si tuviéramos una tabla de ventas con un campo cliente, dicho campo contendría
el código del cliente de la tabla de cliente.
Sin embargo está forma de almacenar la información no resulta muy útil a la hora de consultar los datos.
SQL nos proporciona una forma fácil de mostrar la información repartida en varias tablas, las
consultas combinadas o JOINS.
Las consultas combinadas pueden ser de tres tipos:

Combinación interna.
La combinación interna nos permite mostrar los datos de dos o más tablas a través de una condición
WHERE. Para realizar la consulta combinada entre estas dos tablas debemos escribir una consulta
SELECT en cuya cláusula FROM escribiremos el nombre de las dos tablas, separados por comas, y una
condición WHERE que obligue a que el código de marca de la tabla de coches sea igual al código de la
tabla de marcas.
Lo más sencillo es ver un ejemplo directamente:
SELECT tCoches.matricula,
tMarcas.marca,
tCoches.modelo,
tCoches.color,
tCoches.numero_kilometros,
tCoches.num_plazas
FROM tCoches, tMarcas
WHERE tCoches.marca = tMarcas.codigo
Démonos cuenta que hemos antepuesto el nombre de cada tabla al nombre del campo, esto no es
obligatorio si los nombres de campos no se repiten en las tablas, pero es aconsejable para evitar
conflictos de nombres entre campos. Por ejemplo, si para referirnos al campo marca no anteponemos el
nombre del campo la base de datos no sabe si queremos el campo marca de la tabla tCoches, que
contiene el código de la marca, o el campo marca de la tabla tMarcas, que contiene el nombre de la
marca.
Otra opción es utilizar la cláusula INNER JOIN. Su sintaxis es idéntica a la de una consulta SELECT
habitual, con la particularidad de que en la cláusula FROM sólo aparece una tabla o vista, añadiéndose
el resto de tablas a través de cláusulas.
INNER JOIN . SELECT [ALL | DISTINCT ]
<nombre_campo> [{,<nombre_campo>}]
FROM <nombre_tabla>
[{INNER JOIN <nombre_tabla> ON <condicion_combinacion>}]
[WHERE <condicion> [{ AND|OR <condicion>}]]
[GROUP BY <nombre_campo> [{,<nombre_campo >}]]
SQL Server 2000 39

[HAVING <condicion>[{ AND|OR <condicion>}]]

[ORDER BY <nombre_campo>|<indice_campo> [ASC | DESC]
[{,<nombre_campo>|<indice_campo> [ASC | DESC ]}]]
El ejemplo anterior escrito utilizando la cláusula INNER JOIN quedaría de la siguiente manera:
SELECT tCoches.matricula,
tMarcas.marca,
tCoches.modelo,
tCoches.color,
tCoches.numero_kilometros,
tCoches.num_plazas
FROM tCoches
INNER JOIN tMarcas ON tCoches.marca = tMarcas.codigo
La cláusula INNER JOIN permite separar completamente las condiciones de combinación con otros
criterios, cuando tenemos consultas que combinan nueve o diez tablas esto realmente se agradece. Sin
embargo muchos programadores no son amigos de la cláusula INNER JOIN, la razón es que uno de
los principales gestores de bases de datos.
Combinación Externa
La combinación interna es excluyente. Esto quiere decir que si un registro no cumple la condición de
combinación no se incluye en los resultados. De este modo en el ejemplo anterior si un coche no tiene
grabada la marca no se devuelve en mi consulta.
Según la naturaleza de nuestra consulta esto puede ser una ventaja, pero en otros casos significa un
serio problema. Para modificar este comportamiento SQL pone a nuestra disposición la combinación
externa. La combinación externa no es excluyente.
La sintaxis es muy parecida a la combinación interna:
SELECT [ALL | DISTINCT ]
<nombre_campo> [{,<nombre_campo>}]
FROM <nombre_tabla>
[{LEFT|RIGHT OUTER JOIN <nombre_tabla> ON <condicion_combinacion>}]
[WHERE <condicion> [{ AND|OR <condicion>}]]

[GROUP BY <nombre_campo> [{,<nombre_campo >}]]

[HAVING <condicion>[{ AND|OR <condicion>}]]
[ORDER BY <nombre_campo>|<indice_campo> [ASC | DESC]
[{,<nombre_campo>|<indice_campo> [ASC | DESC ]}]]
La combinación externa puede ser diestra o siniestra, LEFT OUTER JOIN o RIGHT OUTER JOIN.
Con LEFT OUTER JOIN obtenemos todos los registros de en la tabla que situemos a la izquierda de
la cláusula JOIN, mientras que con RIGHT OUTER JOIN obtenemos el efecto contrario.
Como mejor se ve la combinación externa es con un ejemplo:
SELECT tCoches.matricula,
tMarcas.marca,
tCoches.modelo,
tCoches.color,
tCoches.numero_kilometros,
tCoches.num_plazas
FROM tCoches
LEFT OUTER JOIN tMarcas ON tCoches.marca = tMarcas.codigo

Esta consulta devolverá todos los registros de la tabla tCoches, independientemente de que tengan
marca o no. En el caso de que el coche no tenga marca se devolverá el valor null para los campos de
la tabla tMarcas.
40 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Visualmente (la consulta devuelve los datos en azul).

El mismo ejemplo con RIGHT OUTER JOIN.

SELECT tCoches.matricula,
tMarcas.marca,
tCoches.modelo,
tCoches.color,
tCoches.numero_kilometros,
tCoches.num_plazas
FROM tCoches
RIGHT OUTER JOIN tMarcas ON tCoches.marca = tMarcas.codigo

Esta consulta devolverá los registros de la tabla tCoches que tengan marca relacionada y todos los
registros de la tabla tMarcas, tengan algún registro en tCoches o no.
Visualmente (la consulta devuelve los datos en azul).

Unión
La cláusula UNION permite unir dos o más conjuntos de resultados en uno detrás del otro como si se
tratase de una única tabla. De este modo podemos obtener los registros de más de una tabla “unidos”.
La sintaxis corresponde a la de varias SELECT unidas a través de UNION, como se muestra a
continuación:
SELECT [ALL | DISTINCT ]
<nombre_campo> [{,<nombre_campo>}]
FROM <nombre_tabla>
[{LEFT|RIGHT OUTER JOIN <nombre_tabla> ON <condicion_combinacion>}]
[WHERE <condicion> [{ AND|OR <condicion>}]]
[GROUP BY <nombre_campo> [{,<nombre_campo >}]]
[HAVING <condicion>[{ AND|OR <condicion>}]]
{
UNION [ALL | DISTINCT ]
SELECT [ALL | DISTINCT ]
<nombre_campo> [{,<nombre_campo>}]
FROM <nombre_tabla>
[{LEFT|RIGHT OUTER JOIN <nombre_tabla> ON <condicion_combinacion>}]
[WHERE <condicion> [{ AND|OR <condicion>}]]
[GROUP BY <nombre_campo> [{,<nombre_campo >}]]
[HAVING <condicion>[{ AND|OR <condicion>}]]
}
SQL Server 2000 41

[ORDER BY <nombre_campo>|<indice_campo> [ASC | DESC]

[{,<nombre_campo>|<indice_campo> [ASC | DESC ]}]]
Para utilizar la cláusula UNION debemos cumplir una serie de normas.
Las consultas a unir deben tener el mismo número campos, y además los campos deben ser del mismo
tipo.
Sólo puede haber una única cláusula ORDER BY al final de la sentencia SELECT.
El siguiente ejemplo muestra el uso de UNION:
SELECT tCoches.matricula,
tMarcas.marca,
tCoches.modelo,
tCoches.color,
tCoches.numero_kilometros,
tCoches.num_plazas
FROM tCoches
INNER JOIN tMarcas ON tCoches.marca = tMarcas.codigo
UNION
SELECT tMotos.matricula,
tMarcas.marca,
tMotos.modelo,
tMotos.color,
tMotos.numero_kilometros,
0
FROM tCoches
INNER JOIN tMarcas ON tCoches.marca = tMarcas.codigo;17

17
Sánchez Herrarte P. “Consultas combinadas. JOINS”. “Consultas combinadas”. 2005.
<http://www.devjoker.com/asp/ver_contenidos.aspx?co_contenido=17> (22/10/2005)
42 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

TRANSACT SQL Y
PROCEDIMIENTOS
ALMACENADOS

T RANSACT - SQL: Ésta es una versión de SQL (Structured Query Languaje) usada como lenguaje
de programación para SQL Server. SQL es un conjunto de comandos que permite especificar la
información que se desea restaurar o modificar. Con Transact – SQL se puede tener acceso a la
información, realizar búsquedas, actualizar y administrar sistemas de Bases de Datos Relacionales.
Los procedimientos almacenados son un conjunto precompilado de instrucciones Transact-SQL (*)
almacenadas bajo un solo nombre y procesadas como una unidad. Los procedimientos almacenados
pueden recibir parámetros - en base a los cuales realizar distintas acciones - y devolver datos de varias
formas distintas (principalmente como parámetros de salida y como conjuntos de resultados o
Recordsets).
Los procedimientos almacenados están compilados. Traducción básica: El conjunto de instrucciones
que utiliza el equipo para llevar a cabo la operación solicitada se divide hasta el menor nivel posible
disponible en la plataforma en la que está trabajando. (Punto crucial: la velocidad.) La alternativa sería
crear consultas y tareas de mantenimiento de bases de datos que se ejecutaran cada vez que se
enviara la petición, lo que exigiría de su SQL Server mucho más trabajo del necesario.
Hay otras muchas ventajas por utilizar y crear procedimientos almacenados, como la capacidad de
administrar de manera centralizada las tareas reutilizables.

6.1 Característi cas y ven taj as.

Los procedimientos almacenados ofrecen ventajas importantes:
Rendimiento: al ser ejecutados por el motor de base de datos ofrecen un rendimiento inmejorable ya
que no es necesario transportar datos a ninguna parte. Cualquier proceso externo tiene una penalidad
de tiempo adicional dada por el transporte de datos. Los procedimientos almacenados son analizados y
optimizados en el momento de su creación, a diferencia de las instrucciones Transact-SQL, que deben
ser analizadas, compiladas y optimizadas cada vez que son enviadas por el cliente. Además, el motor
de SQL Server es capaz de reutilizar el plan de ejecución del procedimiento almacenado que se
encuentra en la memoria caché de procedimientos, después de haberse ejecutado una primera vez.
Potencia: el lenguaje para procedimientos almacenados es muy potente. Permiten ejecutar operaciones
complejas en pocos pasos ya que poseen un conjunto de Instrucciones avanzadas.
Centralización: al formar parte de la base de datos los procedimientos almacenados están en un lugar
centralizado y pueden ser ejecutados por cualquier aplicación que tenga acceso a la misma. Si un
determinado proceso se desarrolló con una aplicación como Delphi, es posible que no esté disponible
en todos los lugares que se le necesite, por ejemplo: el sistema operativo UNIX. Los procedimientos
almacenados están siempre disponibles.
SQL Server 2000 43

Reducción del tráfico de red

Una sentencia formada por decenas, cientos o incluso miles de líneas de código Transact-SQL puede
escribirse como un procedimiento almacenado en el servidor y ejecutarse simplemente mediante el
nombre de dicho procedimiento, en lugar de enviar todas las líneas de código por la red desde el cliente
hasta el servidor (ésta reducción del tráfico de red será especialmente significativa en redes no muy
veloces, como por ejemplo, algunas redes WAN).
Seguridad
Los procedimientos almacenados facilitan algunas tareas de administración de seguridad y asignación
de permisos. Por ejemplo, se puede conceder permiso a un usuario para ejecutar un determinado
procedimiento almacenado, aunque el usuario no disponga de los permisos necesarios sobre los objetos
afectados por las acciones individuales de dicho procedimiento.
18
Encapsulación
Los procedimientos almacenados encapsulan gran parte de la lógica de los datos a las aplicaciones que
los utilizan. Por ejemplo, una aplicación puede llamar al procedimiento almacenado sp Eliminar
Proveedor sin conocer cómo funciona internamente éste proceso (transacciones e instrucciones
Transact-SQL utilizadas, tablas afectadas, etc.).

6.2 Co mand o Set .

El lenguaje de programación Transact-SQL ofrece varias instrucciones SET que cambian el tratamiento
de información específica por parte de la sesión actual. Las instrucciones SET se agrupan en las
categorías que figuran en la siguiente tabla:

Categoría Instrucciones

Instrucciones de fecha y hora SET DATEFIRST

SET DATEFORMAT

Instrucciones de bloqueo SET DEADLOCK_PRIORITY

SET LOCK_TIMEOUT

Otras instrucciones SET CONCAT_NULL_YIELDS_NULL

SET CURSOR_CLOSE_ON_COMMIT
SET FIPS_FLAGGER
SET IDENTITY_INSERT
SET LANGUAGE
SET OFFSETS
SET QUOTED_IDENTIFIER

Instrucciones de ejecución de consultas SET ARITHABORT

SET ARITHIGNORE
SET FMTONLY
SET NOCOUNT
SET NOEXEC

18
Ponce T.(2006). SQL.Procedimientos almacenados http://www.mygnet.co/articulos/sql/775/index.php (23/08/2006).
44 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

SET NUMERIC_ROUNDABORT
SET PARSEONLY
SET QUERY_GOVERNOR_COST_LIMIT
SET ROWCOUNT
SET TEXTSIZE

Instrucciones de configuración de SQL-92 SET ANSI_DEFAULTS

SET ANSI_NULL_DFLT_OFF
SET ANSI_NULL_DFLT_ON
SET ANSI_NULLS
SET ANSI_PADDING
SET ANSI_WARNINGS

Instrucciones de estadísticas SET FORCEPLAN

SET SHOWPLAN_ALL
SET SHOWPLAN_TEXT
SET SHOWPLAN_XML
SET STATISTICS IO
SET STATISTICS XML
SET STATISTICS PROFILE
SET STATISTICS TIME

Instrucciones de transacciones SET IMPLICIT_TRANSACTIONS

SET REMOTE_PROC_TRANSACTIONS
SET TRANSACTION ISOLATION LEVEL
SET XACT_ABORT

Consideraciones al utilizar las instrucciones SET

Todas las instrucciones SET se implementan en tiempo de ejecución, salvo SET FIPS_FLAGGER, SET
OFFSETS, SET PARSEONLY y SET QUOTED_IDENTIFIER. Estas instrucciones se implementan en
tiempo de análisis.
Si se ejecuta una instrucción SET en un procedimiento almacenado o desencadenador, el valor de la
opción SET se restaura cuando el control vuelve del procedimiento almacenado o desencadenador.
Además, si se especifica una instrucción SET en una cadena de SQL dinámico que se ejecuta mediante
sp_executesql o EXECUTE, el valor de la opción SET se restaura cuando el control vuelve del lote
especificado en la cadena de SQL dinámico.
Los procedimientos almacenados se ejecutan con las opciones de SET especificadas en tiempo de
ejecución, excepto en el caso de SET ANSI_NULLS y SET QUOTED_IDENTIFIER. Los procedimientos
almacenados que utilizan SET ANSI_NULLS o SET QUOTED_IDENTIFIER usan las opciones
especificadas en el momento de crear el procedimiento almacenado. Si se usan dentro de un
procedimiento almacenado, las opciones SET no tienen ningún efecto.
La opción user options de sp_configure permite aplicar opciones a todo el servidor y sirve para múltiples
bases de datos. Además, esta opción se comporta como una instrucción SET explícita, pero con la
diferencia de que tiene lugar en el momento de iniciar la sesión.
Las opciones de base de datos establecidas con ALTER DATABASE sólo son válidas en el nivel de
base de datos y sólo tienen efecto cuando se establecen explícitamente. Las opciones de base de datos
anulan las opciones de instancia que se establecen mediante sp_configure.
En cualquiera de las instrucciones SET con opciones ON y OFF, puede especificar ON u OFF para
múltiples opciones de SET.
SQL Server 2000 45

6.3 E structu ras d e con trol 19 .

En PL/SQL solo disponemos de la estructura condicional IF. Su sintaxis se muestra a continuación:
IF (expresion) THEN
Instrucciones
ELSEIF (expresion) THEN
Instrucciones
ELSE
Instrucciones
END IF;
Un aspecto a tener en cuenta es que la instrucción condicional anidada es ELSIF y no “ELSEIF”.

Sentencia GOTO
PL/SQL dispone de la sentencia GOTO. La sentencia GOTO desvía el flujo de ejecución a una
determinada etiqueta.
En PL/SQL las etiquetas se indican del siguiente modo: << etiqueta >>
El siguiente ejemplo ilustra el uso de GOTO.
DECLARE
flag NUMBER;
BEGIN
flag :=1 ;
IF (flag = 1) THEN
GOTO paso2;
END IF;
<<paso1>>
dbms_output.put_line(‘Ejecucion de paso 1’);
<<paso2>>
dbms_output.put_line(‘Ejecucion de paso 2’);
END;

Bucles
En PL/SQL tenemos a nuestra disposición los siguientes iteradores o bucles:
LOOP
WHILE
FOR
El bucle LOOP, se repite tantas veces como sea necesario hasta que se fuerza su salida con la
instrucción EXIT. Su sintaxis es la siguiente
LOOP
Instrucciones
IF (expresion) THEN

19
Herrarte Sánchez Pedro “Estructuras de control en PL/SQL”.” Estructuras de control de flujo”. “2006”
<http://www.devjoker.com/asp/ver_contenidos.aspx?co_contenido=33> (01/04/2006)
Herrarte Sánchez Pedro “Estructuras de control en PL/SQL”.” Estructuras de control de flujo”. “2006”
<http://www.devjoker.com/asp/ver_contenidos.aspx?co_contenido=33> (01/04/2006)
46 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Instrucciones
EXIT;
END IF;
END LOOP;
El bucle WHILE, se repite mientras que se cumpla expresión.

WHILE (expression) LOOP

Instrucciones
END LOOP;
El bucle FOR, se repite tanta veces como le indiquemos en los identificadores
inicio y final.

FOR contador IN [REVERSE] inicio..final LOOP

Instrucciones

END LOOP;
En el caso de especificar REVERSE el bucle se recorre en sentido inverso.

6.4 V ariables lo cales y gl ob ales 20 .

Las variable globales están definidas en SQL Server, no es posible definir variables globales dentro de
nuestras rutinas, solamente pueden utilizarse las variables ya definidas. Estas variables están siempre
predefinidas con los símbolos @@ precediendo al nombre. Nunca se deben declarar variables locales
con el mismo nombre que una global porque puede tener resultados inesperados.

@@CONNECTIONS Conexiones totales intentadas.

@@UCP_BUSY Tiempo acumulado de UCP para el servidor en ticks.

@@DBTS Valor del sello temporal único para la base de datos.

@@ERROR Ultimo numero de error del sistema.

@@FETCH_STATUS Estado de la última sentencia FETCH.

@@IDENTITY El último valor de entidad insertado.

@@IDLE Tiempo ocioso acumulado de UCP para el servidor.

@@IO_BUSY Tiempo acumulado de Entrada/Salida del servidor.

@@LANGID ID del lenguaje actual.

20
Libros en pantalla de SQL Server, SET (Transact-SQL) <http://msdn2.microsoft.com/es-
es/library/ms190356.aspx>
SQL Server 2000 47

@@LANGUAGE Nombre del lenguaje actual.

@@MAX_CONNECTIONS Máximo numero de conexiones.

@@MAX_PRECISION Nivel de precisión para tipos de datos decimales numéricos.

@@MICROSOFTVERSION Número de versión interno de SQL Server.

@@NESTLEVEL Nivel de anidamiento de subrutinas, entre 1 y 16.

@@PACK_RECEIVED Número de paquetes de entrada leídos.

@@PACKET_SENT Número de paquetes de salida escritos.

@@PACKET_ERRORS Número de errores de lectura y escritura de paquetes.

@@PROCID Identidad del proceso almacenado en curso

@@ROWCONT Número de filas afectadas por la ultima consulta.

@@SERVERNAME Nombre del servidor local.

@@SERVICENAME Nombre del servicio que se está ejecutado.

@@SPID Identidad del proceso del servidor en curso.

Máximo en curso para los datos de tipo texto imagen, con un valor
@@TEXTSIZE
por omisión de 4K.

Número de microsegundos por tick, independiente de la máquina,

@@TIMETICKS
un ticks es igual a 31.25 milisegundos o 1/32 segundos.

@@TOTAL_ERRORS Número total de errores habidos durante lecturas o escrituras.

@@TOTAL_READ Número de lecturas de disco (sin reserva).

@@TOTAL_WRITE Número de escrituras en disco.

@@TRANCOUNT Transacciones actuales de usuarios activos.

@@VERSION Fecha y Versión de SQL Server.

6.5 Utiliz aci ón d e p arámetros.

Consultas con Parámetros
Las consultas con parámetros son aquellas cuyas condiciones de búsqueda se definen mediante
parámetros. Si se ejecutan directamente desde la base de datos donde han sido definidas aparecerá un
48 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

mensaje solicitando el valor de cada uno de los parámetros. Si deseamos ejecutarlas desde una
aplicación hay que asignar primero el valor de los parámetros y después ejecutarlas. Su sintaxis es la
siguiente:
PARAMETERS nombre1 tipo1, nombre2 tipo2, ... , nombreN tipoN Consulta
En donde:

Parte Descripción
nombre Es el nombre del parámetro.
tipo Es el tipo de datos del parámetro.

consulta Una consulta SQL.

Puede utilizar nombre pero no tipo de datos en una cláusula WHERE o HAVING.
PARAMETERS Precio_Minimo Currency, Fecha_Inicio DateTime;
SELECT IDPedido, Cantidad FROM Pedidos WHERE Precio > Precio_Minimo
AND FechaPedido >= Fecha_Inicio;
Ejemplo:
PARAMETERS [Escriba los Apellidos:] Text; SELECT * FROM Empleados
WHERE [Escriba los Apellidos:] = [Apellidos];
La ejecución desde la base de datos solicita al usuario los apellidos del empleado y después
muestra los resultados.

Cursores21
Los cursores son una herramienta de SQL que nos permite recorrer el resultado de una consulta SQL y
realizar operaciones en cada paso de ésta.
Es así como nos ayuda a realizar operaciones que de otro modo serían más complejas o irrealizables. A
continuación se coloca el código de un cursor muy simple para el Analizador de Consultas de SQL
Server.
/* Este cursor deja las contraseñas iguales al nombre de usuario.
La tabla Cliente tiene estos tres campos: CliCod, CliUser, CliPass */
• declaramos las variables
declare @cod as int
declare @user as varchar(50)
declare @pass as varchar(50)
• declaramos un cursor llamado “CURSORITO”. El select debe contener sólo los
campos a utilizar.
declare CURSORITO cursor for
select CliCod, CliUser, CliPass from Cliente
open CURSORITO
• Avanzamos un registro y cargamos en las variables los valores encontrados en el
primer registro
fetch next from CURSORITO
into @cod, @user, @pass
while @@fetch_status = 0

21
Matias Thayer “SQL”. “Cursores en SQL Server”, 2005 <http://www.maestrosdelweb.com/editorial/cursql/>. (16.02.2005)
SQL Server 2000 49

begin
update Cliente set CliPass= @user where CliCod=@cod
• Avanzamos otro registro
fetch next from CURSORITO
into @cod, @rut, @nombres
end
• cerramos el cursor
close CURSORITO
deallocate CURSORITO

6.6 Tran saccion es

Una transacción controla cuantas operaciones realiza un proceso batch T-SQL antes de confirmar los
cambios. Dichas transacciones no serán confirmadas hasta que no se emita la sentencia COMMIT
TRAN[SACTION] o deshechas mediante un BACK TRAN[SACTION] mientras que la orden de inicio de
una transacción se emite con BEGIN TRAN[SACTION].
Para que una transacción sea considerada como tal, el proceso debe cumplir con las propiedades ACID
(Atomicidad, Consistencia, Aislamiento y Durabilidad, por sus siglas en inglés).
Atomicidad: Las transacciones son unidades atómicas de trabajo; se ejecutan todas las operaciones
en ella definidas o ninguna.
Consistencia: Cuando una transacción termina, los datos en la base de datos permanecen en un
estado estable, cumpliendo con las reglas de integridad referencial y con todas las estructuras
internas (por ejemplo los árboles de índices) estables.
Aislamiento: los cambios que se realizan dentro de una transacción permanecen aislados a otras
transacciones. Todo esto significa, que de alguna manera, se debe mantener el control sobre los
elementos que se están modificando (bloqueos) con el propósito de que los mismos no sean
alterados por otras transacciones mientras la actual se esta ejecutando.
Durabilidad: Luego de confirmada la transacción, los cambios realizado se mantienen estables en el
tiempo.
Existen tres tipos de transacciones dentro de SQL Server:
Transacciones explicitas: son aquellas transacciones en las cuales se especifica explícitamente,
en el proceso por lotes, el inicio y fin de la transacción:
BEGIN TRANSACTION: marca el punto de inicio de una transacción para una conexión.
COMMIT TRANSACTION: Sirve para finalizar una transacción en la que no se produjeron
errores, haciendo los cambios pertinentes en la base de datos.
ROLLBACK TRANSACTION: se utiliza para deshacer los cambios sobre los datos en aquellas
transacciones donde se han producido errores.
Transacciones implícitas: Son aquellas que maneja por omisión el servidor de SQL Server. Cada
sentencia individual es confirmada o deshecha.
Transacciones anidadas Otra de las posibilidades que nos ofrece el SQL Server es utilizar
transacciones anidadas.
Esto quiere decir que podemos tener transacciones dentro de transacciones, es decir, podemos
empezar una nueva transacción sin haber terminado la anterior.
50 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Asociada a esta idea de anidamiento existe una variable global @@TRANCOUNT que tiene valor 0 si
no existe ningún nivel de anidamiento, 1 si hay una transacción anidada, si estamos en el segundo nivel
de anidamiento y así sucesivamente.
La dificultad de trabajar con transacciones anidadas está en el comportamiento que tienen ahora las
sentencias ‘COMMIT TRAN’ y ‘ROLLBACK TRAN’
ROLLBACK TRAN: Dentro de una transacción anidada esta sentencia deshace todas las
transacciones internas hasta la instrucción BEGIN TRANSACTION más externa.
COMMIT TRAN: Dentro de una transacción anidada esta sentencia únicamente reduce en 1 el
valor de @@TRANCOUNT, pero no “finaliza” ninguna transacción ni “guarda” los cambios. En el
caso en el que @@TRANCOUNT=1 (cuando estamos en la última transacción).
COMMIT TRAN hace que todas las modificaciones efectuadas sobre los datos desde el inicio de
la transacción sean parte permanente de la base de datos, libera los recursos mantenidos por la
conexión y reduce @@TRANCOUNT a 0.
Quizás estos dos gráficos nos ayuden a entender el comportamiento de estas sentencias cuando hay
varios niveles de anidamiento.

6.7 Recopil ación ♦ .

En la medida que una base de datos cambia debido ala creación de índices o por la modificación sobre
los datos almacenados en columnas indexadas, también cambian los planes de ejecución compilados
para acceder a esos datos. Por ello es necesario recompilar dichos planes para optimizarlos. En SQL
Server 2005 esta recopilación es automática siempre que se corre por primera vez un procedimiento
almacenado luego de reiniciar el servidor o si cambia una tabla utilizada por este. Pero si se crea un
índice nuevo sobre una tabla a partir del cual la ejecución de un procedimiento puede verse beneficiada,
la recopilación no es automática. La siguiente tabla muestra recomendaciones respecto a la
recopilación:

CHECK DETALLE

√ Utilizar procedimientos almacenados o consultas parametrizables

√ Utilizar sp_executesql para consultas dinámicas

√ Evitar sentencias de definición de datos (DDL) o de manipulación de datos (DML) aun en

la tempdb, para manipular elementos ya definidos.

√ Evitar el uso de cursores en tablas temporarias.

♦
Rosas,Karina. SQL SERVER Bases de datos robustas. Manuales Users. Editorial: MP Ediciones 2005. Buenos Aires, Argentina.
 FUNCIONES DEFINIDAS
POR EL USUARIO

7.1 Característi cas y d efini ción.

24
Tipos de funciones
El servidor 2000 del SQL utiliza tres tipos de funciones: las funciones escalares, tabla en línea,
funciones de tabla de multisentencias. Los tres tipos de funciones aceptan parámetros de cualquier tipo
excepto el row version. Las funciones escalares devuelven un solo valor, tabla en línea y
Multisentencias devuelven un tipo de dato tabla.
1. Funciones Escalares
Las funciones escalares vuelven un tipo de los datos tal como int, money, varchar, real, etc.,
pueden ser utilizadas en cualquier lugar incluso incorporada dentro de sentencias SQL. La sintaxis
para una función escalar es la siguiente:
CREATE FUNCTION [owner_name.] function_name
( [{ @parameter_name scalar_parameter_type [ = default]} [,..n]])
RETURNS scalar_return_type
[WITH <function_option> >::={SCHEMABINDING | ENCRYPTION]
[AS]
BEGIN
function_body
RETURN scalar_expression
END

A simple scalar function to cube a number would look like this:

CREATE FUNCTION dbo.Cube( @fNumber float)

RETURNS float
AS
BEGIN
RETURN(@fNumber * @fNumber * @fNumber)
END

CREATE FUNCTION dbo.Factorial ( @iNumber int )

RETURNS INT
AS
BEGIN
DECLARE @i int

IF @iNumber <= 1
SET @i = 1

24
Ferra Jaime “Funciones de usuario multisentencia” <http://www.netveloper.com/contenido2.aspx?IDC=85_0> (18/04/2004)
Funciones SQL Server 2000 http://www.learningsolutions.com.mx/sqlsrvfunciones.cfm
52 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

ELSE
SET @i = @iNumber * dbo.Factorial( @iNumber - 1 )
RETURN (@i)
END
Funciones de tabla en línea
Las funciones de tabla en línea son las funciones que devuelven la salida de una simple declaración
SELECT. La salida se puede utilizar adentro de joins o consultas como si fuera una tabla de estándar.
La sintaxis para una función de tabla en línea es como sigue:
CREATE FUNCTION [owner_name.] function_name
( [{ @parameter_name scalar_parameter_type [ = default]} [,..n]])
RETURNS TABLE
[WITH <function_option>::={SCHEMABINDING | ENCRYPTION}]
RETURN [(] select_statement [)]

An in-line function to return the authors from a particular state would

look like this:

CREATE FUNCTION dbo.AuthorsForState(@cState char(2) )

RETURNS TABLE
AS
RETURN (SELECT * FROM Authors WHERE state = @cState)
Las funciones de tabla de multisentencias son similares a los procedimientos almacenados excepto que
vuelven una tabla. Este tipo de función se usa en situaciones donde se requiere más lógica y proceso.
Lo que sigue es la sintaxis para unas funciones de tabla de multisentencias:
CREATE FUNCTION [owner_name.] function_name
( [{ @parameter_name scalar_parameter_type [ = default]} [,..n]])
RETURNS TABLE
[WITH <function_option> >::={SCHEMABINDING | ENCRYPTION]
[AS]
BEGIN
function_body
RETURN
END
Los datos jerárquicos, tales como una estructura de organización, son un ejemplo de los datos que
no se pueden recopilar en una sola interrogación. La tabla Employees de la base de datos de
Northwind Company contiene un campo llamado ReportsTo que contiene el EmployeeID del
empleado. GetManagerReports es una función de tabla multisentencias: que devuelve una lista de
los empleados que apuntan a un empleado específico, directamente o indirectamente.

CREATE FUNCTION dbo.GetManagerReports ( @iEmployeeID int )

RETURNS @ManagerReports TABLE
(
EmployeeID int,
EmployeeFirstName nvarchar(10),
EmployeeLastName nvarchar(20),
Title nvarchar(30),
TitleOfCourtesy nvarchar(25),
Extension nvarchar(4),
ManagerID int
)
AS
BEGIN

DECLARE

@iRowsAdded int, -- Counts rows added to—table with each iteration

@PREPROCESSED tinyint, -- Constant
for record prior—to processing
SQL Server 2000 53

@PROCESSING tinyint, -- Constant

for record—being processed
@POSTPROCESSED tinyint—Constant for
records that—have been processed

SET @PREPROCESSED = 0
SET @PROCESSING = 1
SET @POSTPROCESSED = 2

DECLARE @tblReports TABLE (

EmployeeID int,
EmployeeFirstName nvarchar(10),
EmployeeLastName nvarchar(20),
Title nvarchar(30),
TitleOfCourtesy nvarchar(25),
Extension nvarchar(4),
ManagerID int,
ProcessedState tinyint
DEFAULT 0
)

Llamando Funciones
Hay algunas idiosincrasias de la sintaxis al invocar funciones definidas por el usuario. SQL 2000
proporciona algunas funciones definidas por el usuario a nivel sistema en la base de datos Master.
Estas funciones del sistema se invocan con una sintaxis levemente distinta a las que usted puede crear.
Las funciones del sistema que devuelven una tabla tienen la sintaxis siguiente:

::function_name ([argument_expr], [,...])

System functions that return a scalar value use this syntax:

function_name ([argument_expr], [,...])

[database_name] owner_name. function_name ([argument_expr], [,...])

Limitaciones
Las funciones definidas por el usuario tienen algunas restricciones. No todas las sentencias SQL son
válidas dentro de una función. Las listas siguientes enumeran las operaciones válidas e inválidas de las
funciones:
Válido:
 Las sentencias de asignación
 Las sentencias de Control de Flujo
 Sentencias SELECT y modificación de variables locales
 Operaciones de cursores sobre variables locales
 Sentencias INSERT, UPDATE, DELETE con variables Locales.
Inválidas:
Armar funciones no determinadas como GetDate() Sentencias de modificación o actualización de tablas
o vistas Operaciones CURSOR FETCH que devuelven datos del cliente.
Implicaciones De Performance Usar UDFs afectará la performance de las consultas. El impacto de
performance depende de cómo y de dónde usted utiliza una función definida por el usuario. Usted debe
tener precaución al implementar funciones en sus consultas y realiza pruebas de benchmarking para
asegurar que las ventajas de usar sus funciones exceden los costes de performance.
54 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

La función siguiente valida que un número de serie que sigue un modelo específico y las porciones del
número de serie corresponden con un algoritmo específico para un tipo del producto.

Columnas computadas♦
Las funciones escalares se pueden utilizar para crear columnas calculadas en una definición de tabla.
Los argumentos de las funciones calculadas, columnas de la tabla, constantes, o funciones
incorporadas.

♦
Ferra Jaime “Funciones de usuario multisentencia” <http://www.netveloper.com/contenido2.aspx?IDC=85_0> (18/04/2004)
Funciones SQL Server 2000 http://www.learningsolutions.com.mx/sqlsrvfunciones.cfm
SQL Server 2000 55

TRIGGERS

8.1 Característi cas y b en efi cio s. 25

Un trigger o un disparador en una Base de datos es un evento que se ejecuta cuando se cumple una
condición establecida al realizar una operación de inserción (INSERT), actualización (UPDATE) o
borrado (DELETE). También puede ser el nombre que recibe la patilla de los circuitos integrados,
microcontroladores, etc). Es lo que se denomina el disparador por donde entra el impulso que es la
señal de entrada al circuito.
Componentes
La estructura básica de un trigger es:
 Llamada de activación: es la sentencia que permite "disparar" el código a ejecutar,
 Restricción: es la condición necesaria para realizar el código. Esta restricción puede ser de tipo
condicional o de tipo nulidad, y
Acción a ejecutar: es la secuencia de instrucciones a ejecutar una vez que se Tipos
Existen dos tipos de triggers, que se clasifican según la cantidad de ejecuciones a realizar:
 Row Triggers (o Triggers de fila): son aquellos que se ejecutaran n-veces si se llama n-veces
desde la tabla asociada al trigger
 Statem ent Triggers (o Triggers de secuencia): son aquellos que sin importar la cantidad de
veces que se cumpla con la condición, su ejecución es única.
Pueden ser de sesión o almacenados
Ventajas:
Estandarización: Un solo procedimiento controla las acciones que pueden realizar el resto de
procedimientos sobre una tabla Oracle específica.
Eficiencia: Cuando un trigger es analizado por el optimizador Oracle, el plan de ejecución se
almacena en la memoria virtual del servidor, con lo cual, si se vuelve a disparar el trigger
PLSQL, este se ejecuta instantáneamente ya que existe una copia del plan de ejecución en la
memoria.
Seguridad: Aumentan la seguridad porque permiten restringir el acceso de los usuarios a los
datos de las tablas, al no poder éstos modificar o acceder a los mismos directamente. Las
acciones que realiza un trigger normalmente se limitan en base a los permisos que tiene el
usuario que creo la tabla involucrada y no en base a los permisos que tiene el usuario que
disparó el trigger.

25
Programación PL/SQL .”TRIGGERS EN PL/SQL”. <http://www.plsql.biz/2007/02/triggers-en-plsql.html>(Febrero 2007)
56 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Sintaxis de los triggers en PL/SQL

CREATE OR REPLACE TRIGGER nombre-del-trigger

[BEFORE/AFTER]
[INSERT/DELETE/UPDATE/UPDATE OF lista-columnas]
[ORDER integer] ON nombre-tabla
[REFERENCING [OLD AS nombre-antiguo][NEW AS nombre-nuevo]]
[FOR EACH ROW/FOR EACH STATEMENT]
[WHEN {condiciones}]
{Bloque estándar de sentencias PL/SQL... BEGIN, EXCEPTION}

La diferencia entre UPDATE y UPDATE OF lista-columnas es que, en el segundo caso, el trigger

PL/SQL se ejecuta sólo cuando se modifica alguna de las columnas de la lista y, en el primer caso, el
trigger se ejecuta en caso de que cualquiera de las columnas de la tabla sea modificada.
La cláusula ORDER se utiliza para determinar el orden en que se deben ejecutar diferentes triggers del
mismo tipo (INSERT, DELETE o UPDATE) que se disparan al mismo tiempo sobre una misma tabla.
La cláusula REFERENCING permite referirnos con el nombre que nosotros indiquemos (por defecto los
nombres son old y new) al valor antiguo (old) de un registro que ha sido borrado o actualizado o al valor
nuevo (new) de un registro que ha sido actualizado o insertado. Yo, sinceramente, no le veo una utilidad
evidente a esta cláusula debido a que los valores por defecto son suficientemente explicativos.
La cláusula WHEN determina que el trigger PLSQL se disparé sólo para los registros que cumplen la
condición de la cláusula. Esta cláusula sólo se puede usar en triggers a nivel de registro.

8.2 Ob servacion es sob re i n tegri dad referenci al.

Podemos recurrir a triggers para implementar esa integridad referencial. Un ejemplo concreto podría ser
el caso que veremos hoy, cuando la integridad es entre dos bases de datos del mismo servidor. No se
puede conseguir poner DRI, pero si se puede implementar un sistema de triggers que se comporte de la
misma forma.
El Código
Pondremos la relación entre una tabla detalle de la tabla Customers de northwind, por tanto hay dos
triggers que implementar, uno en la tabla de detalle y otra en la tabla Customers, que se implementa en
Northwind.

use pruebas
go
create table IntegridadPorTriggers(id Int identity(1,1) not null Primary
key, CustomerId nvarchar(5) null)
go

create trigger Trg_integridadPorTriggers on IntegridadPorTriggers

for insert,update
as
Declare @Cuantos int
Begin Tran
-- Seleccionamos los que se acaban de insertar que no existen
Select @Cuantos=Count(*)FRom Northwind.dbo.Customers C
right join inserted i on C.Customerid=i.customerid
where c.customerid is null
if @Cuantos>0
begin
rollback tran
raiserror ('No se puede insertar un registro que no tenga su
correspondiente en la Tabla Customers de Northwind',16,1)
SQL Server 2000 57

end
else
commit tran

go
insert into IntegridadPorTriggers values('ALFKI')
GO
insert into IntegridadPorTriggers values('ERROR')
GO

8.3 Utiliz aci ón d e lo s trigg ers 26

Usos
Son usados para mejorar la administración de la Base de datos, sin necesidad de contar con el usuario
que ejecute la sentencia de SQL.
Además, pueden generar valores de columnas, previene errores de datos, sincroniza tablas, modifica
valores de una vista, etc.
Permite implementar programas basados en paradigma lógico (sistemas expertos, deducción).
Un sencillo ejemplo sería crear un trigger para insertar un pedido de algún producto cuando la cantidad
de éste en nuestro almacén sea inferior a un valor dado.
BEFORE UPDATE ON tabla_almacen
FOR ALL records
IF :NEW.producto < 100 THEN
INSERT INTO tabla_pedidos(producto) VALUES (1000);
END IF;
END;
Se ejecuta ante un determinado evento de manera automática. Generalmente se utilizan para garantizar
que una determinada acción siempre se realiza después de realizar una tarea determinada. Se debe
tener cuidado con este tipo de estructuras puesto que un uso excesivo puede dar lugar a dependencias
difíciles de mantener. Además se deben tener muy claros las restricciones de integridad.
La sintaxis sería
A nivel de sentencia:
CREATE [OR REPLACE] TRIGGER nombre_trigger
momento_ejecución evento [evento] ON nombre_tabla
bloque PLSQL;
A nivel de registro:
CREATE [OR REPLACE] TRIGGER nombre_trigger
momento_ejecución evento [evento] ON nombre_tabla
[REFERENCING OLD AS old | NEW AS new]
FOR EACH ROW
[WHEN condición]
bloque PLSQL;

26
Programación PL/SQL .”TRIGGERS EN PL/SQL”. <http://www.plsql.biz/2007/02/triggers-en-plsql.html>(Febrero 2007)
58 Compilado por: Jazmin Cabello Pérez, Julia Basurto Madrid

Donde "momento_ejecución" indica cuando se ejecuta el trigger automáticamente. Puede contener los:
valores BEFORE ó AFTER. "evento" indica la operación que provoca la ejecución de este bloque.
Puede contener los valores :INSERT, UPDATE ó DELETE. "old" indica el nombre que se le da al
registro con los valores antiguos que se tenían antes de :la ejecución de la operación que activó el
trigger. Mientras que "new" indica el valor que tiene: actualmente después de dicha operación.
Con la cláusula "WHEN" se puede indicar una restricción que haga que el trigger se ejecute o no. :Por
ejemplo se puede indicar que el trigger se ejecute solo si el campo "campo1" de la tabla tiene :un valor
mayor que 50.
La cláusula "FOR EACH ROW" indica que el trigger es a nivel de registro.
Para eliminar un trigger:
DROP TRIGGER nombre_trigger
UNIVERSIDAD NACIONAL AUTÓNOMA DE MÉXICO
DR. JUAN RAMÓN DE LA FUENTE
Rector
LIC. ENRIQUE DEL VAL BLANCO
Secretario General
DR. DANIEL BARRERA PÉREZ
Secretario Administrativo
DRA. ROSAURA RUIZ GUTIÉRREZ
Secretaria de Desarrollo Institucional
MTRO. JOSÉ ANTONIO VELA CAPDEVILA
Secretario de Servicios a la Comunidad
MTRO. JORGE ISLAS LÓPEZ
Abogado General

DIRECCIÓN GENERAL DE SERVICIOS DE CÓMPUTO

ACADÉMICO
DR. ALEJANDRO PISANTY BARUCH
Director General

MAT. CARMEN BRAVO CHAVESTE

Directora de Cómputo para la Docencia
MTRO. JESÚS DÍAZ BARRIGA ARCEO
Subdirector de Planeación Académica
ACT. FABIÁN ROMO ZAMUDIO
Subdirector de Tecnología para la Educación
ING. SERGIO ALVA ARGUINZONIZ
Coordinador del Centro Mascarones
MTRA. ALEJANDRINA SAN JUAN REYES
Coordinadora del Centro de Extensión en
Cómputo y Telecomunicaciones Nuevo León
LIC. JOSÉ LUIS MEDINA FLORES
Coordinador del Centro Coapa de Extensión
en Cómputo y Telecomunicaciones
ING. PABLO DE LA O CRUZ
Coordinador del Centro San Agustín
MTRA. ALMA IBARRA OBANDO
Responsable de los cursos de Cómputo
del Palacio de la Autonomía, Fundación UNAM
LIC. PATRICIA ROMERO ELÍAS
Coordinadora del Centro Educativo
Multidisciplinario Polanco

Junio de 2007