Chrome-Extension Mhjfbmdgcfjbbpaeojofohoefgiehjai Index-Material

Universidad Nacional del Nordeste
Facultad de Ciencias Exactas y Naturales y Agrimensura
Í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
Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 1

OUTER JOIN LEFT..............................................................................................................29

LEFT OUTER JOIN...............................................................................................................29
OUTER JOIN RIGHT............................................................................................................29
OUTER JOIN FULL ..............................................................................................................30
5. Agrupamiento de Registros y Funciones Agregadas.....................................................32
Funciones Agregadas o de Grupo ........................................................................................32
Creación de Grupos de Datos...............................................................................................33
Exclusión de Resultados de Grupo ......................................................................................34
6. Sentencias INSERT – DELET – UPDATE – CREATE TABLE ................................36
Sentencia INSERT ................................................................................................................36
Sentencia DELETE...............................................................................................................36
Sentencia UPDATE ..............................................................................................................37
Sentencia CREATE TABLE ................................................................................................38
7. Subconsultas o Subquerys ................................................................................................. 40
Definición ..............................................................................................................................40
8. Integridad de Datos ............................................................................................................45
Restricciones (Constraints)................................................................................................... 45
PRIMARY KEY.....................................................................................................................45
DEFAULT ............................................................................................................................46
CHECK................................................................................................................................. 47
UNIQUE..............................................................................................................................47
FOREIGN KEY .....................................................................................................................48
9. Procedimientos Almacenados ...........................................................................................50
Definición ..............................................................................................................................50
Creación................................................................................................................................. 51
Ejecución ...............................................................................................................................52
Modificación y Borrado........................................................................................................ 52
Manejo de Errores.................................................................................................................54
10. Funciones............................................................................................................................57
Introducción...........................................................................................................................57
Definición...........................................................................................................................57
Ventajas de las Funciones ................................................................................................57
Tipos de Funciones ...........................................................................................................57
Parámetros:.......................................................................................................................58
Creación................................................................................................................................. 58
Ejecución ...............................................................................................................................59

1. Conceptos de Bases de Datos
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.
Sistema de gestión de base de datos (SGBD)

Los sistemas de gestión de base de datos son un tipo de software muy específico, dedicado a
servir de interfaz entre los datos, el usuario y las aplicaciones que la utilizan. El propósito general
de los sistemas de gestión de base de datos es el de manejar de forma clara, sencilla y ordenada
un conjunto de datos que posteriormente se convertirán en información relevante, para un buen
manejo de datos.
Existen distintos objetivos que deben cumplir los SGBD:

Abstracción de la información . Los SGBD ahorran a los usuarios detalles acerca del
almacenamiento físico de los datos. Da lo mismo si una base de datos ocupa uno o cientos de
archivos, este hecho se hace transparente al usuario.
Independencia. La independencia de los datos consiste en la capacidad de modificar el esquema
(físico o lógico) de una base de datos sin tener que realizar cambios en las aplicaciones que se
sirven de ella.
Consistencia. En aquellos casos en los que no se ha logrado eliminar la redundancia, será
necesario vigilar que aquella información que aparece repetida se actualice de forma coherente,
es decir, que todo s los datos repetidos se actualicen de forma simultánea. En los SGBD existen
herramientas que facilitan la programación de este tipo de condiciones.
Seguridad. La información almacenada en una base de datos puede llegar a tener un gran valor.
Los SGBD deb en garantizar que esta información se encuentra segura frente a usuarios
malintencionados, que intenten leer información privilegiada; frente a ataques que deseen
manipular o destruir la información; o simplemente ante las torpezas de algún usuario autoriz ado
pero descuidado. Normalmente, los SGBD disponen de un complejo sistema de permisos a
usuarios y grupos de usuarios, que permiten otorgar diversas categorías de permisos.

Integridad. Se trata de adoptar las medidas necesarias para garantizar la validez de los datos
almacenados. Es decir, se trata de proteger los datos ante fallos de hardware, datos introducidos
por usuarios descuidados, o cualquier otra circunstancia capaz de corromper la información
almacenada. 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.
Las ventajas de su uso son:

Proveen faci lidades para la manipulación de grandes volúmenes de datos. Simplificando la
programación de chequeos de consitencia, manejando las políticas de respaldo adecuadas que
garantizan que los cambios de la base serán siempre consistentes sin importar si hay err ores en el
disco, o hay muchos usuarios accediendo simultáneamente a los mismos datos, o se ejecutaron
programas que no terminaros su trabajo correctamente, etc., permitiendo realizar modificaciones
en la organización de los datos con un impácto mínimo en el código de los programas y
permitiendo implementar un manejo centralizado de la seguridad de la información (acceso a
usuarios autorizados), protección de información, de modificaciones, inclusiones, consulta.
Las facilidades anteriores bajan drásticamente los tiempos de desarrollo y aumentan la calidad del
sistema desarrollado si son bien explotados por los desarrolladores.
Usualmente, proveen interfases y lenguajes de consulta que simplifican la recuperación de los
datos.
Las desventajas son:

Generalmente es necesario disponer de una o más personas que administren la base de datos, en
la misma forma en que suele ser necesario en instalaciones de cierto porte disponer de una o más
personas que administren los sistemas operativos. Esto puede llegar a incrementar los costos de
operación en una empresa. Sin embargo hay que balancear este aspecto con la calidad y
confiabilidad del sistema que se obtiene.
Si se tienen muy pocos datos que son usados por un único usuario por vez y no hay que realizar
consultas complejas sobre los datos, entonces es posible que sea mejor usar una planilla de
cálculo.

Bases de Datos OLTP (On Line Transactional Processing)

Los sistemas OLTP son bases de datos orientadas al procesamiento de transacciones. El proceso
transaccional es típico de las bases de datos operacionales. El acceso a los datos está optimizado
para tareas frecuentes de lectura y escritura
Bases de Datos OLAP (On Line Analytical Processing)
Los sistemas OLAP son bases de datos orientadas al procesamiento analítico. Este análisis suele
implicar, generalmente, la lectura de grandes cantidades de datos para llegar a extraer algún tipo
de información útil: tendencias de ventas, patrones de comportamiento de los consumidores,
elaboración de informes complejos… etc. El acceso a los datos suele ser de sólo lectura. La acción
más común es la consulta, con muy pocas inserciones, actualizaciones o eliminaciones
Objetos de la base de datos
- 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.

