Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
Índice General.
Índice General............................................................................................................................1
1. Conceptos de Bases de Datos...............................................................................................3
Definición ................................................................................................................................3
Arquitectura Cliente/Servidor ................................................................................................3
Sistema de gestión de base de datos (SGBD) ....................................................................... 3
Objetos de la base de datos..................................................................................................... 5
2. SQL..........................................................................................................................................7
Breve Historia .........................................................................................................................7
Componentes del SQL............................................................................................................8
Esquemas (Schemas) ............................................................................................................10
Tablas..................................................................................................................................... 11
Indices.................................................................................................................................... 11
Organización de los datos..................................................................................................... 12
3. Sentencia Básica del SQL – SELECT..............................................................................13
Sentencia SELECT Básica ................................................................................................... 14
Expresiones Aritméticas ....................................................................................................... 15
Alias de Columna..................................................................................................................16
Operador de Concatenación ................................................................................................. 16
Cadenas de Caracteres Literales...........................................................................................17
Valores Nulos........................................................................................................................17
Filas Duplicadas ....................................................................................................................17
Ordenamiento y restricción de datos....................................................................................17
Criterios de Selección ...........................................................................................................18
Operadores Lógicos ..............................................................................................................18
Operador (Between …and…) ..............................................................................................19
Operador Like .......................................................................................................................19
Operador In............................................................................................................................20
La cláusula WHERE .............................................................................................................20
Cláusula Order By.................................................................................................................21
Funciones de fila simple ....................................................................................................... 22
Tipos de funciones ................................................................................................................22
Funciones de una sola fila .................................................................................................... 22
Funciones de caracteres a nivel de fila ................................................................................23
Funciones numéricas a nivel de fila.....................................................................................23
Funciones de fecha................................................................................................................24
Funciones de Conversión...................................................................................................... 24
4. Uniones de Tablas ...............................................................................................................27
Consultas de Unión Interna .................................................................................................. 27
Cláusula INNER JOIN ......................................................................................................... 27
Cláusula JOIN / INNER JOIN..............................................................................................27
Consultas de Autocombinación (Autouniones) .................................................................. 28
Consultas de Unión Externa ................................................................................................. 28
Clausulas LEFT|RIGHT|FULL OUTER ................................................................................28
Definición
Es un conjunto de información relacionada que se encuentra agrupada o estructurada. Un archivo
por sí mismo no constituye una base de datos, sino más bien la forma en que está organizada la
información es la que da origen a la base de datos. Desde el punto de vista informático, una base
de datos es un sistema formado por un conjunto de datos almacenados en discos que permiten el
acceso directo a ellos y un conjunto de programas que manipulan ese conjunto de datos.
Arquitectura Cliente/Servidor
Los sistemas cliente/servidor están construidos de tal modo que la base de datos puede residir en
un equipo cent ral, llamado servidor y ser compartida entre varios usuarios. Los usuarios tienen
acceso al servidor a través de una aplicación de cliente o de servidor: En los sistemas
cliente/servidor grandes, miles de usuarios pueden estar conectados con una instalació n de SQL
Server al mismo tiempo. SQL Server tiene una protección completa para dichos entornos, con
barreras de seguridad que impiden problemas como tener varios usuarios intentando actualizar el
mismo elemento de datos a la vez. SQL Server también asigna eficazmente los recursos
disponibles entre los distintos usuarios, como la memoria, el ancho de banda de la red y la E/S de
disco.
Integridad. Se trata de adoptar las medidas necesarias para garantizar la validez de los datos
almacenados. Es decir, se trata de proteger los datos ante fallos de hardware, datos introducidos
por usuarios descuidados, o cualquier otra circunstancia capaz de corromper la información
almacenada. Los SGBD proveen mecanismos para garantiz ar la recuperación de la base de datos
hasta un estado consistente conocido en forma automática.
Respaldo. Los SGBD deben proporcionar una forma eficiente de realizar copias de respaldo de la
información almacenada en ellos, y de restaurar a partir de est as copias los datos que se hayan
podido perder.
Control de la concurrencia . En la mayoría de entornos, lo más habitual es que sean muchas las
personas que acceden a una base de datos, bien para recuperar información, bien para
almacenarla. Y es también frecuente que dichos accesos se realicen de forma simultánea. Así pues,
un SGBD debe controlar este acceso concurrente a la información, que podría derivar en
inconsistencias.
Manejo de Transacciones . Una Transacción es un programa que se ejecuta como una s ola
operación. Esto quiere decir que el estado luego de una ejecución en la que se produce una falla
es el mismo que se obtendría si el programa no se hubiera ejecutado. Los SGBD proveen
mecanismos para programar las modificaciones de los datos de una form a mucho más simple que
si no se dispusiera de ellos.
Tiempo de respuesta. Lógicamente, es deseable minimizar el tiempo que el SGBD tarda en darnos
la información solicitada y en almacenar los cambios realizados.
- Tablas: En una base de datos la información se organiza en tablas, que son filas y
columnas similares a las de los libros contables o a las de las hojas de cálculo. Cada fila de
la tabla recibe también el nombre de registro y cada columna se denomina también
campo.
- Vistas: Una vista es una tabla virtual cuyo contenido está defin ido por una consulta. Al
igual que una tabla real, una vista consta de un conjunto de columnas y filas de datos con
un nombre.
- Índices: Al igual que el índice de un libro, el índice de una base de datos permite encontrar
rápidamente información específica en una tabla o vista indexada. Un índice contiene
claves generadas a partir de una o varias columnas de la tabla o la vista y punteros que
asignan la ubicación de almacenamiento de los datos.
- Procedimientos Almacenados: Conjunto de instrucciones escritas en lenguaje SQL para ser
ejecutadas. Aceptan parámetros.
- Funciones: Rutinas que aceptan parámetros, realizan una acción, como un cálculo
complejo, y devuelven el resultado de esa acción como un valor. Similares a las funciones
de los lenguajes de programación
Transacciones
Una transacción es una secuencia de operaciones realizadas como una sola unidad lógica de
trabajo. Una unidad lógica de trabajo debe exhibir cuatro propiedades, conocidas como
propiedades de atomicidad, coherencia, aislamiento y durabilidad (ACID), para ser calificada como
transacción.
Atomicidad. Una transacción debe ser una unidad atómica de trabajo, tanto si se realizan todas
sus modificaciones en los datos, como si no se realiza ninguna de ellas.
Coherencia. Cuando finaliza, una t ransacción debe dejar todos los datos en un estado coherente.
En una base de datos relacional, se deben aplicar todas las reglas a las modificaciones de la
transacción para mantener la integridad de todos los datos. Todas las estructuras internas de
datos, como índices de árbol B o listas doblemente vinculadas, deben estar correctas al final de la
transacción.
Aislamiento. Las modificaciones realizadas por transacciones simultáneas se deben aislar de las
modificaciones llevadas a cabo por otras transaccion es simultáneas. Una transacción reconoce los
datos en el estado en que estaban antes de que otra transacción simultánea los modificara o
después de que la segunda transacción haya concluido, pero no reconoce un estado intermedio.
Durabilidad. Una vez conc luida una transacción, sus efectos son permanentes en el sistema. Las
modificaciones persisten aún en el caso de producirse un error del sistema.
2. SQL
El lenguaje de consulta estructurado (SQL) es un lenguaje de base de datos normalizado, utilizado
por los diferentes motores de bases de datos para realizar determinadas operaciones sobre los
datos o sobre la estructura de los mismos. Pero como sucede con cualquier sistema de
normalización hay excepciones para casi todo; de hecho, cada motor de bases de datos tiene sus
peculiaridades y lo hace diferente de otro motor, por lo tanto, el lenguaje SQL normalizado (ANSI)
no nos servirá para resolver todos los problemas, aunque si se puede asegurar que cualquier
sentencia escrita en ANSI será interpretable por cualquier motor de datos.
Breve Historia
La historia de SQL (que se pronuncia deletreando en inglés las letras que lo componen, es decir
"ese-cu-ele" y no "siquel" como se oye a menudo) empieza en 1974 con la definición, por parte de
Donald Chamberlin y de otras personas que trabajaban en los laboratorios de investigación de
IBM, de un lenguaje para la especificación de las características de las bases de datos que
adoptaban el modelo relacional. Este lenguaje se llamaba SEQUEL (Structured English Query
Language) y se implementó en un prototipo llamado SEQUEL -XRM entre 1974 y 1975. Las
experimentaciones con ese prototipo condujeron, entre 1976 y 1977, a una revisión del lenguaje
(SEQUEL/2), que a partir de ese momento cambió de nombre por motivos legales, co nvirtiéndose
en SQL. El prototipo (System R), basado en este lenguaje, se adoptó y utilizó internamente en IBM
y lo adoptaron algunos de sus clientes elegidos. Gracias al éxito de este sistema, que no estaba
todavía comercializado, también otras compañías empezaron a desarrollar sus productos
relacionales basados en SQL. A partir de 1981, IBM comenzó a entregar sus productos relacionales
y en 1983 empezó a vender DB2. En el curso de los años ochenta, numerosas compañías (por
ejemplo Oracle y Sybase, sólo por citar algunos) comercializaron productos basados en SQL, que se
convierte en el estándar industrial de hecho por lo que respecta a las bases de datos relacionales.
En 1986, el ANSI adoptó SQL (sustancialmente adoptó el dialecto SQL de IBM) como estándar para
los lenguajes relacionales y en 1987 se transfomó en estándar ISO. Esta versión del estándar va
con el nombre de SQL/86. En los años siguientes, éste ha sufrido diversas revisiones que han
conducido primero a la versión SQL/89 y, posteriormente, a la SQL/92.
El hecho de tener un estándar definido por un lenguaje para bases de datos relacionales abre
potencialmente el camino a la intercomunicabilidad entre todos los productos que se basan en él.
Desde el punto de vista práctico, por desgracia las cosas fueron de otro modo. Efectivamente, en
general cada productor adopta e implementa en la propia base de datos sólo el corazón del
lenguaje SQL (el así llamado Entry level o al máximo el Intermediate level), extendiéndolo de
manera individual según la propia visión que cada cual tenga del mundo de las bases de datos.
Actualmente, está en marcha un proceso de revisión del lenguaje por parte de los comités ANSI e
ISO, que debería terminar en la definición de lo que en este momento se conoce como SQL3. Las
características principales de esta nueva encarnación de SQL deberían ser su transformación en un
lenguaje stand-alone (mientras ahora se usa como lenguaje hospedado en otros lenguajes) y la
introducción de nuevos tipos de datos más complejos que permitan, por ejemplo, el tratamiento
de datos multimediales.
DCL (Data Control Language): Lenguaje que incluye órdenes para manejar la seguridad de los
datos y de la base de datos. Permite crear roles y establecer permis os. Sentencias: GRANT,
REVOKE
DDL (Data Definition Language): Lenguaje que incluye ordenes para definir, modificar o borrar
objetos de la base de datos. Sentencias: CREATE, DROP, ALTER
DML (Data Manipulation Language): Lenguaje de manipulación de datos que permite actualizar y
recuperar los datos almacenados en la base de datos. Este tipo de instrucciones son las que se
desarrollaran en este capítulo. Sentencias: SELECT, INSERT, UPDATE, DELETE
Comandos DCL:
Comando Descripción
GRANT Utilizado para dar permisos a usuarios sobre los objetos de la base de datos
REVOKE Utilizado para quitar permisos a usuarios sobre los objetos de la base de datos
Comandos DDL:
Comando Descripción
CREATE Utilizado para crear nuevas tablas, campos e índices
Comandos DML:
Comando Descripción
Utilizado para consultar registros de la base de datos que satisfagan un criter io
SELECT
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.
Cláusula Descripción
FROM Utilizada para especificar la tabla de la cual se van a seleccionar los registros
Utilizada para especificar las condiciones que deben reunir los registros que se van a
WHERE
seleccionar
GROUP
Utilizada para separar los registros seleccionados en grupos específicos
BY
HAVING Utilizada para expresar la condición que debe satisfacer cada grupo
ORDER BY Utilizada para ordenar los registros seleccionados de acuerdo con un orden específico
Operadores lógicos
Operador Uso
Es el "y" lógico. Evalua dos condiciones y devuelve un valor de verdad sólo si ambas son
AND
ciertas.
Es el "o" lógico. Ev alúa dos condiciones y devuelve un valor de verdar si alguna de las
OR
dos es cierta.
NOT Negación lógica. Devuelve el valor contrario de la expresión.
Operadores de Comparación
Operador Uso
< Menor que
> Mayor que
<> Distinto de
<= Menor ó Igual que
>= Mayor ó Igual que
= Igual que
BETWEEN Utilizado para especificar un intervalo de valores.
LIKE Utilizado en la comparación de un modelo
IN Utilizado para especificar registros de una base de datos
Funciones de Agregado:
Las funciones de agrega do 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.
Función Descripción
AVG Utilizada para calcular el promedio de los valores de un campo determinado
COUNT Utilizada para devolver el número de registros de la selección
SUM Utilizada para devolver la suma de todos los valores de un campo determinado
MAX Utilizada para devolver el valor más alto de un campo especificado
MIN Utilizada para devolver el valor más bajo de un campo especificado
Esquemas (Schemas)
Definición
Ventajas
- Mayor flexibilidad para organizar la base de datos usando nombres de espacio, ya que de esta
manera los objetos no dependen del usuario que lo creo.
- Manejo de permisos mejorada, ya que los permisos pueden ser asignados a los esquemas y no
directamente a cada objeto.
Resolución de nombres
Cuando una base de datos contiene múltiples esquemas los nombres de los objetos pueden
confundirse ya que se podría tener el mismo nombre de objeto en dos esquemas diferentes. Por
ello es bueno asignarle a cada usuario un esquema predeterminado de manera de controlar mejor
el nombre de los objetos cuando no se usa el nombre completo. Para resolver los nombres de los
objetos incompletos SQL Server 2005 busca primero en el esquema predeterminado asociado al
Indices
Los índices son una estructura de datos que mejora la velocidad de las operacione s, permitiendo
un rápido acceso a los registros de una tabla. Al aumentar drásticamente la velocidad de acceso,
se suelen usar sobre aquellos campos sobre los cuales se hagan frecuentes búsquedas.
El í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 pueden ser creados usando una o más columnas, proporcionando la base tanto para
búsquedas rápidas al azar como de un ordenado acceso a registros eficiente.
Los índices son construidos sobre árboles B , B+, B* o sobre una mezcla de ellos, funciones de
cálculo u otros métodos.
El espacio en disco requeri do para almacenar el índice es típicamente menor que el espacio de
almacenamiento de la tabla (puesto que los índices generalmente contienen solamente los
campos clave de acuerdo con los que la tabla será ordenada, y excluyen el resto de los detalles de
la tabla), lo que da la posibilidad de almacenar en memoria los índices de tablas que no cabrían en
ella. En una base de datos relacional un índice es una copia de parte de una tabla.
Los índices pueden ser definidos como únicos o no únicos. Un índice único actúa como una
restricción en la tabla previniendo filas idénticas en el índice.
SQL Server 2005 accede a los datos de dos maneras:
Recorriendo la tabla completa página a página desde el principio de la tabla extrayendo los
registros que cumplen con el criterio de la consulta o
Usando índices: Cuando usa un índice pr imero recorre la estructura de árbol del índice para
encontrar los registros que cumplen con los criterios de la consulta
Los índices bien diseñados pueden reducir las operaciones de E/S de disco y consumir menos
recursos del sistema, con lo que mejoran e l rendimiento de la consulta. Los índices pueden ser
útiles para varias consultas que contienen instrucciones SELECT, UPDATE o DELETE. Cuando se
ejecuta una consulta, el optimizador de consultas evalúa cada método disponible para recuperar
datos y selecciona el método más eficiente. El método puede ser un recorrido de la tabla o puede
ser recorrer uno o más índices si existen. Al realizar un recorrido de la tabla, el optimizador de
consultas leerá todas las filas de la tabla y extraerá las filas que cumplen con los criterios de la
consulta. Un recorrido de la tabla genera muchas operaciones de E/S de disco y puede consumir
recursos. No obstante, puede ser el método más eficaz si, por ejemplo, el conjunto de resultados
de la consulta es un porcentaje elevado de filas de la tabla. Cuando el optimizador de consultas
utiliza un índice, busca en las columnas de clave de índice, busca la ubicación de almacenamiento
de las filas que necesita la consulta y extrae las filas coincidentes de esa ubicación. Generalmente,
la búsqueda del índice es mucho más rápida que la búsqueda de la tabla porque, a diferencia de la
tabla, un índice frecuentemente contiene muy pocas columnas por fila y las filas están ordenadas.
El optimizador de consultas normalmente selecciona el métod o más eficaz cuando ejecuta
consultas. No obstante, si no hay índices disponibles, el optimizador de consultas debe utilizar un
recorrido de la tabla. Su tarea es diseñar y crear los índices más apropiados para su entorno de
forma que el optimizador de consultas tenga una selección de índices eficaces entre los que elegir.
Proyección: la capacidad de proyección de SQL permite seleccionar de una tabla las columnas que
se desea consultar. Se pueden elegir tantas columnas de la tabla como sea necesario.
Selección: la capacidad de selección de SQL permite seleccionar las filas de una tabla que se desea
que una consulta devuelva. Se pueden usar diferentes criterios (predicados) para restringir las filas
visibles.
Ejemplo unión: una entidad bancaria cuenta con tablas de los depósitos y préstamos de clientes
en distintas sucursales:
Depositos
Nombre_Sucursal Nro_Cuenta Nombre_Cliente Deposito
Prestamos
Nombre_Sucursal Nro_Cuenta Nombre_Cliente Prestamo
En la sintaxis:
SELECT es una lista de una o más columnas
DISTINCT suprime los duplicados
* selecciona todas las columnas
columna|expresión selecciona la columna o expresión especificada
alias asigna nombre de cabecera diferente a la columna
FROM tabla especifica la tabla que contiene las columnas
Para visualizar todas las columnas de datos en una tabla se escribe un asterisco (*) después de la
palabra clave SELECT.
Ejemplo 1: Listar todas las columnas y todas las filas de la tabla Proveedores
SELECT *
FROM proveedores
Para visualizar columnas específicas de una tabla, en la sentencia SELECT se deben indicar los
nombres de columna, separados por comas.
Expresiones Aritméticas
+ Suma
- Resta
* Multiplicación
/ División
Estos operadores pueden ser utilizados en cualquier cláusula de una sentencia SQL excepto en la
cláusula FROM.
Ejemplo: mostrar nombre, salario y el salario aumentado en $300 de todos los empleados (tabla
empleados)
SELECT nombre, salario, salario + 300
FROM empleados;
El operador de suma permite calcular un incremento del salario de $300 para todos los
empleados. En el resultado, la tercera columna aparecerá con la leyenda “(Sin nombre de
columna)”. Cabe destacar que esta columna calculada resultante no es una columna nueva de la
tabla EMPLEADOS, sino sólo de visualización.
Prioridad de Operadores
En expresiones aritméticas con más de un operador, SQL trabaja igual que otros lenguajes:
· la multiplicación y la división se evalúan en primer lugar
· los operadores de idéntica prioridad se evalúan de izquierda a derecha
· Se puede utilizar paréntesis para forza r que la expresión incluida entre paréntesis se evalúe
en primer lugar
Alias de Columna
En el caso de una expresión, la cabecera de la columna no tiene un nombre que indique el
contenido. En estos cas os se utiliza un “alias”, es decir otro nombre, que permite renombrar la
cabecera de una columna.
El alias se coloca detrás de la columna en la lista SELECT, utilizando un espacio como separador.
Puede colocarse la palabra clave opcional AS entre el nombre de la columna y el alias.
Si el alias contiene espacios o caracteres especiales (como # o $), se debe escribir el alias entre
comillas dobles (" ").
Ejemplo: Listar el apellido de los empleados, con la cabecera “Nombre”, junto al salario anual,
también con un alias apropiado:
SELECT apellido AS Nombre, salario*12 “Salario Anual"
FROM empleados
En la primera columna se usa la palabra clave opcional AS delante del alias de columna. El
resultado es el mismo que en la segunda columna, en que no se colocó dicha palabra clave.
Operador de Concatenación
Es el operador +. Concatena dos expresiones en una expresión. Sólo se pueden concatenar datos
tipo cadena. La longitud de la cadena es la suma de las longitudes de las cadenas originales
expresadas en caracteres. Si alguno de los elementos es NULL, el resultado será NULL.
La sintaxis es:
character_expression1 + character_expression2
Ejemplo: Listar apellido y nombre de los empleados, separados por una coma (,), con la cabecera
“Empleados”
SELECT apellido + ‘, ‘ + nombre AS Empleado
FROM empleados;
Valores Nulos
Si una fila no tiene el valor de datos de una columna determinada, se dice que ese valor es nulo, o
que contiene un null.
Un valor nulo es un valor no disponible, no asignado, desconocido, o no aplicable. Un valor nulo no
es lo mismo que cero ni que un espacio. Cero es un número y un espacio es un carácter.
Las columnas de cualquier tipo de dato pueden contener valores nulos. Sin embargo, algunas
restricciones (NOT NULL y PRIMARY KEY), evitan que se ingresen valores nulos en la columna.
Si el valor de columna en una expresión aritmética es nulo, el resultado es null. Si se intenta dividir
por cero, se recibirá un mensaje de error. Sin embargo, si se divide un número por un valor nulo, el
resultado será nulo o desconocido.
Filas Duplicadas
Por defecto, los resultados de una consulta se muestran sin eliminar filas duplicadas. Para eliminar
filas duplicadas en el resultado, se debe incluir la palabra clave DISTINCT en la c láusula SELECT,
inmediatamente detrás de la palabra clave SELECT.
Criterios de Selección
En el capítulo anterior se vio la forma de recuperar los registros de las tablas. Las formas
empleadas devolvían todos los registros de la tabla usada. A lo largo de este capítulo se estudiarán
las posibilidades de filtrar los registros con el fin de recuperar solamente aquellos que cumplan
condiciones preestablecidas.
Antes de comenzar el desarrollo de este apartado hay que recalcar tres detalles de vital
importancia:
1 - 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
2 - no es posible establecer condiciones de búsqueda en los campos memo
3 - con respecto a las fechas, no existe una sintaxis que funcione en todos los sistemas, por lo
que se hace necesario particularizarlas según el banco de datos:
Referente a los valores lógicos True/False, cabe destacar que n o son reconocidos en ORACLE,
ni en SQL-SERVER. Es decir, no existen datos de tipo boolean. Sí disponen de campos BIT que
permiten almacenar valores de 0 ó 1. En Access existen campos de tipo "SI/NO".
Internamente, Access almacena en estos campos valores de 0 ó -1. Esto dificulta el uso. Sin
embargo, aprovechando la coincidencia del 0 para los valores FALSE, se puede utilizar la
sintaxis siguiente que funciona en todos los casos: si se desea saber si el campo es falso "...
CAMPO = 0" y para saber los verdaderos "CAMPO <> 0".
Operadores Lógicos
Los operadores lógicos soportados por SQL son: AND, OR y Not. A excepción de los dos últimos
todos poseen la siguiente sintaxis:
<expresión1> operador <expresión2>
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:
Ejemplos:
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';
SELECT *
FROM empleados
WHERE (sueldo > 100
AND sueldo < 500)
OR (provincia = 'Corrientes'
AND estado = 'Casado');
Intervalos de Valores
Para indicar que deseamos recuperar los registros según el intervalo de valore s de un campo
emplearemos el operador Between, cuya sintaxis es:
En este caso la consulta devolvería los registros que contengan en " campo" un valor incluido en el
intervalo valor1, valor2 (ambos inclusive). Si ante ponemos la condición NOT devolverá aquellos
valores no incluidos en el intervalo.
SELECT *
FROM pedidos
WHERE CodPostal BETWEEN 3400 AND 4000;
Operador Like
Se utiliza para c omparar una expresión de cadena con un modelo en una expresión SQL. Su
sintaxis es:
En donde modelo es una cadena modelo o campo contra el que se compara expresión.
Se puede utilizar el operador Like para encontrar valores en los c ampos que coincidan con el
modelo especificado. Por modelo puede especificar un valor completo (‘Ana María’), o se pueden
utilizar caracteres comodín, que pueden variar según el motor usado (*, %, etc), para encontrar un
rango de valores (Like ‘An%’).
Por ejemplo, si introduce Like ‘C%’ en una consulta SQL, la consulta devuelve todos los valores de
campo que comiencen por la letra C. En una consulta con parámetros, puede hacer que el usuario
escriba el modelo que se va a utilizar.
Ejemplo: mostrar el stock de todos los productos que sean shampoo (SHA) del archivo de
productos.
Operador In
Este operador devuelve aquellos registros cuyo campo indicado coincide con alguno de los de un a
lista. Su sintaxis es:
expresión [Not] IN(valor1, valor2, . . .)
SELECT *
FROM pedidos
WHERE provincia IN ('Corrientes', 'Chaco', 'Misiones');
La cláusula WHERE
La cláusula WHERE puede usarse para determinar qué registros de las tablas enumeradas e n la
cláusula FROM aparecerán en los resultados de la instrucción SELECT. Después de escribir esta
cláusula se deben especificar las condiciones expuestas en los dos primeros apartados de este
capítulo. Si no se emplea esta cláusula, la consulta devolverá todas las filas de la tabla. WHERE es
opcional, pero cuando aparece debe ir a continuación de FROM.
Ejemplos:
SELECT *
FROM pedidos
WHERE fecha_envio = #5/10/94#;
Cláusula Order By
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.
Ejemplos:
La siguiente consulta devuelve los campos codigoPostal, nombre, teléfono de la tabla clientes,
ordenados por el campo nombre.
Se puede especificar el orden de los registros: ascendente mediante la claúsula ASC (valor por
defecto) ó descendente (DESC).
Se puede especificar el orden de los registros por un campo que no figura en la SELECT:
Tipos de funciones
Básicamente, son de dos tipos:
· Funciones de una sola fila: Las funciones a nivel de filas operan sobre ellas y devuelven un
resultado por cada una.
· Funciones de varias filas: Operan sobre grupos de filas y devuelven un resultado por cada
grupo. De ahí el nombre, ya que son conocidas como “funciones de grupo”.
Aceptan uno o varios argumentos y devuelven un valor para cada fila recuperada por la consulta.
Se pueden utilizar en cláusulas SELECT, WHERE y ORDER BY; se pueden anidar.
Sintaxis:
nombre_funcion [(arg 1, arg 2,..., arg n)]
Los argumentos pueden ser: un nombre de columna, una expresión, una constante proporcionada
por el usuario o un valor de variable.
Función/Ejemplo Propósito/Resultado
LOWER(columna|expresión) Convierte a minúsculas los caracteres alfabéticos
LOWER(‘ABM Empleado') abm empleado
SUBSTRING('HolaMundo',1,4) Hola
Función/Ejemplo Propósito/Resultado
ROUND(columna|expresión, n) Redondea a n posiciones decimales. Si se omite n, se redondea
sin lugares decimales. Si n es negativo, se redondean los
números a la izquierda del punto decimal
ROUND(58.273,0), ROUND(58.273), 58
ROUND(58.273,2), ROUND(58.273,- 58
1) 58.27
60
M%N Devuelve el resto de la división de m /n. Si n es cero, devuelve m
1600 % 300 100
Transact-SQL es fundamental para trabajar con SQL Server. Todas las aplicaciones que se
comunican con SQL Server lo hacen enviando instrucciones Transact -SQL al servidor,
independientemente de la interfaz de usuario de la aplicación.
Nota: Se pueden ver resultados de funciones y cálculos sin necesidad de acceder a una tabla en
particular. Para ellos se utiliza la sintaxis de la cláusula SELECT sin el FROM.
EJ:
SELECT 1600 % 300 as Resto
SELECT ROUND(58.273,0)
Fechas en la base de datos:
Las bases de datos en su gran mayoría almacena n internamente las fechas en un formato que
incluye el siglo, el año, el mes, el día, la hora, los m inutos y los segundos. Sin embargo, el formato
para el ingreso y la visualización de cualquier fecha es por defecto DD-MM-YY.
SQL Server provee una función de fecha que devuelve la fecha y la hora actuales del servidor de
base de datos. La función getdate() puede ser utilizada en las consultas como si fuera una columna
normal. También puede mostrarse la fecha actual.
select getdate()
Dado que las fechas se almacenan como números, se puede operar con las mismas para obtener la
cantidad de días entre dos fechas, agregar días a una fecha, etc.
En general, al operar con fechas se obtiene como resultado un campo de tipo fecha, excepto al
restar dos fechas, en cuyo caso se obtiene un número, que indica la cantidad de días entre ambas
fechas.
Funciones de fecha
Función/Ejemplo Propósito/Resultado
DATEADD (datepart , number, date ) La función DATEADD agrega un intervalo a la fecha que
especifique
SELECT DATEADD(day, 3, getdate()) Agrega 3 dias a la fecha actual
SELECT DATEADD(day, -3, getdate()) Resta 3 días a la fecha actual
SELECT DATEADD(Month, -3, getdate()) Resta 3 Meses a la fecha actual
DATEDIFF(datepart, startdate, enddate) Devuelve la diferencia entra las dos fechas especificadas
SELECT DATEDIFF(day, OrderDate, GETDATE()) Devuelve la cantidad de dias entre OrderDate y la fecha actual
AS NumberOfDays
Funciones de Conversión
Sql Server provee funciones de conversión, que convierten un valor de un tipo de dato en otro.
CAST y CONVERT proporcionan funciones similares:
Syntax for CAST:
CAST ( expression AS data_type [ (length ) ])
Donde:
expression
Es cualquier expresión válida.
data_type
Es el tipo de datos de destino proporcionado por el sistema. No se pueden utilizar tipos de
datos de alias. Para obtener más información acerca de los tipos de datos disponibles, vea
Tipos de datos (Transact-SQL).
length
Es un parámetro opcional de los tipos de datos nchar, nvarchar, char, varchar, binary o
varbinary. Para C ONVERT, si no se ha especificado el parámetro length, el valor
predeterminado es 30 caracteres.
style
Es el estilo del formato de fecha usado para convertir datos de tipo datetime o
smalldatetime en datos de caracteres (con tipo de datos nchar, nvarchar, char, varchar,
nchar o nvarchar), o para convertir datos de caracteres de formatos de fecha y hora
conocidos en datos de tipo datetime o smalldatetime; o bien, el formato de cadena usado
para convertir datos de tipo float, real, money o smallmoney en datos de caracteres (con
tipo de datos nchar, nvarchar, char, varchar, nchar o nvarchar). Cuando style es NULL, el
resultado devuelto también es NULL.
Las funciones pueden anidarse (aplicar una función al resultado de otra). El orden de resolución es
desde la más interna hacia la más externa.
Evalúan una lista de condiciones y devuelve una de las varias expresiones de resultado posibles.
Ejemplo: emitir un listado de los inscriptos a los cursos, con el importe cobrado, según su
condición.
4. Uniones de Tablas
Cuando son necesarios datos de más de una tabla de la base de datos, se utiliza una condición de
unión. Las filas de una tabla se pueden unir a las de otra según valores comunes que existen en las
columnas correspondientes, es decir, normalmente columnas de clave primaria y ajena.
Los productos Cartesianos tienden a generar un gran número de filas y es poco frecuente que el
resultado sea útil. Debe incluir siempre una condición de unión válida en una cláusula WHERE, a
menos que tenga la necesidad específica de combinar todas las filas de todas las tablas.
Los productos Cartesianos son útiles para algunas pruebas en las que se necesita generar un gran
número de filas para simular una cantidad razonable de datos.
Para visualizar datos de dos o más tablas relacionadas, escriba una condición de unión simple en la
cláusula WHERE.
Cláusula JOIN / INNER JOIN
Usando la cláusula JOIN se pueden devolver datos de dos o más tablas basándose en relacione s
lógicas entre ellas. Indica como SQL Server debería usar los datos de una de las tablas para
seleccionar registros en la otra.
Combina registros de dos tablas siempre que haya valores coincidentes en un campo común.
Puede utilizar una operación INNER JO IN en cualquier cláusula FROM. Éste es el tipo más común
de combinación.
Se puede utilizar una operación INNER JOIN o bien solo JOIN en cualquier cláusula FROM. Esto
crea una combinación por equivalencia, conocida también como unión interna. Las combinaciones
“Equi” son las más comunes. Estas combinan los registros de dos tablas siempre que haya
concordancia de valores en un campo común a ambas tablas. Se puede utilizar INNER JOIN con las
tablas Departamentos y Empleados para seleccionar todos los empleado s de cada departamento.
Por el contrario, para seleccionar todos los departamentos (incluso si alguno de ellos no tiene
ningún empleado asignado) se emplea LEFT JOIN o todos los empleados (incluso si alguno no está
asignado a ningún departamento), en este caso RIGHT JOIN.
Ejemplos:
Formato ANSI:
SELECT campos
FROM tb1
INNER JOIN tb2 ON tb1.campo1 comp tb2.campo2;
O bien:
SELECT campos
FROM tb1
JOIN tb2 ON tb1.campo1 comp tb2.campo2;
Devuelven las ventas totales y los descuentos de todos los productos de la tabla Product que
tuvieron movimientos. Para eso consulta la tabla SalesOrderDetail:
Las combinaciones externas, a diferencia de las internas, devuelven todas las filas de una de las
tablas o vistas mencionadas en la cláusula FROM, como mínimo, siempre que tales filas cumplan
con alguna de las condiciones de búsqueda de WHERE o HAVING. Todas las filas se recuperarán de
la tabla izquierda a la que se haya hecho referencia con una combinación externa izquierda, y de la
tabla derecha a la que se haya hecho referencia con una combinación externa derecha. En una
combinación externa completa, se devuelven todas las filas de ambas tablas.
SQL Server usa las siguientes palabras clave ISO para las combinaciones externas especificadas en
una cláusula FROM:
OUTER JOIN LEFT: El resultado de esta operación siempre contiene todos los registros de la tabla
de la izquierda (la primera tabla que se menciona en la consulta), aun cuando no exista un registro
correspondiente en la tabla de la derecha, para uno de la izquierda.
USE AdventureWorks;
GO
SELECT p.Name, pr.ProductReviewID
FROM Production.Product p
LEFT OUTER JOIN Production.ProductReview pr
ON p.ProductID = pr.ProductID
LEFT OUTER JOIN incluye en el resultado todas las filas de la tabla Product, tanto si hay una
coincidencia en la columna ProductID de la tabla ProductReview como si no la hay. Observe que
en los resultados donde no hay un Id. de revisión de producto coincidente para un producto, la fila
contiene un valor nulo en la columna ProductReviewID.
OUTER JOIN RIGHT: Similar al anterior considerando que la tabla que se muestra completa es la
que se especifica a la derecha. Los valores de la tabla completa que no tengan correspondencia en
la segunda tabla presentarán sus valores en nulo
Utilizar combinaciones externas derechas
Para incluir a todos los vendedores en los resultados, independientemente de si están asignados a
un territorio de ventas, utilice una combinación externa derecha ISO. A continuación se muestra la
consulta Transact-SQL y los resultados de la combinación externa derecha:
USE AdventureWorks;
GO
SELECT st.Name AS Territory, sp.SalesPersonID
FROM Sales.SalesTerritory st
RIGHT OUTER JOIN Sales.SalesPerson sp
ON st.TerritoryID = sp.TerritoryID ;
Territory SalesPersonID
-------------------------------------------------- -------------
NULL 268
Northeast 275
Southwest 276
Central 277
Canada 278
Southeast 279
Northwest 280
Southwest 281
Canada 282
Northwest 283
NULL 284
United Kingdom 285
France 286
Northwest 287
NULL 288
Germany 289
Australia 290
Una combinación externa puede restringirse más mediante el uso de un predicado. Este ejemplo
contiene la misma combinación externa derecha, pero sólo incluye los territorios de ventas con un
volumen de ventas inferior a 2.000.000 de dólares:
USE AdventureWorks;
GO
SELECT st.Name AS Territory, sp.SalesPersonID
FROM Sales.SalesTerritory st
RIGHT OUTER JOIN Sales.SalesPerson sp
ON st.TerritoryID = sp.TerritoryID
WHERE st.SalesYTD < $2000000;
OUTER JOIN FULL: Para retener la información que no coincida al incluir las filas no coincidentes
en los resultados de una combinación, utilice una combinación externa completa. SQL Server
proporciona el operador de combinación externa completa, FULL OUTER JOIN, que incluye todas
las filas de ambas tablas, con independencia de que la otra tabla tenga o no un valor coincidente.
Puede incluir una cláusula WHERE con una combinación externa completa para devolver
solamente las filas donde no hay datos coincidentes entre las tablas. La siguiente consulta sólo
devuelve los productos que no tienen pedidos de venta que coincidan, así como los pedidos de
venta que no coinciden con ningún producto (aunque todos los pedidos de venta, en este caso,
coincidan con un producto).
USE AdventureWorks;
GO
-- The OUTER keyword following the FULL keyword is optional.
SELECT p.Name, sod.SalesOrderID
FROM Production.Product p
FULL OUTER JOIN Sales.SalesOrderDetail sod
ON p.ProductID = sod.ProductID
WHERE p.ProductID IS NULL
OR sod.ProductID IS NULL
ORDER BY p.Name ;
Las funciones de grupo operan sobre conjuntos de filas y permiten obtener un resultado para cada
grupo. Las más utilizadas son:
COUNT(*|[DISTINCT] columna)
Devuelve el número de registros que cumplen la condición solicitada. Si se coloca (*) incluye
valores nulos.
Si se coloca una columna como argumento, devuelve cuántos registros cumplen la condición, pero
sin contar los valores nulos. Además, si se coloca DISTINCT delante columna, no contará los valores
que aparezcan más de una vez.
SUM([DISTINCT] columna)
Suma los valores no nulos de col umna de las filas recuperadas que cumplan la condición pedida.
Con
DISTINCT no se sumarán los valores repetidos.
AVG([DISTINCT] columna)
Devuelve la media de los valores no nulos de columna de las filas recuperadas que cumplen la
condición pedida.
Con DISTINCT, no entrarán en el cálculo de la media los valores repetidos.
MAX([DISTINCT] columna)
Devuelve el valor máximo de columna que cumpla la condición.
MIN([DISTINCT] columna)
Devuelve el valor mínimo de columna que cumpla la condición.
Sintaxis:
SELECT funcion_grupo(columna)
FROM tabla
[WHERE condicion];
AVG y SUM operan sobre datos numéricos. COUNT, MIN y MAX operan sobre cualquier tipo de
datos, incluso texto.
Ejemplos:
Determinar la cantidad de alumnos del curso Consulta de Bases de Datos .
SELECT COUNT(*) AS Cantidad Alumnos
FROM alumnosCursoVerano
WHERE curso_desc = Consulta de Bases de Datos ;
Mostrar el promedio de notas de todos los alumnos inscriptos en los Cursos de Verano.
SELECT AVG(nota) AS Promedio
FROM alumnosCursoVerano;
SQL provee la cláusula GROUP BY, que combina los registros con valores idénticos en la lista de
campos especificados, en un único registro. Para ca da nuevo registro se crea un valor resumen si
se incluye una función agregada (o función de grupo) en la lista de la SELECT.
Sintaxis:
SELECT [columna_gr], funcion_grupo(columna)
FROM tabla
[WHERE condicion]
[GROUP BY columna_gr]
[HAVING condicion_de_agrupacion]
[ORDER BY columna_ord];
La cláusula GROUP BY permite dividir las filas de una tabla en grupos más pequeños, de acuerdo a
columna_g.
Un campo de la lista de campos GROUP BY puede referirse a cualquier campo de la tabla que
aparece en la cláusula FROM, incluso si el campo no esta incluido en la instrucción SELECT.
Este ejemplo provee el promedio de notas de los alumnos inscriptos en los Cursos de Verano para
los
distintos cursos. Sin embargo, no se visualiza a qué curso corresponde cada valor obtenido.
Promedios
--------------
6
8
7
9
Para poder ver a qué curso corresponde cada promedio obtenido, se debe agregar la columna
correspondiente:
Toda columna que aparece en la lista de las SELECT (que no sea la función de grupo), debe estar
en la cláusula GROUP BY.
Para que sea correcto, sólo se debe agregar curso_desc a la cláusula GROUP BY.
Es posible agrupar los datos por más de un campo. Por ejemplo, si se desea saber que cantidad de
los inscriptos en cada curso son Público en general , cuántos Docentes y cuántos Alumnos :
La cláusula WHERE se utiliza par a excluir aquellas filas que no desea agrupar. Sin embargo, en
ocasiones se desea filtrar los registros una vez agrupados. Por ejemplo, se necesita conocer la
cantidad de inscriptos por curso, pero sólo para aquellos cursos que tienen más de 20 inscriptos.
SQL provee para estos casos la cláusula HAVING, cuya sintaxis es la siguiente:
SELECT columna_gr, funcion_grupo(columna)
FROM tabla
[WHERE condicion]
[GROUP BY columna_gr]
[HAVING condicion_de_agrupacion]
[ORDER BY columna_ord];
La cláusula HAVING muest ra el valor de resumen de la función de grupo de los grupos que
satisfacen la condicion_de_agrupacion.
Se puede agregar una condición de sel ección de filas, previo a la aplicación de la función de
grupos.
Ejemplo: obtener la cantidad de inscriptos por curso, que hayan pagado la inscripción, pero sólo
para aquellos cursos que tienen más de 20 inscriptos.
Sentencia INSERT
Una sentencia INSERT de SQL agrega uno o más registros a una (y sólo una) tabla en una base de
datos relacional.
Las cantidades de columnas y valores deben ser iguales. Si una columna no se especifica, le será
asignado el valor por omisión. Los valores especificados (o implícitos) por la
sentencia INSERT deberán satisfacer todas las restricciones aplicables. Si ocurre un error de
sintaxis o si alguna de las restricciones es violada, no se agrega la fila y se devuelve un error.
Estructura simple:
Ejemplo:
1) Agregar una fila con tantos valores como columnas tenemos. En este caso no se enumeran las
columnas. Los valores deben ir dispuestos según el orden de las columnas.
En el siguiente ejemplo se inserta una fila en la tabla Production.UnitMeasure. Dado que los
valores para todas las columnas se suministran e incluyen en el mismo orden que las columnas de
la tabla, no es necesario especificar los nombres de columna en column_list..
USE AdventureWorks;
1) Agrega una nueva fila con distinto orden de columnas. En este caso es necesario enunciar cada
columna y su disposición en la lista.
En el siguiente ejemplo se utiliza column_list para especificar de forma explícita los valores
insertados en cada columna. El orden de las columnas de la
tabla UnitMeasurees UnitMeasureCode, Name, ModifiedDate; no obstante, las columnas no se
incluyen en dicho orden en column_list.
USE AdventureWorks;
Sentencia DELETE
Una sentencia DELETE de SQL borra uno o más registros existentes en una tabla.
Ejemplo:
USE AdventureWorks;
USE AdventureWorks;
Sentencia UPDATE
Una sentencia UPDATE de SQL es utilizada para modificar los valores de un conjunto de registros
existentes en una tabla.
Modelo de sentencia:
UPDATE ‘tabla’ SET columna1 = ‘valor nuevo’ WHERE columna2 = 'N';
Ejemplo:
USE AdventureWorks;
UPDATE Sales.SalesPerson
SET Bonus = 6000, CommissionPct = .10, SalesQuota = NULL;
USE AdventureWorks;
UPDATE Production.Product
SET Color = 'Metallic Red'
WHERE Name LIKE 'Road-250%' AND Color = 'Red';
Este comando crea una nueva tabla dentro del gestor de base de datos.
Modelo de sentencia:
IDENTITY
Indica que la nueva columna es una columna de identidad. Cuando se agrega una nueva fila a la
tabla, el Motor de base de datos proporciona un valor incremental único para la columna. Las
columnas de identidad se utilizan normalmente con las restricciones PRIMARY KEY como
identificadores de fila únicos de la tabla. La propiedad IDENTITY se puede asignar a las
columnas tinyint, smallint, int, bigint,decimal(p,0) o numeric(p,0). Sólo se puede crear una
columna de identidad para cada tabla. Las restricciones DEFAULT y los valores predeterminados
enlazados no se pueden utilizar en las columnas de identidad. En este caso, deben especificarse el
valor de inicialización y el incremento, o ninguno de esto valores. Si no se especifica ninguno, el
valor predeterminado es (1,1).
seed
Es el valor que se utiliza para la primera fila cargada en la tabla.
increment
Es el valor incremental que se agrega al valor de identidad de la fila cargada anterior.
CONSTRAINT
Es una palabra clave opcional que indica el principio de la definición de una restricción PRIMARY
KEY, NOT NULL, UNIQUE, FOREIGN KEY o CHECK.
constraint_name
Es el nombre de una restricción. Los nombres de restricción deben ser únicos en el esquema al que
pertenece la tabla.
Ejemplo:
USE AdventureWorks;
7. Subconsultas o Subquerys
Sintaxis:
SELECT select_list
FROM table
WHERE expr operador (SELECT select_list
FROM table);
Donde operator incluye una condición de comparación como >, = o IN
Nota: Las condiciones de comparación son de dos clases: operadores de una sola fila (>, =, >=, <,
<>, <=) y operadores de varias filas (IN, ANY, ALL).
Definición
Una subconsulta es una instrucción SELECT anidada dentro de otra instrucción SELECT.
Se puede utilizar una subconsulta en lugar de una expresión en la lista de campos de una
instrucción
SELECT o en una cláusula WHERE o HAVING. En una subconsulta, se utiliza una instrucci ón SELECT
para proporcionar un conjunto de uno o más valores especificados para evaluar en la expresión de
la cláusula WHERE o HAVING.
SELECT *
FROM Productos
WHERE PrecioUnidad > ANY (SELECT PrecioUnidad
FROM DetallePedido
WHERE Descuento >= 0 .25);
Predicado ALL
El predicado ALL se utiliza para recuperar únicamente aquellos registros de la consulta principal
que satisfacen la comparación con todos los registros recuperados en la subconsulta. Si se cambia
ANY por ALL en el ejemplo anterior, la consulta devolverá únicamente aquellos productos cuyo
precio unitario sea mayor que el de todos los productos vendidos con un descuento igual o mayor
al 25 por ciento. Esto es mucho más restrictivo.
Predicado IN
El predicado IN se emplea para recuperar únicamente aquellos registros de la consulta principal
para los que algunos registros de la subconsulta contienen un valor igual.
El ejemplo siguiente devuelve todos los productos vendidos con un descuento igual o mayor al 25
% ciento:
Predicado EXISTS
El predicado EXISTS (con la palabra reservada NOT opcional) se utiliza en comparacione s de
verdad/falso para determinar si la subconsulta devuelve algún registro.
Supongamos que deseamos recuperar todos aquellos clientes que hayan realizado al menos un
pedido:
Se puede utilizar también alias de l nombre de la tabla en una subconsulta para referirse a tablas
listadas en la cláusula FROM fuera de la subconsulta.
El ejemplo siguiente devuelve los nombres de los empleados cuyo salario es igual o mayor que el
salario medio de todos los empleados con e l mismo título. A la tabla Empleados se le ha dado el
alias T1:
Otros ejemplos:
Obtiene una lista con el nombre, cargo y salario de todos los agentes de ventas cuyo salario es
mayor que el de todos los jefes y directores.
Obtiene una lista con el nombre y el precio unitario de todos los productos con el mismo precio
que el almíbar anisado.
Obtiene una lista de las compañías y los contactos de todos los clientes que han realizado un
pedido en el segundo trimestre de 1993.
Selecciona el nombre de todos los empleados que han reservado al menos un pedido.
Recupera el Código del Producto y la Cantidad pedida de la tabla pedidos, extrayendo el nombre
del producto de la tabla de productos.
Recupera números de vuelo y capacidades de aquellos vuelos con destino Madrid y plazas libres.
Supongamos ahora que tenemos una tabla con los identificadores de todos los productos y el
stock de cada uno de ellos. En otra tabla se encuentran todos los pedidos pendientes de envío. Se
trata de averiguar qué productos no se pueden enviar por falta de stock.
SELECT PedidosPendientes.Nombre
FROM PedidosPendientes
GROUP BY PedidosPendientes.Nombre
HAVING SUM(PedidosPendientes.Cantidad < (SELECT Productos.Stock
FROM Productos
WHERE Productos.IdProducto = PedidosPendientes.IdProducto));
Supongamos que en nuestra tabla de empleados deseamos buscar todas las mujeres cuya edad
sea mayor a la de cualquier hombre:
SELECT Empleados.Nombre
FROM Empleados
WHERE Sexo = 'M'
AND Edad > ANY (SELECT Empleados.Edad
FROM Empleados
WHERE Sexo ='H')
SELECT Empleados.Nombre
FROM Empleados
WHERE Sexo = 'M'
AND Edad > (SELECT Max( Empleados.Edad )
FROM Empleados
WHERE Sexo ='H')
Resultado
3 > ANY (2,5,7) Cierto
3 = ANY (2,5,7) Falso
3 = ANY (2,3,5,7) Cierto
3 > ANY (2,5,7) Falso
3 < ANY (5,6,7) Falso
8. Integridad de Datos
La integridad de datos se refiere a los valores reales que se almacenan y se utilizan en las
estructuras de datos de la aplicación. La aplicación debe ejercer un control deliberado sobre todos
los procesos que utilicen los datos para garantizar la co rrección permanente de la información.
Existen 3 tipos de integridad:
Dominio (o columna): Valores válidos para las columnas y verificación de nulos.
Entidad (o tabla): Requiere que todos los registros tengan un identificador único
Referencial: Asegura las relaciones entre tablas
Tipo de dato: Controla el tipo de dato que puede guardarse en una columna. Es solo el primer
paso.
Reglas y Valores Predeterminados (Rules and Defaults): Las reglas definen valores aceptables para
una columna y Defaults define valores predeterminado para la columnas cuando estás no reciben
un valor específico. Son dos objetos independientes y pueden ser asociados a una o más
columnas. No son compatibles con ANSI.
Restricciones (Constraints)
Definición
Las restricciones son un método estándar ANSI de reforzar la integridad de datos. Existen distintos
tipos de restricciones:
PRIMARY KEY
DEFAULT
CHECK
UNIQUE
FOREIGN KEY
Se pueden crear restricciones usando CREATE TABLA o ALTER TABLE o usando el SQL Server
Management Studio.
PRIMARY KEY
Una tabla suele tener una columna o una combinación de columnas cuyos valores identifican de
forma única cada fila de la tabla. Estas co lumnas se denominan claves principales de la tabla y
exigen la integridad de entidad de la tabla. Puede crear una clave principal mediante la definición
de una restricción PRIMARY KEY cuando crea o modifica una tabla.
Consideraciones:
Cuando especifica una restricción PRIMARY KEY en una tabla, el Motor de base de datos exige la
unicidad de los datos mediante la creación de un índice único para las columnas de la clave
principal. Este índice también permite un acceso rápido a los datos cuando se utiliza la clave
principal en las consultas.
Ejemplo:
CREATE TABLE [HumanResources].[Department]
([DepartmentID] [smallint] IDENTITY(1,1) NOT NULL,
[Name] [dbo].[Name] NOT NULL,
[GroupName] [dbo].[Name] NOT NULL,
[ModifiedDate] [datetime] NOT NULL,
CONSTRAINT [PK_Department_DepartmentID]
PRIMARY KEY CLUSTERED ([DepartmentID] ASC )
WITH (IGNORE_DUP_KEY = OFF)
ON [PRIMARY])
DEFAULT
Cada columna d e un registro debe contener un valor, aunque sea un valor nulo. Si la columna
acepta valores nulos, puede cargar la fila con un valor nulo. Pero, dado que puede no resultar
conveniente utilizar columnas que acepten valores nulos, una mejor solución podría ser establecer
una definición DEFAULT o valor predeterminado para la columna siempr e que sea necesario. Por
ejemplo, es habitual especificar el valor cero como valor predeterminado para las columnas
numéricas, o N/D (no disponible) como valor predeterminado para las columnas de cadenas
cuando no se especifica ningún valor. Al cargar una fila en una tabla con una definición DEFAULT
para una columna, se indica implícitamente al Motor de base de datos que cargue un valor
predeterminado en la columna en la que no se haya especificado ningún valor. Si una columna no
permite valores nulos y no tiene una definición DEFAULT, deberá especificar explícitamente un
valor para la columna o el Motor de base de datos devolverá un error para indicar que la columna
no permite valores nulos. También puede indicar explícitamente que se inserte un valor
predeterminado para una columna mediante la cláusula DEFAULT VALUES de la instrucción
INSERT.
Consideraciones:
Se aplica solo para la instrucción INSERT.
Cada columna puede tener su propia restricción DEFAULT
No se puede aplicar sobre columnas definidas Identity
Acepta funciones y valores de sistema
Ejemplo:
CREATE TABLE [Production].[Location]
( [LocationID] [smallint] IDENTITY(1,1) NOT NULL,
[Name] [dbo].[Name] NOT NULL,
[CostRate] [smallmoney] NOT NULL
CONSTRAINT [DF_Location_CostRate] DEFAULT ((0.00)),
[Availability] [decimal](8, 2) NOT NULL
CONSTRAINT [DF_Location_Availability]
DEFAULT ((0.00)),
[ModifiedDate] [datetime] NOT NULL
CONSTRAINT [DF_Location_ModifiedDate] DEFAULT (getdate()))
CHECK
Las restricciones CHECK exigen la integridad del dominio mediante la limitación de los valores que
puede aceptar una columna. Son similares a las restricciones FOREIGN KEY porque controlan los
valores que se colocan en una columna. La diferencia reside en la forma en que determina n qué
valores son válidos: las restricciones FOREIGN KEY obtienen la lista de valores válidos de otra tabla,
mientras que las restricciones CHECK determinan los valores válidos a partir de una expresión
lógica que se basa en datos de otra columna de la mis ma tabla. Por ejemplo, es posible limitar el
intervalo de valores para una columna Porcentaje para que solo tome valores entre 0 y 100. Puede
crear una restricción CHECK con cualquier expresión lógica que devuelva TRUE (verdadero) o
FALSE (falso) basándose en operadores lógicos.
Consideraciones:
Se verifica tanto en INSERT como en UPDATE
No puede contener subconsultas
Puede aplicar varias restricciones CHECK a una misma columna.
No puede ser aplicada a columnas con tipo de dato text, ntext o image.
Si se aplica sobre una tabla que contiene datos, los mismos son verificados. Si algún registro no
cumple con la condición la restricción no es aceptada.
Ejemplo:
ALTER TABLE [HumanResources].[EmployeeDepartmentHistory]
WITH CHECK ADD CONSTRAINT [CK_EmployeeDepartmentHistory_EndDate]
CHECK (([EndDate]>=[StartDate] OR [EndDate] IS NULL))
UNIQUE
Puede utilizar restricciones UNIQUE para garantizar que no se escriben valores duplicados en
columnas específicas que no forman parte de una clave principal. Ta nto la restricción UNIQUE
como la restricción PRIMARY KEY exigen la unicidad; sin embargo, debe utilizar la restricción
UNIQUE y no PRIMARY KEY si desea exigir la unicidad de una columna o una combinación de
columnas que no forman la clave principal.
Consideraciones
En una tabla se pueden definir varias restricciones UNIQUE, pero sólo una restricción PRIMARY
KEY.
Además, a diferencia de las restricciones PRIMARY KEY, las restricciones UNIQUE admiten valores
nulos. Sin embargo, de la misma forma que cualq uier valor incluido en una restricción UNIQUE,
sólo se admite un valor nulo por columna.
Es posible hacer referencia a una restricción UNIQUE con una restricción FOREIGN KEY.
Crea un índice único para controlar la restricción.
Ejemplo:
CREATE TABLE [HumanResources].[Employee]
( [EmployeeID] [int] IDENTITY(1,1) NOT NULL,
[NationalIDNumber] [nvarchar](15) NOT NULL UNIQUE NONCLUSTERED,
[ContactID] [int] NOT NULL, …)
FOREIGN KEY
Una clave externa (FK) es una columna o combinación de columnas que se utiliza para establecer y
exigir un vínculo entre los datos de dos tablas. Puede crear una clave externa mediante la
definición de una restricción FOREIGN KEY cuando cree o modifique una tabla. En una referencia
de clave externa, se crea un vínculo entre dos tablas cuando las columnas de una de ellas hacen
referencia a las columnas de la otra que contienen el valor de clave principal. Esta columna se
convierte en una clave externa para la segunda tabla. No es necesario que una restricción
FOREIGN KEY esté vinculada únicamente a una restricción PRIMARY KEY de otra tabla; también
puede definirse para que haga referencia a las columnas de una restricción UNIQUE de otra tabla.
Una restricción FOREIGN KEY puede contener valores nulos, pero si alguna columna de u na
restricción FOREIGN KEY compuesta contiene valores nulos, se omitirá la comprobación de los
valores que componen la restricción FOREIGN KEY. Para asegurarse de que todos los valores de la
restricción FOREIGN KEY compuesta se comprueben, especifique NOT NULL en todas las columnas
que participan.
Consideraciones:
La relación puede estar dada por una o varias columnas. La cantidad de columnas y los tipos de
datos de la sentencia FOREIGN KEY debe coincidir con la cantidad de columnas y los tipos de datos
especificados en la cláusula REFERENCE.
No crea índices automáticamente.
Puede referirse a columnas de la misma tabla.
Un registro referenciado desde otra tabla no puede ser borrado ni modificado.
Ejemplo:
ALTER TABLE
[Sales].[SalesOrderHeader]
WITH CHECK ADD CONSTRAINT [FK_SalesOrderHeader_Customer_CustomerID]
FOREIGN KEY([CustomerID])
REFERENCES [Sales].[Customer] ([CustomerID])
Las restricciones de integridad referencial en cascada permiten definir las acciones que SQL Server
lleva a cabo cuando un usuario intenta eliminar o actualizar una clave a la que apuntan las claves
externas existentes. Las cláusulas REFERENCES de las instrucciones CREATE TABLE y ALTER TABLE
admiten las cláusulas ON DELETE y ON UPDATE. Ambas opciones admiten 4 valores:
CASCADE: Si se intenta eliminar una fila con una clave a la que hacen referencia claves externas de
filas existentes en otras tablas, todas las filas que contiene n dichas claves externas también se
eliminan. Si se intenta actualizar un valor de clave de una fila a cuyo valor de clave hacen
referencia claves externas de filas existentes en otras tablas, también se actualizan todos los
valores que conforman la clave externa al nuevo valor especificado para la clave.
SET NULL: Si se intenta eliminar o actualizar una fila con una clave a la que hacen referencia las
claves externas de las filas existentes de otras tablas, todos los valores que conforman la clave
externa de las filas a las que se hace referencia se establecen en nulo. Todas las columnas de clave
externa de la tabla de destino deben aceptar valores nulos para que esta restricción se ejecute.
SET DEFAULT: Si se intenta eliminar o actualizar una fila con una clave a la que hacen referencia las
claves externas de las filas existentes de otras tablas, todos los valores que conforman la clave
externa de las filas a las que se hace referencia se establecen como predeterminados. Todas las
columnas de clave externa de la tabla de destino deben tener una definición predeterminada para
que esta restricción se ejecute. Si una columna acepta valores nulos y no se ha establecido ningún
valor predeterminado explícito, NULL se convierte en el valor predeterminado implí cito de la
columna. Todos los valores distintos de nulo que se establecen debido a SET DEFAULT deben tener
unos valores correspondientes en la tabla principal para mantener la validez de la r estricción de la
clave externa.
9. Procedimientos Almacenados
Definición
Un procedimiento almacenado (stored procedure) es una colección de sentencias Transact-SQL
que se guardan dentro de la base de datos. Son métodos de encapsulación con tareas repetitivas
que soportan el uso de variables, ejecuciones condicionales y otras características de rogramación.
Pueden:
· Aceptar parámetros de entrada y devolver varios valores en forma de parámetros de salida al
lote o al procedimiento que realiza la llamada.
· Contener instrucciones de programación que realicen operaciones en la base de datos,
incluidas las llamadas a otros procedimientos.
· Devolver un valor de estado a un lote o a un procedimiento que realiza una llamada para
indicar si la operación se ha realizado correctamente o se han producido errores (y el motivo
de éstos).
Los procedimientos almacenados difieren de las funciones en que no devuelven valores en lugar
de sus nombres ni pueden utilizarse directamente en una expresión.
Los procedimientos almacenados son objetos de ámbito de esquema y sus nombres deben
ajustarse a las reglas para los identificadores.
Sólo puede crear un procedimiento almacenado en la base de datos actual.
· Puede crear el procedimiento una vez y llamarlo desde el programa tantas veces como desee.
Así, puede mejorar el mantenimiento de la aplicación y permiti r que las aplicaciones tengan
acceso a la base de datos de manera uniforme.
· Constituyen código con nombre que permite el enlace diferido. Esto proporciona un nivel de
direccionamiento indirecto que facilita la evolución del código.
· Pueden reducir el tráfico de red.
· Una operación que necesite centenares de líneas de código Transact-SQL puede realizarse
mediante una sola instrucción que ejecute el código en un procedimiento, en vez de enviar
cientos de líneas de código por la red.
Creación
Puede crear procedimientos almacenados usando la instrucción CREATE PROCEDURE de Transact -
SQL. Cuando cree un procedimiento almacenado, deberá especificar lo siguiente:
Todos los parámetros de entrada y de salida del lote o del procedimiento que realiza la llamada.
Las instrucciones de programación que realicen operaciones en la base de datos, incluidas las
llamadas a otros procedimientos.
El valor de estado devuelto al lote o al procedimiento que realiza la llamada, a fin de indicar que la
operación se ha realizado correctamente o que se ha producido un error (y el motivo del mismo).
Las instrucciones de control de errores necesarias para detectar y administrar posibles errores.
Ejemplo:
CREATE PROC Production.LongLeadProducts
AS SELECT Name, ProductNumber FROM Production.Product WHERE DaysToManufacture >= 1 GO
Ejecución
Para ejecutar un procedimiento almacenado, utilice la instrucción EXECUTE o EXEC de Transact -
SQL. También puede ejecutar un procedimiento almacenado sin necesidad de utilizar la palabra
clave EXECUTE si el procedimiento almacenado es la primera instrucción del lote.
Ejemplo:
EXEC Production.LongLeadProducts
Modificación y Borrado
Para cambiar las instrucciones o los parámetros de un procedimiento almacenado, puede eliminar
y volver a crear el procedimiento, o bien modificar el procedimiento almacenado en un solo paso.
Cuando elimina un procedimiento almacenado y lo vuelve a crear, se pierden todos los permisos
que están asociados con él. Cuando modifica el procedimiento almacenado, se cambia la
definición de los parámetros o del procedimiento pero se conservan los permisos definidos para el
procedimiento almacenado, y los procedimientos almacenados o desencadenadores dependientes
no se ven afectados. También es posible modificar un procedimiento almacenado para cifrar la
definición o provocar que se vuelva a compilar el procedimiento cada vez que se ejecute. Para
modificar o borrar un procedimiento almacenado use la instrucciones ALTER / DROP PROCEDURE.
Antes de modificar o borrar un procedimiento verifique sus dependencias de manera de control ar
como afectará esto al resto de los objetos.
Vistas de catálogo:
Sys_procedures devuelve la lista de procedimientos de la base de datos
Sys_parameters devuelve la definición de los parámetros de los procedimientos o
sys.sql_modules devuelve la lista de vistas, procedimientos, funciones y desencadenadores de la
base de datos
Sys_Sql_Dependencies permite verificar las dependencias del objeto.
Procedimiento almacenado:
sp_HelpText permite ver la definición de una vista
sp_Help y sp_depends permite verificar las dependencias del objeto.
Cada parámetro de un procedimiento almacenado debe definirse con un nombr e único. Los
nombres de los procedimientos almacenados deben empezar por un solo carácter @, como una
variable estándar de Transact -SQL, y deben seguir las reglas definidas para los identificadores de
objetos. El nombre del parámetro se puede utilizar en e l procedimiento almacenado para obtener
y cambiar el valor del parámetro. Es posible pasar valores a los procedimientos almacenados de
dos maneras: asignando un nombre explícitamente a los parámetros y asignando el valor
apropiado, o bien suministrando los valores del parámetro especificados en la instrucción CREATE
PROCEDURE sin asignarles un nombre. Por ejemplo, si el procedimiento almacenado
miProcedimiento espera tres parámetros llamados @Primero, @Segundo y @Tercero, los valores
pasados al procedimiento almacenado pueden asignarse a los nombres de los parámetros;
por ejemplo:
AS
IF (@MinimumLength < 0)
BEGIN
RAISERROR('Dato inválido', 14, 1)
RETURN
END
Por posición:
EXEC Production.LongLeadProducts 4
Como el parámetro tiene un valor predeterminado asociado se puede llamar al procedimiento si n
argumentos, el mismo asumirá el valor 1
EXEC Production.LongLeadProducts
Parámetros de Salida
Para especificar un parámetro de salida, debe indicar la palabra clave OUTPUT en la definición del
parámetro del procedimiento almacenado. El procedimiento almacenado devuelve el valor actual
del parámetro de salida al programa que lo llama cuando se abandona el procedimiento
almacenado. El programa que realiza la llamada también debe utilizar la palabra clave OUTPUT al
ejecutar el procedimiento almacenado, a fin de guardar el valor del parámetro en una variable que
se pueda utilizar en el programa que llama.
Ejemplo:
CREATE PROC HumanResources.AddDepartment
@Name nvarchar(50), @GroupName nvarchar(50), @DeptID smallint OUTPUT
Manejo de Errores
Manejo Estructurado de Excepciones
El manejo estructurado de excepciones de SQL Server 2005 es un requerimiento importante para
varias sentencias Transact -SQL particularmente las que involucran transacciones. Reduce el
trabajo requerido para controlar los errores y genera un código más confiable.
TRY...CATCH en Transact-SQL
Los errores en el código de Transact -SQL se pueden procesar mediante una construcción
TRY…CATCH similar a las características de control de excepciones de los lenguajes Microsoft
Visual C++ y Microsoft Visual C#. Las construcciones TRY…CATCH constan de dos partes: un bloque
TRY y uno CATCH. Cuando se detecta una condición de error en una instrucción de Transact -SQL
que se encuentra dentro de un bloque TRY, se pasa el control a un bloque CATCH do nde se puede
procesar el error. Cuando el bloque CATCH controla la excepción, el control se transfiere a la
primera instrucción de Transact-SQL siguiente a la instrucción END CATCH. Si la instrucción CATCH
es la última instrucción de un procedimiento almac enado o un desencadenador, el control vuelve
al código que los invocó. No se ejecutarán las instrucciones de Transact -SQL del bloque TRY que
siguen a la instrucción que genera un error. Si no existen errores en el bloque TRY, el control pasa
a la instrucci ón inmediatamente después de la instrucción END CATCH asociada. Si la instrucción
END CATCH es la última instrucción de un procedimiento almacenado o un desencadenador, el
control pasa a la instrucción que invocó al procedimiento almacenado o el desencaden ador. Un
bloque TRY se inicia con la instrucción BEGIN TRY y finaliza con la instrucción END TRY. Se pueden
especificar una o varias instrucciones de Transact -SQL entre las instrucciones BEGIN TRY y END
TRY. Un bloque TRY debe ir seguido inmediatamente por un bloque CATCH. Un bloque CATCH se
inicia con la instrucción BEGIN CATCH y finaliza con la instrucción END CATCH. En Transact -SQL,
cada bloque TRY se asocia a un sólo bloque CATCH.
Sintaxis:
BEGIN TRY
{sentencias SQL | bloque sentencias}
END TRY
BEGIN CATCH
{sentencias SQL | bloque sentencias}
END CATCH
Ejemplo:
CREATE PROCEDURE dbo.AgregarDatos @a int, @b varchar(50)
AS
BEGIN TRY
INSERT INTO TablaPrueba VALUES (@a, @b)
END TRY
BEGIN CATCH
SELECT ERROR_NUMBER() as NumError, ERROR_MESSAGE() as MsgError
END CATCH
GO
Ejecución:
EXEC dbo.AgregarDatos 1, 'Primero'
EXEC dbo.AgregarDatos 2, 'Segundo' EXEC dbo.AgregarDatos 1, 'Tercero'
Este último trata de insertar nuevamente la clave 1 la cual ya fue ingresada.
La respuesta a la ejecución es:
NumError MsgError
----------- ------------------------------------------------------------------------------------------------------------------
2627 Violation of PRIMARY KEY constraint 'PK_TablaPrueba'. Cannot insert duplicate key in object
'dbo.TablaPrueba'.
Transacciones no confirmables
10. Funciones
Introducción
Definición
Al igual que las funciones en los lenguajes de programación, las funciones definidas por el usuario
de Microsoft SQL Server son rutinas que aceptan parámetros, realizan una acción, como un cálculo
complejo, y devuelven el resultado de esa acción como un valor. El valor devuelto puede ser un
valor escalar único o un conjunto de resultados.
Ventajas de las Funciones
Permiten una programación modular: Puede crear la función una vez, almacenarla en la base de
datos y llamarla desde el programa tantas veces como desee. Las funciones definidas por el
usuario se pueden modificar, independientemente del código de origen del programa.
Permiten una ejecución más rápida: Al igual que los procedimientos almacenados, las funciones
definidas por el usuario Transact -SQL reducen el costo de compilación del código Transact-SQL
almacenando los planes en la caché y reutilizándolos para ejecuciones repetidas. Esto significa que
no es necesario volver a analizar y optimizar la función definida por el usuario con cada uso, lo que
permite obtener tiempos de ejecución mucho más rápidos.
Pueden reducir el tráfico de red: Una operación que filtra datos basándose en restricciones
complejas que no se puede expresar en una sola expresión escalar se puede expresar como una
función. La función se puede invocar en la cláusula WHER E para reducir el número de filas que se
envían al cliente.
Tipos de Funciones
Escalares (scalar functions) : Devuelven un único valor de datos del tipo definido en la cláusula
RETURNS.
Con Valores de Tabla en Línea (inline table -valued functions): Devuelven un tipo de datos Table.
No tienen cuerpo; la tabla es el conjunto de resultados de una sola instrucción SELECT.
Con Valores de Tabla con múltiples instrucciones (multi -statement tabled -value functions) :
Devuelven un tipo de datos Table. El cuerpo de la función, definido en un bloque BEGIN...END,
contiene una serie de instrucciones Transact-SQL que generan e insertan filas en la tabla que se va
a devolver.
Parámetros:
Una función definida por el usuario tiene de cero a varios parámetros de entrada y devuelve un
valor escalar o una tabla. Una función puede tener un máximo de 1024 parámetros de entrada.
Cuando un parámetro de la función tiene un valor predeterminado, debe especificarse la palabra
clave DEFAULT al llamar a la función para poder obtener el valor predeterminado. Este
comportamiento es diferente del de los parámetros con valores predeterminados de
procedimientos almacenados definidos por el usuario, para los cuales omitir el parámetro implica
especificar el valor predeterminado. Las funciones definidas por el usuario no admiten parámetros
de salida.
Creación
Creación
Las funciones se crean con la instr ucción CREATE FUNCTION, se modifican con ALTER FUNCTION y
se borran con DROP FUNCTION. La instrucción CREATE FUNCTION es diferente para cada tipo de
función. CREATE FUNCTION admite una cláusula SCHEMABINDING que enlaza la función con el
esquema de cualquie r objeto al que haga referencia, como tablas, vistas y otras funciones
definidas por el usuario.
Ejemplo:
CREATE FUNCTION Sales.SumSold(@ProductID int)
RETURNS int
AS
BEGIN
DECLARE @ret int
SELECT @ret = SUM(OrderQty)
FROM Sales.SalesOrderDetail WHERE ProductID = @ProductID
IF (@ret IS NULL) SET @ret = 0 RETURN @ret
END
Las funciones con valores escalares deben invocarse como mínimo con el nombre de dos partes de
la función. En estas ubicac iones se permiten funciones definidas por el usuario que devuelven
valores escalares:
Consultas
o Como expresión de la lista de una instrucción SELECT
o Como expresión de cláusula WHERE o HAVING
o Como expresión de las cláusulas GROUP BY u ORDER BY
o Como expresión de la cláusula SET en una instrucción UPDATE
o Como expresión en el VALUES de una instrucción INSERT
Definición de Tablas
o En una restricción CHECK
o En una restricción DEFAULT
o En columnas calculadas
Sentencias SQL
o En una condición control de flujo
o En una expresiones CASE
o En una sentencia PRINT
Funciones y procedimientos almacenados
Ejecución
Ejemplo:
CREATE FUNCTION HumanResources.EmployeesForManager (@ManagerId int)
RETURNS TABLE
AS
Ejecución:
SELECT * FROM HumanResources.EmployeesForManager(3)
Funciones con Valores de Tabla con Múlt iples Instrucciones (multi -statement tabled -value
functions)
Las funciones con valores de tabla definidas por el usuario devuelven un tipo de datos table.
Pueden ser unas eficaces alternativas a las vistas. Una función definida por el usuario con valores
de tabla se puede usar donde se permiten las expresiones de vista o de tabla en las consultas
Transact-SQL. Mientras que las vistas se limitan a una única instrucción SELECT, las funciones
definidas por el usuario pueden contener instrucciones adicionales que permiten una lógica más
eficaz que en las vistas. Una función definida por el usuario con valores de tabla también puede
reemplazar procedimientos almacenados que devuelven un solo conjunto de resultados. En la
cláusula FROM de una instrucción Transact-SQL es posible hacer referencia a la tabla que devuelve
una función definida por el usuario, pero esto no es posible con los procedimientos almacenados
que devuelven conjuntos de resultados.
Ninguna instrucción Transact-SQL de una función con valores de tabla puede devolver un conjunto
de resultados directamente a un usuario. La única información que la función puede devolver al
usuario es el tipo de datos table devuelto por la función.
Ejemplo:
CREATE FUNCTION HumanResources.EmployeeNames
(@format nvarchar(9))
RETURNS @tbl_Employees TABLE (EmployeeID int PRIMARY KEY, [Employee Name] nvarchar(100))
AS
BEGIN
IF (@format = 'SHORTNAME')
INSERT @tbl_Employees
SELECT EmployeeID, LastName FROM HumanResources.vEmployee ELSE IF (@format =
'LONGNAME')
INSERT @tbl_Employees
SELECT EmployeeID, (FirstName + ' ' + LastName) FROM HumanResources.vEmployee
RETURN
END
Ejecución:
SELECT * FROM HumanResources.EmployeeNames('LONGNAME') SELECT * FROM
HumanResources.EmployeeNames('SHORTNAME')
Procedimiento almacenado:
· sp_HelpText permite ver la definición de una función
· sp_Help
· sp_depends permite verificar las dependencias del objeto.
· Etc.