Componentes del SQL

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.
Las sentencias de SQL se clasifican según su finalidad dando origen a 3 sublenguajes:
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:
CREATE Utilizado para crear nuevas tablas, campos e índices
DROP Empleado para eliminar tablas e índices
Utilizado para modificar las tablas agregando campos o cambiando la definición de

ALTER
los campos.
Comandos DML:
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
Esquema es un espacio de nombres (namespace) distinto que existe de forma

independientemente del usuario de base de datos que lo creó. Es decir, un esquema simplemente
es un contenedor de objetos. Cu alquier usuario puede ser propietario de un esquema, y esta
propiedad es transferible. Todas las bases de datos contienen un esquema llamado dbo. Es el
esquema predeterminado para todos los usuarios cuando no se define explícitamente el esquema
Se pueden crear esquemas usando la herramienta SQL Server Management Studio o la instrucción
CREATE SCHEMA.
Para modificar o borrar un esquema use las instrucciones ALTER/DROP SCHEMA.
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.
- Al dar de baja un usuario no es necesario renombrar los objetos que le pertenecían.
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

usuario, si no lo encuentra intenta usando dbo. Para asignar un esquema predeterminado a un

usuario se usa ALTER USER
ALTER USER Curso WITH DEFAULT_SCHEMA = Compras

Tablas
Definición
Son objetos de una base de datos que contienen los datos, normalm ente estos datos se
almacenan en tablas permanentes; no obstante, también se pueden crear tablas temporales.
Las tablas se almacenan en los archivos de base de datos hasta que se eliminan, y están
disponibles para cualquier usuario que cuente con los permisos necesarios.
Puede definir hasta 1.024 columnas por tabla.
Los nombres de las tablas y de las columnas deben seguir las reglas de los identificadores; tienen
que ser únicos dentro de una tabla específica, pero puede utilizar el mismo nombre de columna en
distintas tablas de la misma base de datos.
Aunque los nombres de las tablas tienen que ser únicos para cada esquema de una base de datos,
puede crear varias tablas con el mismo nombre si especifica distintos esquemas para cada una de
ellas. Las tablas temporales son similares a las permanentes, salvo por el hecho de que las tablas
temporales se almacenan en una base de datos del sistema llamada Tempdb y se eliminan
automáticamente cuando ya no se utilizan.
Hay dos tipos de tablas temporales: locales y globales. Se diferencian entre sí por los nombres, la
visibilidad y la disponibilidad. Las tablas temporales locales tienen como primer carácter de sus
nombres un solo signo de número (#); sólo son visibles para el usuario de la conexión actual y se
eliminan cuando el usuario se desconecta de la instancia de SQL Server. Las tablas temporales
globales presentan dos signos de número (##) antes del nombre; son visibles para cualquier
usuario después de su creación y se eliminan cuando todos los usuarios que hacen referencia a la
tabla se desconectan de la instancia de SQL Server.
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.
Organización de los datos

Los datos de una base de datos SQL Server están organizados en páginas. Las páginas de un
archivo de datos de SQL Server están numeradas secuencialmente, come nzando por cero (0) para
la primera página del archivo. Cada archivo de una base de datos tiene un número de identificador
único. En SQL Server, el tamaño de página es de 8 KB.
Las extensiones (extents) son una colección de ocho páginas físicamente contiguas; se utilizan para
administrar las páginas de forma eficaz. Todas las páginas se almacenen en extensiones. Constan
de ocho páginas contiguas físicamente, es decir 64 KB.

3. Sentencia Básica del SQL – SELECT

Objetivos
Describir las características b ásicas de la sentencia SELECT de lenguaje estructurado de consulta
(SQL), que permiten visualizar (devolver/recuperar) datos de la base de datos. Es posible mostrar
todas las columnas de una tabla, o restringir las columnas que se muestran.
Capacidades de la Sentencia SQL SELECT

Una sentencia SELECT permite hacer lo siguiente:
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.
Unión: la capacidad de unión permite recuperar datos

que están almacenados en diferentes tablas,
obteniendo como resultado una combinación de los
datos. La estructura de los datos a unir debe ser la
misma (igual grado y dominio).
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
Casa Central 4020 Juan Perez 1000
Norte 2010 Jose Gomez 800
Centro 1050 María Gonzales 1500
Casa_Central 2070 Juana Dominguez 300
Sur 2040 Oscar Arce 900
Prestamos
Nombre_Sucursal Nro_Cuenta Nombre_Cliente Prestamo
Este 3020 Cristian Gimenez 2000

Norte 1010 Nicolas Prieto 3800
Centro 5050 Eduardo Gonzales 5100
Casa_Central 3070 Juan Coronel 3000
Sur 4040 Miguel Perez 2900
Oeste 6025 Rosa Gomez 6000
Se desea encontrar los clientes de la Casa Central
SELECT DISTINCT nombre_cliente_d

FROM depositos
WHERE nombre_sucursal = “CASA CENTRAL”
Union
SELECT DISTINCT nombre_cliente_p
FROM prestamos
WHERE nombre_sucursal = “CASA CENTRAL”
Sentencia SELECT Básica

En su forma más simple, una sentencia SELECT incluye lo siguiente:
· Una cláusula SELECT, que especifica las columnas a mostrar
· Una cláusula FROM, que especifica la tabla que contiene las columnas listadas en la
cláusula SELECT
SELECT [DISTINCT] {*,columna | expresión [alias],...}

FROM tabla
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.

Ejemplo 2: Visualizar el código de proveedor y de localidad de la tabla Proveedores

SELECT proveedor_id, localidad_id
FROM proveedores
Nota: Las sentencias SQL

· no son case-sensitive (no diferencian mayúsculas/minúsculas).
· Las sentencias SQL pueden ocupar una o más líneas.
Expresiones Aritméticas
Permiten modificar la forma en que se muestra la información, realizando cálculos, mediante

expresiones aritméticas.
Una expresión aritmética puede contener nombres de columna, constantes numéricas y
operadores aritméticos.
Los operadores aritméticos disponibles en SQL son:
Operador Descripción
+ 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

Ejemplo: mostrar el apellido, el salario y la remuneración anual de los empleados. La

remuneración anual se calcula como 12 multiplicado por el salario mensual, más una bonificación
única de $100.
SELECT apellido, salario, 12*salario+100

FROM empleados;
Según el orden de prioridades visto, la multiplicación se realiza antes que la suma.

Los paréntesis permiten reforzar el orden de prioridad estándar y mejorar la claridad. Por ejemplo,
la expresión anterior se puede escribir como (12*salary)+100 sin que haya ningún cambio en el
resultado.
Los paréntesis además permiten modificar las reglas de prioridad, especificando otro orden de
ejecución de los operadores. Por ejemplo:
SELECT apellido, salario, 12*(salario+100)
FROM empleados;
En primer lugar se realiza la suma, y el resultado se multiplica por 12.
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, con la cabecera “Empleado”

SELECT apellido + nombre AS Empleado
FROM empleados

Nota: en la salida obtenida, nombre y apellido no tendrán separación entre sí.

Cadenas de Caracteres Literales
Un literal es un carácter, un número o una fecha que está incluido en la lista SELECT y que no es un
nombre de columna o un alias de col umna. Un literal está impreso para cada fila recuperada. Las
cadenas literales de texto de formato libre se pueden incluir en el resultado de la consulta y son
tratados de la misma manera que una columna en la lista SELECT.
Los literales de caracteres y fecha se deben escribir entre comillas simples (' ' – ALT + 39).
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.
Ej: Se reemplaza nulo por 0.

SELECT ISNULL(ManagerID,0)
FROM HumanResources.Employee
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.
Ejemplo: mostrar los productos vendidos, sin repetir, de la tabla facturas_vta
SELECT DISTINCT nombre_producto

FROM facturas_vta;
Ordenamiento y restricción de datos

Sintaxis
SELECT *|{[DISTINCT] columna|expresion [alias],...}
FROM tabla
[WHERE condicion/es]
[ORDER BY columna1, columna2… columnaN [ASC|DESC];

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:
<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
Si a cualquiera de las anteriores condiciones le anteponemos el operador NOT, el resultado de

la operación será el contrario al devuelto sin el operador NOT.

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
Operador (Between …and…)
Para indicar que deseamos recuperar los registros según el intervalo de valore s de un campo
emplearemos el operador Between, cuya sintaxis es:
campo [NOT] BETWEEN valor1 AND valor2
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.
Ejemplo: Mostrar los pedidos realizados en la provincia de Corrientes.
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:
expresión LIKE modelo
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.
SELECT descipción, stock

FROM productos
WHERE descripcion LIKE ‘%SHA%’;
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 apellidos, salario

FROM empleados
WHERE salario > 21000;
SELECT id_producto, existencias

FROM productos

WHERE existencias <= nuevo_pedido;
SELECT *
FROM pedidos
WHERE fecha_envio = #5/10/94#;
SELECT apellidos, nombre

FROM empleados
WHERE apellidos = 'Perez';

FROM empleados
WHERE salario BETWEEN 200 AND 300;

FROM empleados
WHERE apellidos BETWEEN 'Lon' AND 'Tol';
SELECT i_pedido, fecha_pedido
FROM pedidos
WHERE fecha_pedido BETWEEN ‘01-01-2007’ AND ‘30-06-2000’;
SELECT apellidos, nombre, ciudad

FROM empleados
WHERE ciudad IN (‘Corrientes’, ‘Chaco’, ‘Formosa’);
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.
SELECT codigoPostal, nombre, telefono

FROM clientes
ORDER BY nombre;
Se pueden ordenar los registros por más de un campo, como:

FROM clientes
ORDER BY codigoPostal, nombre;

Se puede especificar el orden de los registros: ascendente mediante la claúsula ASC (valor por
defecto) ó descendente (DESC).

FROM clientes
ORDER BY codigoPostal DESC , nombre ASC;
Se puede especificar el orden de los registros por un campo que no figura en la SELECT:
SELECT nombre, telefono

FROM clientes ORDER BY codigoPostal;
Funciones de fila simple
Las funcion es proveen un poderoso conjunto de herramientas para manipular el resultado de

grupos de filas, convertir tipos de datos, proveer resultados de acuerdo a determinadas
condiciones, dar formato a las salidas, etc.
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”.
Funciones de una sola fila
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.
Existen diferentes tipos. Entre ellas:

Funciones de caracteres : Aceptan argumentos de car acteres y pueden devolver valores de
caracteres y numéricos.
Funciones numéricas: Aceptan entradas numéricas y devuelven valores numéricos.
Funciones de fecha : Operan sobre valores de tipo DATE. En general devuelven un valor de tipo
DATE. Funciones de conversión: Convierten tipos de dato.

Funciones de caracteres a nivel de fila
Función/Ejemplo Propósito/Resultado
LOWER(columna|expresión) Convierte a minúsculas los caracteres alfabéticos
LOWER(‘ABM Empleado') abm empleado
UPPER(columna|expresión) Convierte a mayúsculas los caracteres alfabéticos

UPPER(‘ABM Empleado') ABM EMPLEADO
col_1|exp_1 + col_2|exp_2 Concatena la primer cadena con la segunda. Equivalente a || en
Oracle
‘San’ + ‘Martín’ SanMartín
LEN (columna|expresión) Devuelve la cantidad de caracteres

LEN (‘Maria’) 5
SUBSTRING(col|exp, m [,n]) Devuelve la subcadena comenzando por m, y con n caracteres de

longitud. Si m es negativo, la cuenta comienza desde el final de la
cadena. Si n es omitido, devuelve la subcadena hasta el final.
SUBSTRING('HolaMundo',1,4) Hola
ISNULL(col_1|exp_1, col_2|exp_2) Si el primer valor es nulo, lo convierte al valor del segundo.

Ambos datos deben ser del mismo tipo
ISNULL(jefe_name, ‘No tiene jefe’) No tiene jefe
REPLACE(texto, m, n) Sustituye n en m si existe en texto

REPLACE(‘Helo’, ‘e’, ‘i’) Hilo
Funciones numéricas a nivel de fila
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
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 ) ])

Syntax for CONVERT:

CONVERT ( data_type [ ( length ) ] , expression [ , style ] )
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.
FUNCION CASE : ANSI SQL
Evalúan una lista de condiciones y devuelve una de las varias expresiones de resultado posibles.
CASE expr WHEN exp_compara1 THEN expr_devuelta_1

[WHEN exp_compara2 THEN expr_devuelta_2
WHEN exp_comparan THEN expr_devuelta_n
ELSE exp_defecto]
END
Cuando se encuentra la primera coincidencia en el WHEN, se devuelve la expresión THEN. Si no

hay coincidencia, devuelve el valor por defecto del ELSE. Si no existe ELSE, devuelve NULL.
Todas las expresiones (expr, expr_compara y expr_devuelta) deben tener el mismo tipo de dato
(por ejemplo VARCHAR2).
Ejemplo: emitir un listado de los inscriptos a los cursos, con el importe cobrado, según su
condición.

SELECT nombre, condicion,

CASE condicion WHEN 'Publico' THEN precio
WHEN 'Docente' THEN precio * (1 – 15/100)
WHEN 'Alumno' THEN precio * (1 – 20/100)
ELSE precio
END AS "Costo Curso"
FROM curso;

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.
Cuando una condición de unión no es válida o está completamente omitida, el resultado es un

producto Cartesiano, en el que se muestran todas las combinaciones de filas. Todas las filas de la
primera tabla se unen con todas las filas de la segunda tabla.
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.
Consultas de Unión Interna
Cláusula INNER JOIN

Las combinaciones internas sólo devuelven filas cuando hay una fila de ambas tablas, como
mínimo, que coincide con la condición de la combinación. Las combinaciones internas eliminan las
filas que no coinciden con alguna fila de la otra tabla.
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:
SELECT p.Name AS ProductName, NonDiscountSales=(OrderQty * UnitPrice), Discounts =

((OrderQty * UnitPrice) * UnitPriceDiscount)
FROM Production.Product p
INNER JOIN Sales.SalesOrderDetail sod ON p.ProductID = sod.ProductID
ORDER BY ProductName DESC
Consultas de Autocombinación (Autouniones)
La autocombinación se utiliza para unir una tabla consigo misma, comparando valores de dos
columnas con el mismo tipo de datos. La sintaxis en la siguiente:
SELECT alias1.columna, alias2.columna, ...
FROM tabla1 as alias1, tabla1 as alias2
WHERE alias1.columna = alias2.columna
AND otras condiciones;
Por ejemplo, para visualizar el número, nombre y puesto de cada empleado, junto con el número,
nombre y puesto del supervisor de cada uno de ellos se utilizaría la siguiente sentencia:
SELECT t.num_emp, t.nombre, t.puesto, t.num_sup,s.nombre, s.puesto
FROM empleados AS t, empleados AS s
WHERE t.num_sup = s.num_emp;
Consultas de Unión Externa
Clausulas LEFT|RIGHT|FULL OUTER
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:
· LEFT OUTER JOIN o LEFT JOIN

· RIGHT OUTER JOIN o RIGHT JOIN
· FULL OUTER JOIN o FULL JOIN
Utilizar combinaciones externas izquierdas
Imagine una combinación de la tabla Product y de la tabla ProductReview en sus columnas

ProductID. Los resultados muestran solamente los productos para los que se han escrito
revisiones.
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
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
Imagine una combinación de la tabla SalesTerritory y de la tabla SalesPerson en sus columnas

TerritoryID. Los resultados pueden mostrar cualquier territorio de ventas asignado a un vendedor.
El operador ISO de combinación externa derecha, RIGHT OUTER JOIN, indica que todas las filas de
la segunda tabla se deben incluir en los resultados, con independencia de si hay datos coincidentes
en la primera tabla.
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 ;
Éste es el conjunto de resultados.
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
(17 row(s) affected)
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.

Imagine una combinación de la tabla Product y de la tabla SalesOrderDetail en sus columnas

ProductID. Los resultados sólo muestran los productos para los que se han efectuado pedidos de
venta. El operador ISO de combinación externa completa, FULL OUTER JOIN, indica que todas las
filas de ambas tablas se van a incluir en los resultados, con independencia de que haya datos
coincidentes en las tablas.
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
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 ;

5. Agrupamiento de Registros y Funciones Agregadas
Funciones Agregadas o de Grupo
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;

Obtener el importe recaudado por concepto del curso de Word.

SELECT SUM(pago) AS Recaudado
WHERE curso_id = 4;
Creación de Grupos de Datos

En algunas ocasiones se desea conocer un valor de resumen para un determinado grupo de
elementos. Por ejemplo, el promedio de notas de los alumnos inscriptos en los Cursos de Verano,
pero discriminado por curso.
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.
SELECT AVG(nota) AS Promedios

GROUP BY curso_id;
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:
SELECT curso_desc AS Nombre Curso , AVG(nota) AS Promedio

GROUP BY curso_desc
ORDER BY curso_desc;
Nombre Curso Promedio
---------------------------------- -------------
Consulta de Bases de Datos 8
Planilla de Cálculo 7
Procesador de Texto 8
Project 9
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.
El ejemplo siguiente es incorrecto:
SELECT curso_desc AS Nombre Curso , AVG(nota) AS Promedio

GROUP BY curso_id
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 :
SELECT curso_desc NOMBRE, tipo_ins TIPO, COUNT(DNI) CANTIDAD

GROUP BY curso_desc, tipo_ins;
Exclusión de Resultados de Grupo
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.
SELECT curso_desc NOMBRE, COUNT(DNI) CANTIDAD

GROUP BY curso_desc
HAVING COUNT(DNI) > 20;
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.
SELECT curso_desc NOMBRE, COUNT(DNI) CANTIDAD

WHERE pago IS NOT NULL
GROUP BY curso_desc
HAVING COUNT(DNI) > 20
El orden en que se resuelven las cláusulas es el siguiente:
1. Se seleccionan las filas según condición del WHERE
2. Se agrupan las filas según columna_gr del GROUP BY
3. Se aplica la función de grupo a cada grupo
4. Se seleccionan los grupos que cumplen condicion_de_agrupacion del HAVING.
5. Se muestran los datos ordenados según el ORDER BY

6. Sentencias INSERT – DELET – UPDATE – CREATE TABLE
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:
INSERT INTO 'tabla' ('columna1',['columna2,... ']) VALUES ('valor1', ['valor2,...'])
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;
INSERT INTO Production.UnitMeasure VALUES (N'F2', N'Square Feet', GETDATE());
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;
INSERT INTO Production.UnitMeasure (Name, UnitMeasureCode, ModifiedDate)

VALUES (N'Square Yards', N'Y2', GETDATE());
Sentencia DELETE
Una sentencia DELETE de SQL borra uno o más registros existentes en una tabla.
DELETE FROM 'tabla' WHERE 'columna1' = 'valor1'

Ejemplo:
1) Borrar todas las filas de una tabla.

En el ejemplo siguiente se eliminan todas las filas de la tabla SalesPersonQuotaHistory porque no
se utiliza una cláusula WHERE para limitar el número de filas eliminadas.
USE AdventureWorks;
DELETE FROM Sales.SalesPersonQuotaHistory;
2) Borrar un conjunto de registros de una tabla

En el ejemplo siguiente se eliminan todas las filas de la tabla ProductCostHistory en las que el valor
de la columna StandardCost es superior a 1000.00.
USE AdventureWorks;
DELETE FROM Production.ProductCostHistory

WHERE StandardCost > 1000.00;
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:
1) Actualizar TODAS las filas de una tabla al no utilizar WHERE

En los ejemplos siguientes se muestra cómo se pueden ver afectadas t odas las filas si no se utiliza
una cláusula WHERE para especificar la fila o las filas que se deben actualizar.
En este ejemplo se actualizan los valores de las columnas Bonus, CommissionPct y SalesQuota de
todas las filas de la tabla SalesPerson.
USE AdventureWorks;
UPDATE Sales.SalesPerson
SET Bonus = 6000, CommissionPct = .10, SalesQuota = NULL;
2) Actualizar un conjunto de registros

En el ejemplo siguiente se utiliza la cláusula WHERE para especificar las filas que se van a
actualizar. Por ejemplo , Adventure Works Cycles vende su modelo de bicicleta Road -250 en dos
colores: rojo y negro. La compañía ha decidido cambiar el color rojo de este modelo por el rojo
metalizado. La instrucción siguiente actualiza las filas de la tabla Production.Product para todos los
productos Road-250 de color rojo.

USE AdventureWorks;
UPDATE Production.Product
SET Color = 'Metallic Red'
WHERE Name LIKE 'Road-250%' AND Color = 'Red';
Sentencia CREATE TABLE
Este comando crea una nueva tabla dentro del gestor de base de datos.
Modelo de sentencia:
CREATE TABLE ‘tabla’ (

Columna1 <data_type> [
[CONSTRAINT constraint_name] DEFAULT constant_expression]
| [IDENTITY [( seed , increment )]
],
Columna2 <data_type> [NULL | NOT NULL] [CONSTRAINT],
…………
[CONSTRAINT]
)
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.
NULL | NOT NULL

Determina si se permiten valores NULL en la columna. NULL no es estrictamente una restricción,

pero se puede especificar de la misma forma que NOT NULL.
Ejemplo:
1) Definición de una tabla completa.

En el siguiente ejemplo se muestran las definiciones de tablas completas con todas las definiciones
de restricciones para la tablaPurchaseOrderDetail creada en la base de datos AdventureWorks.
Tenga en cuenta que, para ejecutar el ejemplo, el esquema de tabla se cambia adbo.
USE AdventureWorks;
CREATE TABLE [dbo].[PurchaseOrderDetail]

(
[PurchaseOrderID] [int] NOT NULL
REFERENCES Purchasing.PurchaseOrderHeader(PurchaseOrderID),
[LineNumber] [smallint] NOT NULL,
[ProductID] [int] NULL
REFERENCES Production.Product(ProductID),
[UnitPrice] [money] NULL,
[OrderQty] [smallint] NULL,
[ReceivedQty] [float] NULL,
[RejectedQty] [float] NULL,
[DueDate] [datetime] NULL,
[rowguid] [uniqueidentifier] ROWGUIDCOL NOT NULL
CONSTRAINT [DF_PurchaseOrderDetail_rowguid] DEFAULT (newid()),
[ModifiedDate] [datetime] NOT NULL
CONSTRAINT [DF_PurchaseOrderDetail_ModifiedDate] DEFAULT (getdate()),
[LineTotal] AS (([UnitPrice]*[OrderQty])),
[StockedQty] AS (([ReceivedQty]-[RejectedQty])),
CONSTRAINT [PK_PurchaseOrderDetail_PurchaseOrderID_LineNumber]
PRIMARY KEY CLUSTERED ([PurchaseOrderID], [LineNumber])
WITH (IGNORE_DUP_KEY = OFF)
)

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.
Predicado ANY o SOME

Se puede utilizar el predicado ANY o SOME, los cuales son sinónimos, para recuperar registros de
la consulta principal, que satisfagan la comparación con cualquier otro registro recuperado en la
subconsulta.
El ejemplo siguiente devuelve todos los productos cuyo precio unitario es mayor que el de
cualquier
producto vendido con un descuento igual o mayor al 25 por ciento:
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:
SELECT * FROM Productos

WHERE IDProducto IN (SELECT IDProducto
FROM DetallePedido
WHERE Descuento >= 0.25);
Inversamente se puede utilizar NOT IN p ara recuperar únicamente aquellos registros de la

consulta principal para los que no hay ningún registro de la subconsulta que contenga un valor
igual.
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:
SELECT Clientes.Compañía, Clientes.Teléfono

FROM Clientes
WHERE EXISTS (SELECT 1
FROM Pedidos
WHERE Pedidos.IdPedido = Clientes.IdCliente)
Esta consulta es equivalente a esta otra:
SELECT Clientes.Compañía, Clientes.Teléfono

FROM Clientes
WHERE IdClientes IN (SELECT Pedidos.IdCliente
FROM Pedidos)
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:
SELECT Apellido, Nombre, Titulo, Salario

FROM Empleados AS T1
WHERE Salario >= (SELECT Avg(Salario)
FROM Empleados
WHERE T1.Titulo = Empleados.Titulo)
ORDER BY Titulo;
En el ejemplo anterior, la palabra reservada AS es opcional.

Otros ejemplos:
SELECT Apellidos, Nombre, Cargo, Salario

FROM Empleados
WHERE Cargo LIKE "Agente Ven*"
AND Salario > ALL (SELECT Salario
FROM Empleados
WHERE (Cargo LIKE "*Jefe*")
OR (Cargo LIKE "*Director*"));
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.
SELECT DISTINCT NombreProducto, Precio_Unidad

FROM Productos
WHERE (Precio_Unidad = (SELECT Precio_Unidad
FROM Productos
WHERE Nombre_Producto = "Almíbar anisado");
Obtiene una lista con el nombre y el precio unitario de todos los productos con el mismo precio
que el almíbar anisado.
SELECT DISTINCT Nombre_Contacto, Nombre_Compañia, Telefono

FROM Clientes
WHERE (ID_Cliente IN (SELECT DISTINCT ID_Cliente
FROM Pedidos
WHERE Fecha_Pedido >= #04/1/93# <#07/1/93#);
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.
SELECT Nombre, Apellidos

FROM Empleados AS E
WHERE EXISTS (SELECT *
FROM Pedidos AS O
WHERE O.ID_Empleado = E.ID_Empleado);
Selecciona el nombre de todos los empleados que han reservado al menos un pedido.
SELECT DISTINCT Pedidos.Id_Producto, Pedidos.Cantidad,

(SELECT DISTINCT Productos.Nombre
FROM Productos
WHERE Productos.Id_Producto = Pedidos.Id_Producto) AS ElProducto
FROM Pedidos
WHERE Pedidos.Cantidad > 150
ORDER BY Pedidos.Id_Producto;

Recupera el Código del Producto y la Cantidad pedida de la tabla pedidos, extrayendo el nombre
del producto de la tabla de productos.
SELECT NumVuelo, Plazas

FROM Vuelos
WHERE Origen = 'Madrid'
AND Exists (SELECT T1.NumVuelo
FROM Vuelos AS T1
WHERE T1.PlazasLibres > 0
AND T1.NumVuelo = Vuelos.NumVuelo)
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')
ó lo que sería lo mismo:
SELECT Empleados.Nombre
FROM Empleados
WHERE Sexo = 'M'
AND Edad > (SELECT Max( Empleados.Edad )
FROM Empleados
WHERE Sexo ='H')

La siguiente tabla muestra algún ejemplo del operador ANY y ALL

Valor 1 Operador Valor 2
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
El operador =ANY es equivalente al operador IN. Ambos devuelven el mismo resultado.

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
Opciones para reforzar la integridad de datos
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): Define restricciones a los valores aceptables y es lo más

recomendable para manejar la integridad de datos.
Desencadenadores (Triggers): procedimientos almacenados especiales que se disparan ante la

detección de eventos. Los eventos más comunes son INSERT, UPDATE y DELETE
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:

Una tabla sólo puede tener una restricción PRIMARY KEY.

Ninguna columna a la que se aplique una restricción PRIMARY KEY puede aceptar valores nulos.
Debido a que las restricciones PRIMARY KEY garantizan datos únicos, con frecuencia se definen en
una columna de identidad (Identity).
Si se define una restricción PRIMARY KEY para más de una columna, puede haber valores
duplicados dentro de la misma columna, pero cada combinación de valores de todas las columnas
de la definición de la restricción PRIMARY KEY debe ser única.
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])
Restricciones de integridad referencial en cascada
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:
NO ACTION: es el valor predeterminado si no se especifica ON DELETE u ON UPDATE. Si se intenta

eliminar o actualizar una fila con una clave a la que hacen referencia las claves externas de las filas
existentes en otras tablas, se produce un error y se revierte la instrucción DELETE o UPDATE.
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.
Guía para su Creación

Especificar el esquema de los objetos que se usan en el procedimiento almacenado. Esto asegura
que los objetos de otros esquemas sean accesibles desde el procedimiento. Si no se especifica el
esquema el procedimiento los buscará en el esquema predeterminado.
Diseñar cada procedimiento para cumplir con una sola tarea
Crear y probar el procedimiento en el servidor antes de usarlo desde el cliente
Se recomienda no crear procedimientos almacenados con el prefijo sp_. SQL Server utiliza el
prefijo sp_ para indicar procedimientos almacenados del sistema. El nombre que elija puede
entrar en conflicto con algún procedim iento futuro del sistema. Cuando se ejecuta un
procedimiento cuyo nombre comienza con este prefijo SQL Server busca primero en la base de
datos master y luego en la base de datos local.
Ventajas de los procedimientos almacenados
· Se registran en el servidor.
· Pueden incluir atributos de seguridad (como permisos) y cadenas de propiedad; además se les
pueden asociar certificados.
· Los usuarios pueden disponer de permiso para ejecutar un procedimiento almacenado sin
necesidad de contar con permisos directos en los objetos a los que se hace referencia en el
procedimiento.
· Mejoran la seguridad de la aplicación.
· Encapsulan lógica de aplicación, que puede ser compartida entre múltiples aplicaciones.
· Los procedimientos almacenados con parámetros pueden ayudar a proteger la aplicación ante
ataques por inyección de código SQL.
· Permiten una programación modular.

· 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.
CREATE { PROC | PROCEDURE } [Nombre_esquema.] Nombre_Procedimiento

[ { @parametro [ nombre_esquema. ] tipo_dato }
Argumentos
nombre_esquema: Es el nombre del esquema al que pertenece el procedimiento.
Nombre_Procedimiento: Es el nombre del prodecimiento. Los nombres de los procedimientos
almacenados deben cumplir las reglas de los ident ificadores. La especificación del nombre del
propietario opcional.
Es un parámetro del procedimiento. En una instrucción CREATE PROCEDURE se pueden declarar
uno o más parámetros. El usuario debe proporcionar el valor de cada parámetro declarado cuando
se llama al procedimiento, a menos que se haya definido un valor predeterminado para el
parámetro o se haya establecido en el mismo valor que otro parámetro. Un procedimiento
almacenado puede tener un máximo de 2.100 parámetros. Si un procedimiento contiene
parámetros con valores de tabla y el parámetro no está en la llamada, se pasa un valor
predeterminado de tabla vacía.
@parametros: Especifique un nombre de parámetro con un signo (@) como primer carácter. El
nombre del parámetro se debe ajustar a las regla s de los identificadores. Los parámetros son
locales para el procedimiento; los mismos nombres de parámetro se pueden utilizar en otros
procedimientos. De manera predeterminada, los parámetros sólo pueden ocupar el lugar de
expresiones constantes; no se pueden utilizar en lugar de nombres de tabla, nombres de columna
o nombres de otros objetos de base de datos. Para obtener más información, vea EXECUTE
(Transact-SQL).
[type_schema_name.]data_type: Es el tipo de datos del parámetro y el esquema al que
pertenece. Se pueden utilizar todos los tipos de datos como un parámetro de un procedimiento
almacenado Transact-SQL.

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.
Procedimientos Almacenados con Parámetros

Un procedimiento almacenado se comunica con el programa que lo llama mediante sus
parámetros. Cuando un programa ejecuta un procedimiento almacenado, es posible pasarle
valores mediante los parámetros del procedimiento. Estos valores se pueden utilizar como
variables estándar en el lenguaje de programación Transact -SQL. El procedimiento almacenado
también puede devolver valores al programa que lo llama mediante parámetros OUT PUT. Un
procedimiento almacenado puede tener hasta 2.100 parámetros, cada uno de ellos con un
nombre, un tipo de datos, una dirección y un valor predeterminado.
Manejo de parámetro

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:
EXECUTE miProcedimiento @Segundo = 2, @Primero = 1, @Tercero = 3

O bien por posición, sin asignarles ningún nombre:
EXECUTE miProcedimiento 1, 2, 3
Si se asigna un nombre a los parámetros cuando se ejecuta el procedimiento almacenado, es

posible especificarlos en cualquier orden. Si no se asigna ningún nombre a los parámetros, deben
especificarse en el mismo orden (de izquierda a derecha) en el que están definidos en el
procedimiento almacenado. Además, todos los parámetros que precedan a un parámetro
determinado deberán especificarse aunque sean opcionales y tengan valores predeterminados.
Por ejemplo, si todos los parámetros de miProcedimiento son opcionales, se podría ejecu tar
miProcedimiento mediante la especificación de los valores correspondientes a los dos primeros
parámetros, pero no a los del segundo y tercer parámetros solamente. Esto es necesario, ya que
en caso contrario, Microsoft SQL Server no puede identificar los parámetros que se especifican.
Dirección de los parámetros
La dirección de un parámetro puede ser de entrada, que indica que un valor se pasa al parámetro
de entrada de un procedimiento almacenado, o de salida, que indica que el procedimiento
almacenado devuelve un valor al programa que lo llama mediante un parámetro de salida. El valor
predeterminado es un parámetro de entrada. Un parámetros de salida se especifica con la
cláusula OUTPUT.
Valores Predeterminados
Puede crear un procedimiento almacenad o con parámetros opcionales especificando un valor
predeterminado para los mismos. Al ejecutar el procedimiento almacenado, se utilizará el valor
predeterminado si no se ha especificado ningún otro. Es necesario especificar valores
predeterminados, ya que el sistema devuelve un error si en el procedimiento almacenado no se
especifica un valor predeterminado para un parámetro y el programa que realiza la llamada no
proporciona ningún otro valor al ejecutar el procedimiento. Si no se puede especificar ningún valor
predeterminado para el parámetro, siempre se puede especificar NULL y dejar que el
procedimiento almacenado devuelva un mensaje personalizado en caso de ejecutarse sin que el
parámetro tenga un valor.
Parámetros de Entrada
Ejemplo:
ALTER PROCEDURE Production.LongLeadProducts
@MinimumLength int = 1

AS
IF (@MinimumLength < 0)
BEGIN
RAISERROR('Dato inválido', 14, 1)
RETURN
END
SELECT Name, ProductNumber, DaysToManufacture

FROM Production.Product
WHERE DaysToManufacture >= @MinimumLength ORDER BY DaysToManufacture DESC, Name
Ejecución: Por nombre:

EXEC Production.LongLeadProducts @MinimumLength=4
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'.
Guía para el control de errores

Cada construcción TRY…CATCH debe encontrarse en un solo lote, procedimiento
almacenado o desencadenador.
Un bloque CATCH debe seguir inmediatamente a un bloque TRY.
Las construcciones TRY…CATCH pueden estar an idadas. Esto significa que las
construcciones TRY…CATCH se pueden colocar dentro de otros bloques TRY y CATCH. Cuando se
produce un error dentro de un bloque TRY anidado, el control del programa se transfiere al bloque
CATCH que está asociado al bloque TRY anidado.

Para controlar un error que se produce en un bloque CATCH determinado, escriba un

bloque TRY…...CATCH en el bloque CATCH especificado.
El bloque TRY…CATCH no controlará los errores con una gravedad de 20 o superior que
hacen que el Motor de bas e de datos cierre la conexión. No obstante, TRY…CATCH controlará los
errores con una gravedad de 20 o superior siempre que la conexión no se cierre.
Los errores con un gravedad de 10 o inferior se consideran advertencias o mensajes
informativos, y los bloques TRY…CATCH no los controlan.
Transacciones no confirmables
En una construcción TRY…CATCH, las transacciones pueden pasar a un estado en el que la

transacción sigue abierta pero no se puede confirmar. La transacción no puede realizar ninguna
acción que genere una escritura en el registro de transacciones, como modificar datos o intentar
revertir a un punto de retorno. En este estado, sin embargo, los bloqueos adquiridos por la
transacción se mantienen y la conexión también sigue abierta. Los efectos d e la transacción no se
revierten hasta que se emite la instrucción ROLLBACK, o bien hasta que el lote termina y el Motor
de base de datos revierte automáticamente la transacción. Si no se ha enviado ningún mensaje de
error cuando la transacción pasó al est ado no confirmable, cuando el lote termina, se enviará un
mensaje de error a la aplicación cliente indicando que se ha detectado y revertido una transacción
no confirmable. Una transacción pasa a un estado no confirmable dentro de un bloque TRY
cuando se produce un error que, de lo contrario, habría terminado la transacción. Por ejemplo, la
mayoría de los errores procedentes de una instrucción de lenguaje de definición de datos (DDL)
como CREATE TABLE o la mayoría de los errores que se producen cuando SET XACT_ABORT está en
ON, terminan la transacción fuera de un bloque TRY, pero crean una transacción no confirmable
dentro de un bloque TRY.
El código de un bloque CATCH debe probar el estado de una transacción mediante la función
XACT_STATE. XACT_STATE devuelve -1 si la sesión tiene una transacción no confirmable. El bloque
CATCH no debe realizar acciones que generen escrituras en el registro cuando XACT_STATE
devuelve -1.

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.
Instrucciones válidas en una función

Las instrucciones DECLARE pueden utilizarse para definir variables y cursores de datos locales de la
función.
La asignación de valores a objetos locales de la función, como la utilización de SET para asignar
valores a variables locales escalares y de tabla.
Las operaciones de cursores que hacen referencia a c ursores locales que están declarados,
abiertos, cerrados y no asignados en la función. No se admiten las instrucciones FETCH que
devuelven datos al cliente. Sólo se permiten las instrucciones FETCH que asignan valores a
variables locales mediante la cláusula INTO.
Instrucciones de control de flujo excepto instrucciones TRY...CATCH.
Instrucciones SELECT que contienen listas de selección con expresiones que asignan valores a las
variables locales para la función.
Instrucciones UPDATE, INSERT y DELETE que modifican las variables de tabla locales de la función.
Instrucciones EXECUTE que llaman a un procedimiento almacenado extendido.

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.
Volver a escribir procedimientos almacenados como funciones

Si desea invocar un procedimiento almacenado directamente desde una consulta, reorganice el
código como si fuera una función definida por el usuario. En general, si el procedimiento
almacenado devuelve un solo conjunto de resultados, defina una función con valores de tabla. Si
el procedimiento almacenado calcula un valor escalar, defina una función escalar.
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.
Funciones Escalar (Scalar Function)

Las funciones escalares definidas por el usuario devuelven un único valor de datos del tipo
definido en la cláusula RETU RNS. Las funciones escalares insertadas no tienen cuerpo; el valor
escalar es el resultado de una sola instrucción. Para una función escalar de múltiples instrucciones,
el cuerpo de la función, definido en un bloque BEGIN...END, contiene una serie de instr ucciones
Transact-SQL que devuelven el valor único. El tipo devuelto puede ser de cualquier tipo de datos
excepto text, ntext, image, cursor y timestamp.
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
SELECT ProductID, Name, Sales.SumSold(ProductID) AS SumSold

FROM Production.Product
Funciones con Valores de Tabla en Línea (inline table-valued functions)

Las funciones con valores de tabla definidas por el usuario devuelven un tipo de datos table. Las
funciones con valores de tabla en línea no tienen cuerpo; la tabla es el conjunto de resultados de
una sola instrucción SELECT. Pueden utilizarse para obtener la funcionalidad de vistas con
parámetros, ya que las vista no manejan parámetros. Las funciones en línea definidas por el
usuario siguen las reglas siguientes:
La cláusula RETURNS sólo contiene la palabra clave table. No e s necesario definir el formato de
una variable de retorno, ya que se define mediante el formato del conjunto de resultados de la
instrucción SELECT en la cláusula RETURN.
El cuerpo de la función no está delimitada por BEGIN ni END.
La cláusula RETURN con tiene una sola instrucción SELECT entre paréntesis. El conjunto de
resultados de la instrucción SELECT forma la tabla devuelta por la función. La instrucción SELECT
utilizada en una función en línea está sujeta a las mismas restricciones que las instruccio nes
SELECT utilizadas en las vistas.
La función con valores de tabla sólo acepta constantes o argumentos @local_variable.
Ejemplo:
CREATE FUNCTION HumanResources.EmployeesForManager (@ManagerId int)
RETURNS TABLE
AS

RETURN (SELECT FirstName, LastName FROM HumanResources.Employee Employee

INNER JOIN Person.Contact Contact ON Employee.ContactID = Contact.ContactID
WHERE ManagerID = @ManagerId )
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.
En una función definida por el usuario con valores de tabla:

La cláusula RETURNS define el nombre de una variable de retorno local para la tabla devuelta por
la función. La cláusula RETURNS también define el formato de la tabla. El nombre de una variable
de retorno local tiene un ámbito local dentro de la función.
Las instrucciones Transact-SQL del cuerpo de la función generan e insertan filas en la variable de
retorno definida por la cláusula RETURNS.
Al ejecutar una instrucción RETURN, las filas insertadas en la variable se devuelven desde la
función en formato tabular. La instrucción RETURN no puede tener un argumento.
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')
Obtener información sobre funciones :

Vistas de catálogo:
· Sys_sql_modules: devuelve la lista de procedimientos, funciones, vistas y desencadenadores
de la base de datos.
· Sys_parameters: devuelve la definición de los parámetros de las funciones.
· Sys_Sql_Dependencies: permite verificar las dependencias del objeto.
· Etc.
Procedimiento almacenado:
· sp_HelpText permite ver la definición de una función
· sp_Help
· sp_depends permite verificar las dependencias del objeto.
· Etc.

Chrome-Extension Mhjfbmdgcfjbbpaeojofohoefgiehjai Index-Material

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Chrome-Extension Mhjfbmdgcfjbbpaeojofohoefgiehjai Index-Material

Încărcat de

Drepturi de autor:

Formate disponibile

Universidad Nacional del Nordeste

Facultad de Ciencias Exactas y Naturales y Agrimensura

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 1

OUTER JOIN LEFT..............................................................................................................29

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 2

1. Conceptos de Bases de Datos

Sistema de gestión de base de datos (SGBD)

Existen distintos objetivos que deben cumplir los SGBD:

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 3

Las ventajas de su uso son:

Las desventajas son:

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 4

Bases de Datos OLTP (On Line Transactional Processing)

Objetos de la base de datos

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 5

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 6

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 7

Componentes del SQL

Las sentencias de SQL se clasifican según su finalidad dando origen a 3 sublenguajes:

DROP Empleado para eliminar tablas e índices

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

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 8

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 9

Esquema es un espacio de nombres (namespace) distinto que existe de forma

Para modificar o borrar un esquema use las instrucciones ALTER/DROP SCHEMA.

- Al dar de baja un usuario no es necesario renombrar los objetos que le pertenecían.

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 10

usuario, si no lo encuentra intenta usando dbo. Para asignar un esquema predeterminado a un

ALTER USER Curso WITH DEFAULT_SCHEMA = Compras

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 11

Organización de los datos

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 12

3. Sentencia Básica del SQL – SELECT

Capacidades de la Sentencia SQL SELECT

Unión: la capacidad de unión permite recuperar datos

Casa Central 4020 Juan Perez 1000

Norte 2010 Jose Gomez 800

Centro 1050 María Gonzales 1500

Casa_Central 2070 Juana Dominguez 300

Sur 2040 Oscar Arce 900

Este 3020 Cristian Gimenez 2000

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 13

Norte 1010 Nicolas Prieto 3800

Centro 5050 Eduardo Gonzales 5100

Casa_Central 3070 Juan Coronel 3000

Sur 4040 Miguel Perez 2900

Oeste 6025 Rosa Gomez 6000

Se desea encontrar los clientes de la Casa Central

SELECT DISTINCT nombre_cliente_d

Sentencia SELECT Básica

SELECT [DISTINCT] {*,columna | expresión [alias],...}

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 14

Ejemplo 2: Visualizar el código de proveedor y de localidad de la tabla Proveedores

Nota: Las sentencias SQL

Permiten modificar la forma en que se muestra la información, realizando cálculos, mediante

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 15

Ejemplo: mostrar el apellido, el salario y la remuneración anual de los empleados. La

SELECT apellido, salario, 12*salario+100

Según el orden de prioridades visto, la multiplicación se realiza antes que la suma.

En primer lugar se realiza la suma, y el resultado se multiplica por 12.

Ejemplo: Listar apellido y nombre de los empleados, con la cabecera “Empleado”

Lenguaje de Consulta de Bases de Datos (SQL) - Curso 2016 16

Nota: en la salida obtenida, nombre y apellido no tendrán separación entre sí.