Sql

Sentencias SQL

Creamos la base de datos

CREATE DATABASE empresa

Creamos la tabla Personas

CREATE TABLE dbo.Personas

(
P_id int PRIMARY KEY IDENTITY,
Nombre nchar(20) NOT NULL,
Apellidos nchar(30) NOT NULL,
Direccion nchar(40) NOT NULL,
Ciudad nchar(10) NOT NULL
)
GO

Insertamos algunos registros:

INSERT INTO Personas

VALUES ('Marco Antonio','Trejo Lemus','Calle E 822','Tampico')
INSERT INTO Personas
VALUES ('Martha Beatriz','Trejo Lemus','Calle E 822','Tampico')
INSERT INTO Personas
VALUES ('Juana Elvira','Trejo Lemus','Calle E 822','Tampico')
INSERT INTO Personas
VALUES ('Nora Zulma','Trejo Lemus','Calle E 822','Tampico')
INSERT INTO Personas
VALUES ('Laura Lucero','Sobrevilla Trejo','Calle E 822','Tampico')
INSERT INTO Personas
VALUES ('Maria de la luz','Trejo Campos','Calle E 822','Tampico')
INSERT INTO Personas
VALUES ('Trinidad','Trejo Bautista','Calle E 822','Tampico')
INSERT INTO Personas
VALUES ('Marcel Abisag','Sobrevilla Trejo','Calle E 822','Tampico')
INSERT INTO Personas
VALUES ('Jose Abraham','Sobrevilla Trejo','Calle E 822','Tampico')
INSERT INTO Personas
VALUES ('Samuel Salomon','Olmeda Trejo','Calle E 822','Tampico')
Muchas de las acciones que necesitas realizar en una base de datos se hacen con sentencias SQL

Seleccionamos todos los registros de la tabla

Las siguiente sentencia seleccionara todos los registros de la tabla "Personas" :

SELECT * FROM Personas

Abajo esta un ejemplo del resultado de la sentencia a la tabla llamada "Personas":

Este tutorial te enseara acerca de las diferentes declaraciones en SQL

Manten en mente lo siguiente: las sentencias SQL no son sencibles a las mayusculas o minisculas

Punto y coma despues de las sentencias SQL

Algunos sistemas de bases de datos requieren un punto y coma al final de cada sentencia SQL

El punto y como es un estandar que se para cada sentencia SQL en sistemas de bases de datos que
habilitan mas de una sentencia SQL ejecutada en la misma llamada al servidor

SQL DML Y DLL

SQL puede ser dividido en dos partes: El Lenguaje de Manipulacion de Datos (DML) y el Lenguaje
de Definicion de Datos (DDL)

La parte DML del SQL de los comandos de consulta y actualizacion son:

SELECT - extrae datos de una base de datos

UPDATE - actualiza datos en una base de datos
DELETE - borra datos de una base de datos
INSERT INTO - inserta datos dentro de una base de datos
DLL del SQL que permite a bases de datos y tablas ser creadas o borradas.
Tambien define indices(llaves). especifica enlaces entre tablas, y impone relaciones entre tablas.

La parte DLL del SQL, las sentencias mas importante DDL en SQL son:

CREATE DATABASE - crea una nueva base de datos

ALTER DATABASE - modifica una base de datos
CREATE TABLE - crea una nueva tabla
ALTER TABLE - modifica una tabla
DROP TABLE - borra una tabla
CREATE INDEX - crea un indice (llave de busqueda)
DROP INDEX - borra un indice

La sentencia SELECT

La sentencia SELECT es usada para seleccionar datos de una base de datos.

El resultado es almacenado en una tabla temporal, llamada tabla-resultado

La sintaxis SQL de la sentencia SELECT es:

1) SELECT nombre_columna(s)
FROM nombre_tabla

2) SELECT * FROM nombre_tabla

Ejemplo 1

SELECT nombre_columna(s)
FROM nombre_tabla

SELECT Nombre,Apellidos,Ciudad
FROM Personas
Ejemplo 2

SELECT * FROM nombre_tabla

SELECT * FROM nombre_tabla

Navegacion en una tabla de resultados

Muchos sistemas de bases de datos permiten la navegacion en la tabla de resultados

programando funciones como: Moverse-Al-Primero, Obtener-Contenido-Registro, Moverse-Al-
Siguiente-Registro, etc.

Funciones de programacion como estas no son parte de este tutorial. Para aprender a accesar a
datos con la llamada a funciones espera mi siguiente tutorial ADO y PHP.
La sentencia SELECT DISTINCT

Dentro de una tabla, algunas columnas pueden contener valores duplicados. Esto no es un
problema, algunas veces tu querras listar solo los valores diferentes (distintos) en la tabla

La palabra DISTINCT puede ser usada como llave para regresar solo los valores
distintos(diferentes).

Sintaxis SQL SELECT DISTINCT

SELECT DISTINCT nombre_columna(s)

FROM nombre_table

Ejemplo:

SELECT DISTINCT Apellidos

FROM Personas

Abajo esta el resultado de la sentencia DISTINCT a la tabla "Personas":

SELECT DISTINCT Ciudad FROM Personas

Abajo esta el resultado de la sentencia DISTINCT a la tabla "Personas":

SQL WHERE

La sentencia where es usada para extraer solo los registros que cumplen con el criterio especificad

La Sintaxis SQL WHERE

SELECT nombre_columna(s)
FROM nombre_tabla
WHERE nombre_columna operador valor

Ejemplo de la sentecia WHERE

SELECT *
FROM Personas
WHERE Apellidos ='Trejo Lemus'

Comillas en los campos de texto

SQL usa comillas simples en los valores de texto (muchos sitemas manejadores de bases de datos
aceptan comillas dobles).Para SQL los valores de texto deben ser puestos entre comillas simples

Los valores numericos no deben ser puestos entre comillas

Para valores de texto:

Esta es la forma correcta:

SELECT *
FROM Personas
WHERE Nombre='Lucero'

Esta es la forma equivocada:

SELECT *
FROM Personas
WHERE Nombre=Lucero

Para valores numericos:

Esta es la forma correcta:

SELECT *
FROM Personas
WHERE P_id = 9
Esta es la forma incorrecta:

SELECT *
FROM Personas
WHERE P_id = '9'

Operadores permitidos en la sentencia WHERE

Con la sentencia WHERE, los siguientes operadores pueden ser usados:

Operadores SQL AND y OR

Los operadores AND y OR son usados para filtrar registros basados en mas de una condicion

Operador AND
El operador AND muestra el registro si la primera condicion y la segunda condicion son verdaderas

El operador OR muestra el registro si la primera o la segunda condicion es verdadera

Ahora teniendo en cuenta la siguiente tabla:

Para seleccionar solo las personas con el Nombre igual a Marcel Abisag y el apellido igual a
Sobrevilla Trejo,

Usaremos la siguiente sentencia SELECT:

SELECT * FROM Personas

WHERE Nombre='Marcel Abisag'
AND Apellidos='Sobrevilla Trejo'

El resultado seria:

Operador OR

Ahora seleccionaremos las personas con el campo Nombre igual a "Martha" o el campo Nombre
igual a "Elvira"

Usaremos la siguiente sentencia SELECT

SELECT * FROM Personas

WHERE Nombre='Martha Beatriz'
OR Nombre='Juana Elvira'

El resultado sera el siguiente:

Combinando AND & OR

Puedes combinar el AND y el OR (usando parentesis para formar expresiones complejas)

Ahora seleccionaremos solo las personas con el campo Apellidos igual a "Sobrevilla Trejo" AND
Nombre igual a "Marcel Abisag" OR igual a "Jose Abraham"

Usaremos la siguiente sentencia SELECT:

SELECT * FROM Personas WHERE

Apellidos='Sobrevilla Trejo'
AND (Nombre='Marcel Abisag' OR Nombre='Jose Abraham')

El resultado sera el siguiente:

SQL ORDER BY

The ORDER BY keyword is used to sort the result-set.

La sentencia ORDER BY es usada para ordenar un resultado ordenado por una columna especifica

La sentencia ORDER BY es usada para ordenar los registros en orden ascendente por default

Si quieres ordenar los registros en orden descendente utiliza la palabra DESC

Sintaxis SQL ORDER BY

SELECT nombre_columna(s)
FROM nombre_tabla
ORDER BY nombre_column(s) ASCDESC

Ahora vamos a seleccionar todas las personas de la tabla, pero mostrando en orden por el campo
Nombre

Usaremos la siguiente sentencia SELECT:

SELECT * FROM Personas

ORDER BY Nombre

El resultado sera el siguiente:

ORDER BY DESC

Ahora vamos a seleccionar a todas las personas de la tabla pero mostrandolas en un orden
descendente por el campo Nombre con la palabra DESC

We use the following SELECT statement:

SELECT * FROM Personas

ORDER BY Nombre DESC

El resultado sera el siguiente:

Sentencia SQL INSERT INTO

La sentencia INSERT INTO se usa para insertar un registro o fila en una tabla

Sintaxis SQL INSERT INTO

Es posible escribir la sentencia INSET INTO en dos formas

La primera forma no especifica los nombres de las columnas donde los datos seran insertados solo
los valores:

INSERT INTO nombre_tabla

VALUES (valor1, valor2, valor3,...)

La segunda forma especifica los nombres de las columnas y los valores insertados

INSERT INTO nombre_tabla (columna1, columna2, columna3,...)

VALUES (valor1, valor2, valor3,...)

Ejemplo INSERT INTO

Dado que tenemos la siguiente tabla Personas:

Insertaremos un nuevo registro de la siguiente forma:

INSERT INTO Personas

VALUES ('Martha', 'Lemus Hurtado', 'Canoga Park', 'L.A.')

El resultado lo mostrariamos con la sentencia SELECT * FROM Personas y seria el siguiente:

Insertar Datos solo en columnas especificadas

Es posible agregar datos en columnas especificas
Las siguientes sentencias SQL agregaran una nueva fila, pero solo agregaran datos en las columnas
Nombre y Apellidos

INSERT INTO Personas (Nombre, Apellidos)

VALUES ('Antonio', 'Trejo Campos')

Para mostrar el resultado con la sentencia: SELECT * FROM Personas

Mostrara lo siguiente:
Sentencia SQL UPDATE Statement

La sentencia UPDATE es usada para actualizar registros en una tabla

Sintaxis SQL UPDATE

UPDATE nombre_tabla
SET columna1=valor, column2=valor,...
WHERE alguna_columna=algun_valor

Nota: La sentencia WEHRE en la sintaxis UPDATE, especifica cual de los registros va a ser
actualizado. Si omites la sentencia WHERE todos los registros seran actualizados.

Ahora vamos a actualizar la persona "Antonio Trejo Campos" en la tabla Personas

Usaremos la siguientes sentencias SQL:

UPDATE Personas
SET Direccion='Canoga Park', Ciudad='L.A.'
WHERE Nombre='Antonio' AND Apellido='Trejo Campos'

El resultado sera el siguiente:

CUIDADO!!! al utilizar la sentencia UPDATE

Si omites la sentencia WHERE se actualizaran todos los registros de esta forma:

UPDATE Personas
SET Direccion='Canoga Park', Ciudad='L.A.'

El resultado seria:

Sentencia SQL DELETE

La sentencia DELETE se usa para borrar registros o filas en una tabla

Sintaxis SQL DELETE

DELETE FROM nombre_tabla

WHERE alguna_columna=algun_valor

Nota: La sentencia WHERE en la sintaxis DELETE especifica el registro o los registros que seran
borrados, si omites la sentencia WHERE, todos los registros seran borrados de la tabla
Ahora vamos a borrar la persona "Marco Antonio Trejo Lemus" en la tabla Personas con la
siguiente sentencia:

DELETE FROM Personas

WHERE Nombre='Marco Antonio' AND Apellidos='Trejo Lemus'
SELECT * FROM Personas

El resultado sera el siguiente:

Borrar todas las filas

Es posible borrar todas las filas en una table sin borrar la tabla en si. Esto significa que la estructura
de la tabla, atributos e indices quedaran intactos:

DELETE FROM nombre_tabla

or

DELETE * FROM nombre_tabla

Nota: Debes tener cuidado cuando borres registros. Ya que no podras deshacer lo que hagas con
esta sentencia.

APENDICE 1
El siguiente codigo creara la base de datos en el servidor SQL EXPRESS
1.- Hacer clic en Inicio --> Todos los Programas --> Microsoft SQL SERVER 2008 -->
SQL Server Management Studio

2.- Hacer clic en el boton CONECTAR

3.- Hacer clic Nueva Consulta (se encuentra en el margen superior izquierdo)

Seleccionar y Copiar el siguiente "CODIGO GENERADOR

DE BASE DE DATOS" empresa:
______________________________________________________

USE master
if exists (select * from sysdatabases where name='empresa')
begin
raiserror('La base de datos existe; eliminndola....',0,1)
DROP database empresa
end
GO
raiserror('Creando base de datos empresa....',0,1)
go
CREATE DATABASE empresa
GO
USE empresa
GO
CREATE TABLE Personas(
P_id int PRIMARY KEY IDENTITY,
Nombre nchar(20) NOT NULL,
Apellidos nchar(30) NOT NULL,
Direccion nchar(40) NOT NULL,
Ciudad nchar(10) NOT NULL)
GO
GO
INSERT INTO Personas VALUES ('Marco Antonio','Trejo Lemus','Calle E
822','Tampico')INSERT INTO Personas VALUES ('Martha Beatriz','Trejo Lemus','Calle E
822','Tampico')INSERT INTO Personas VALUES ('Juana Elvira','Trejo Lemus','Calle E
822','Tampico')
INSERT INTO Personas VALUES ('Nora Zulma','Trejo Lemus','Calle E 822','Tampico')
INSERT INTO Personas VALUES ('Laura Lucero','Sobrevilla Trejo','Calle E
822','Tampico')INSERT INTO Personas VALUES ('Maria de la luz','Trejo Campos','Calle
E 822','Tampico')INSERT INTO Personas VALUES ('Trinidad','Trejo Bautista','Calle E
822','Tampico')
INSERT INTO Personas VALUES ('Marcel Abisag','Sobrevilla Trejo','Calle E
822','Tampico')INSERT INTO Personas VALUES ('Jose Abraham','Sobrevilla Trejo','Calle
E 822','Tampico')INSERT INTO Personas VALUES ('Samuel Salomon','Olmeda
Trejo','Calle E 822','Tampico')
GO
select * from Personas
quit

______________________________________________________

4.- Pegar el codigo

5.- Ejecutar el codigo SQL haciendo clic sobre la opcion !Ejecutar que se muestra a
continuacion:

Publicado por Marco Antonio Trejo Lemus en 19:18 1 comentario:

lunes, 18 de mayo de 2009

AVANZADO
Clausula SQL TOP

La clausula TOP se usa para especificar el numer de registros que existen

puede verificar la longitud de las tablas con miles de registros, regresando el numero de registros

Nota: No todas las bases de datos soportan la clausula TOP

Sintaxis SQL Server

SELECT TOP numeroporciento nombre_columna(s)
FROM nombre_tabla

Ahora seleccionaremos solo los dos primeros registros de la tabla que se muestra abajo:

Utilizaremos las siguientes sentencias SELECT:

SELECT TOP 2 * FROM Personas

El resultado sera el siguiente:

Sentencia SQL TOP PERCENT

Ahora seleccionaremos solo el 50% de los registros en la tabla

Usaremos las siguientes sentencias SELECT:

SELECT TOP 50 PERCENT * FROM Personas

El resultado se muestra abajo en la tabla:

Operador SQL LIKE

Operador SQL LIKE

El operador LIKE se usa en una sentencia WHERE para buscar un patron en una columna

Sintaxis LIKE
SELECT nombre_columna(s)
FROM nombre_tabla
WHERE nombre_columna LIKE patron

Ejemplo de operador LIKE

En la tabla "Personas" :

Vamos a buscar las personas que viven en la ciudad de Tampico que empiecen con "Ta" de la tabla
en cuestion

Usaremos la siguiente sentencia SELECT:

SELECT * FROM Personas

WHERE Ciudad LIKE 'Ta%'

El signo "%" puede ser usado para definir comodines (letras que faltan en el patron de busqueda)
ambas antes o despues del patron de busqueda

El resultado seria el siguiente:

Ahora vamos a seleccionar las personas que viven en la ciudad que comienza con una "T" de la
tabla personas

Usaremos la siguiente sentencia SELECT:

SELECT * FROM Personas

WHERE Ciudad LIKE '%T'

El resultado seria el siguiente:

Ahora vamos a seleccionar las personas que viven en la ciudad que contiene el patron "tam" de la
tabla personas

Usaremos la siguiente sentencia SELECT:

SELECT * FROM Personas
WHERE Ciudad LIKE '%tam%'

El resultado seria el siguiente:

Tambien es posible seleccionar las personas que viven en la ciudad que no contienen el patron
"tamp" de la tabla personas, usando la palabra clave NOT

Usaremos la siguiente sentencia SELECT:

SELECT * FROM Personas

WHERE Ciudad NOT LIKE '%tamp%'

El resultado seria el siguiente:

Comodines SQL

Los comodines SQL pueden ser usados en la busqueda de datos en una base de datos
pueden sustituir a uno o mas caracteres cuando se busquen los datos

Los comodines deben usarse con el operador LIKE

Se pueden usar con SQL los siguientes comodines:

Usando el comodn %
Ahora seleccionaremos las personas que viven en la ciudad de Tampico que empiecen con "Ta" de
la tabla Personas

Usaremos la siguiente sentencia SELECT:

SELECT * FROM Personas

WHERE Ciudad LIKE 'Ta%'
Ahora buscaremos las personas que viven en la ciudad que contenga el patron "ico" de la tabla
Personas

Usaremos la siguiente sentencia SELECT:

SELECT * FROM Personas

WHERE Ciudad LIKE '%ico%'

Usando el _ Comodn

Ahora selectionaremos las personas que el primer nombre comience con algun caracter
seguido de "Ma" de la tabla Personas

Usaremos la siguiente sentencia SELECT:

SELECT * FROM Personas
WHERE Nombre LIKE '_ar'

Ejemplos de SELECT (Transact-SQL)

SQL Server 2014
Otras versiones

En este tema se proporcionan ejemplos del uso de la instruccin SELECT.

A.Usar SELECT para recuperar filas y columnas

En el siguiente ejemplo se muestran tres fragmentos de cdigo. En el primer ejemplo de
cdigo, se devuelven todas las filas (no se especifica la clusula WHERE) y todas las
columnas (con *) de la tabla Product de la base de datos AdventureWorks2012 .

Transact-SQL
USE AdventureWorks2012;
GO
SELECT *
FROM Production.Product
ORDER BY Name ASC;
-- Alternate way.
USE AdventureWorks2012;
GO
SELECT p.*
FROM Production.Product AS p
ORDER BY Name ASC;
GO

En este ejemplo se devuelven todas las filas (no se ha especificado la clusula WHERE) y
solo un subconjunto de las columnas (Name, ProductNumber, ListPrice) de la tabla Product
de la base de datos AdventureWorks2012 . Adems, se agrega un encabezado de columna.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT Name, ProductNumber, ListPrice AS Price
FROM Production.Product
ORDER BY Name ASC;
GO

En este ejemplo solo se devuelven las filas de Product que tienen una lnea de productos de
R y cuyo valor correspondiente a los das para fabricar es inferior a 4.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT Name, ProductNumber, ListPrice AS Price
FROM Production.Product
WHERE ProductLine = 'R'
AND DaysToManufacture < 4
ORDER BY Name ASC;
GO

B.Usar SELECT con encabezados de columna y clculos

En los siguientes ejemplos se devuelven todas las filas de la tabla Product. En el primer
ejemplo se devuelven las ventas totales y los descuentos de cada producto. En el segundo
ejemplo se calculan los beneficios totales de cada producto.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT p.Name AS ProductName,
NonDiscountSales = (OrderQty * UnitPrice),
Discounts = ((OrderQty * UnitPrice) * UnitPriceDiscount)
FROM Production.Product AS p
INNER JOIN Sales.SalesOrderDetail AS sod
ON p.ProductID = sod.ProductID
ORDER BY ProductName DESC;
GO

sta es la consulta que calcula el beneficio de cada producto de cada pedido de venta.
Transact-SQL
USE AdventureWorks2012;
GO
SELECT 'Total income is', ((OrderQty * UnitPrice) * (1.0 -
UnitPriceDiscount)), ' for ',
p.Name AS ProductName
FROM Production.Product AS p
INNER JOIN Sales.SalesOrderDetail AS sod
ON p.ProductID = sod.ProductID
ORDER BY ProductName ASC;
GO

C.Usar DISTINCT con SELECT

En el siguiente ejemplo se utiliza DISTINCT para evitar la recuperacin de ttulos
duplicados.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT DISTINCT JobTitle
FROM HumanResources.Employee
ORDER BY JobTitle;
GO

D.Crear tablas con SELECT INTO

En el primer ejemplo se crea una tabla temporal denominada #Bicycles en tempdb.

Transact-SQL
USE tempdb;
GO
IF OBJECT_ID (N'#Bicycles',N'U') IS NOT NULL
DROP TABLE #Bicycles;
GO
SELECT *
INTO #Bicycles
FROM AdventureWorks2012.Production.Product
WHERE ProductNumber LIKE 'BK%';
GO

En el segundo ejemplo se crea la tabla permanente NewProducts.

Transact-SQL
USE AdventureWorks2012;
GO
IF OBJECT_ID('dbo.NewProducts', 'U') IS NOT NULL
DROP TABLE dbo.NewProducts;
GO
ALTER DATABASE AdventureWorks2012 SET RECOVERY BULK_LOGGED;
GO
SELECT * INTO dbo.NewProducts
FROM Production.Product
WHERE ListPrice > $25
AND ListPrice < $100;
GO
ALTER DATABASE AdventureWorks2012 SET RECOVERY FULL;
GO

E.Usar subconsultas correlacionadas

En el siguiente ejemplo se muestran consultas que son semnticamente equivalentes y se
demuestra la diferencia entre la utilizacin de la palabra clave EXISTS y la palabra clave
IN. Ambos son ejemplos de subconsultas vlidas que recuperan una instancia de cada
nombre de producto cuyo modelo es un jersey de manga larga con logotipo y cuyos
nmeros de ProductModelID coinciden en las tablas Product y ProductModel.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT DISTINCT Name
FROM Production.Product AS p
WHERE EXISTS
(SELECT *
FROM Production.ProductModel AS pm
WHERE p.ProductModelID = pm.ProductModelID
AND pm.Name LIKE 'Long-Sleeve Logo Jersey%');
GO

-- OR

USE AdventureWorks2012;
GO
SELECT DISTINCT Name
FROM Production.Product
WHERE ProductModelID IN
(SELECT ProductModelID
FROM Production.ProductModel
WHERE Name LIKE 'Long-Sleeve Logo Jersey%');
GO

En el siguiente ejemplo se utiliza IN en una subconsulta correlativa o repetitiva. Se trata de

una consulta que depende de la consulta externa de sus valores. Se ejecuta varias veces, una
vez por cada fila que pueda seleccionar la consulta externa. Esta consulta recupera una
instancia del nombre y apellido de cada empleado cuya bonificacin en la tabla SalesPerson
sea de 5000.00 y cuyos nmeros de identificacin coincidan en las tablas Employee y
SalesPerson.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT DISTINCT p.LastName, p.FirstName
FROM Person.Person AS p
JOIN HumanResources.Employee AS e
ON e.BusinessEntityID = p.BusinessEntityID WHERE 5000.00 IN
(SELECT Bonus
FROM Sales.SalesPerson AS sp
WHERE e.BusinessEntityID = sp.BusinessEntityID);
GO

La subconsulta anterior de esta instruccin no se puede evaluar independientemente de la

consulta externa. Necesita el valor Employee.EmployeeID, aunque este valor cambia a
medida que el Motor de base de datos de SQL Server examina diferentes filas de
Employee.

Una subconsulta correlativa se puede usar tambin en la clusula HAVING de una consulta
externa. En este ejemplo se buscan los modelos cuyo precio mximo es superior al doble de
la media del modelo.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT p1.ProductModelID
FROM Production.Product AS p1
GROUP BY p1.ProductModelID
HAVING MAX(p1.ListPrice) >= ALL
(SELECT AVG(p2.ListPrice)
FROM Production.Product AS p2
WHERE p1.ProductModelID = p2.ProductModelID);
GO

En este ejemplo se utilizan dos subconsultas correlativas para buscar los nombres de los
empleados que han vendido un producto especfico.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT DISTINCT pp.LastName, pp.FirstName
FROM Person.Person pp JOIN HumanResources.Employee e
ON e.BusinessEntityID = pp.BusinessEntityID WHERE pp.BusinessEntityID IN
(SELECT SalesPersonID
FROM Sales.SalesOrderHeader
WHERE SalesOrderID IN
(SELECT SalesOrderID
FROM Sales.SalesOrderDetail
WHERE ProductID IN
(SELECT ProductID
FROM Production.Product p
WHERE ProductNumber = 'BK-M68B-42')));
GO

F.Usar GROUP BY
En este ejemplo se busca el total de cada pedido de venta de la base de datos.
Transact-SQL
USE AdventureWorks2012;
GO
SELECT SalesOrderID, SUM(LineTotal) AS SubTotal
FROM Sales.SalesOrderDetail
GROUP BY SalesOrderID
ORDER BY SalesOrderID;
GO

Debido a la clusula GROUP BY, solo se devuelve una fila que contiene la suma de todas
las ventas por cada pedido de venta.

G.Usar GROUP BY con varios grupos

En este ejemplo se busca el precio medio y la suma de las ventas anuales hasta la fecha,
agrupados por Id. de producto e Id. de oferta especial.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT ProductID, SpecialOfferID, AVG(UnitPrice) AS [Average Price],
SUM(LineTotal) AS SubTotal
FROM Sales.SalesOrderDetail
GROUP BY ProductID, SpecialOfferID
ORDER BY ProductID;
GO

H.Usar GROUP BY y WHERE

En el siguiente ejemplo se colocan los resultados en grupos despus de recuperar
nicamente las filas con precios superiores a $1000.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT ProductModelID, AVG(ListPrice) AS [Average List Price]
FROM Production.Product
WHERE ListPrice > $1000
GROUP BY ProductModelID
ORDER BY ProductModelID;
GO

I.Usar GROUP BY con una expresin

En este ejemplo se agrupa por una expresin. Puede agrupar por una expresin si sta no
incluye funciones de agregado.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT AVG(OrderQty) AS [Average Quantity],
NonDiscountSales = (OrderQty * UnitPrice)
FROM Sales.SalesOrderDetail
GROUP BY (OrderQty * UnitPrice)
ORDER BY (OrderQty * UnitPrice) DESC;
GO

J.Usar GROUP BY con ORDER BY

En este ejemplo se busca el precio medio de cada tipo de producto y se ordenan los
resultados por precio medio.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT ProductID, AVG(UnitPrice) AS [Average Price]
FROM Sales.SalesOrderDetail
WHERE OrderQty > 10
GROUP BY ProductID
ORDER BY AVG(UnitPrice);
GO

K.Usar la clusula HAVING

En el primer ejemplo se muestra una clusula HAVING con una funcin de agregado.
Agrupa las filas de la tabla SalesOrderDetail por Id. de producto y elimina aquellos
productos cuyas cantidades de pedido medias son cinco o menos. En el segundo ejemplo se
muestra una clusula HAVING sin funciones de agregado.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT ProductID
FROM Sales.SalesOrderDetail
GROUP BY ProductID
HAVING AVG(OrderQty) > 5
ORDER BY ProductID;
GO

En esta consulta se utiliza la clusula LIKE en la clusula HAVING.

USE AdventureWorks2012 ;
GO
SELECT SalesOrderID, CarrierTrackingNumber
FROM Sales.SalesOrderDetail
GROUP BY SalesOrderID, CarrierTrackingNumber
HAVING CarrierTrackingNumber LIKE '4BD%'
ORDER BY SalesOrderID ;
GO
L.Usar HAVING y GROUP BY
En el siguiente ejemplo se muestra el uso de las clusulas GROUP BY, HAVING, WHERE
y ORDER BY en una instruccin SELECT. Genera grupos y valores de resumen pero lo
hace tras eliminar los productos cuyos precios superan los 25 $ y cuyas cantidades de
pedido medias son inferiores a 5. Tambin organiza los resultados por ProductID.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT ProductID
FROM Sales.SalesOrderDetail
WHERE UnitPrice < 25.00
GROUP BY ProductID
HAVING AVG(OrderQty) > 5
ORDER BY ProductID;
GO

M.Usar HAVING con SUM y AVG

En el siguiente ejemplo se agrupa la tabla SalesOrderDetail por Id. de producto y solo se
incluyen aquellos grupos de productos cuyos pedidos suman ms de $1000000.00 y cuyas
cantidades de pedido medias son inferiores a 3.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT ProductID, AVG(OrderQty) AS AverageQuantity, SUM(LineTotal) AS
Total
FROM Sales.SalesOrderDetail
GROUP BY ProductID
HAVING SUM(LineTotal) > $1000000.00
AND AVG(OrderQty) < 3;
GO

Para ver los productos cuyas ventas totales son superiores a $2000000.00, utilice esta
consulta:

Transact-SQL
USE AdventureWorks2012;
GO
SELECT ProductID, Total = SUM(LineTotal)
FROM Sales.SalesOrderDetail
GROUP BY ProductID
HAVING SUM(LineTotal) > $2000000.00;
GO

Si desea asegurarse de que hay al menos mil quinientos elementos para los clculos de cada
producto, use HAVING COUNT(*) > 1500 para eliminar los productos que devuelven
totales inferiores a 1500 elementos vendidos. La consulta sera la siguiente:
Transact-SQL
USE AdventureWorks2012;
GO
SELECT ProductID, SUM(LineTotal) AS Total
FROM Sales.SalesOrderDetail
GROUP BY ProductID
HAVING COUNT(*) > 1500;
GO

N.Usar la sugerencia del optimizador INDEX

En el ejemplo siguiente se muestran dos formas de usar la sugerencia del optimizador
INDEX. En el primer ejemplo se muestra cmo obligar al optimizador a que use un ndice
no clster para recuperar filas de una tabla, mientras que en el segundo ejemplo se obliga a
realizar un recorrido de tabla mediante un ndice igual a 0.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT pp.FirstName, pp.LastName, e.NationalIDNumber
FROM HumanResources.Employee AS e WITH
(INDEX(AK_Employee_NationalIDNumber))
JOIN Person.Person AS pp on e.BusinessEntityID = pp.BusinessEntityID
WHERE LastName = 'Johnson';
GO

-- Force a table scan by using INDEX = 0.

USE AdventureWorks2012;
GO
SELECT pp.LastName, pp.FirstName, e.JobTitle
FROM HumanResources.Employee AS e WITH (INDEX = 0) JOIN Person.Person AS
pp
ON e.BusinessEntityID = pp.BusinessEntityID
WHERE LastName = 'Johnson';
GO

M.Usar OPTION y las sugerencias GROUP

En el ejemplo siguiente se muestra cmo se usa la clusula OPTION (GROUP) con una
clusula GROUP BY.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT ProductID, OrderQty, SUM(LineTotal) AS Total
FROM Sales.SalesOrderDetail
WHERE UnitPrice < $5.00
GROUP BY ProductID, OrderQty
ORDER BY ProductID, OrderQty
OPTION (HASH GROUP, FAST 10);
GO
O.Usar la sugerencia de consulta UNION
En el ejemplo siguiente se usa la sugerencia de consulta MERGE UNION.

Transact-SQL
USE AdventureWorks2012;
GO
SELECT BusinessEntityID, JobTitle, HireDate, VacationHours,
SickLeaveHours
FROM HumanResources.Employee AS e1
UNION
SELECT BusinessEntityID, JobTitle, HireDate, VacationHours,
SickLeaveHours
FROM HumanResources.Employee AS e2
OPTION (MERGE UNION);
GO

P.Usar una instruccin UNION simple

En el ejemplo siguiente, el conjunto de resultados incluye el contenido de las columnas
ProductModelID y Name de las tablas ProductModel y Gloves.

Transact-SQL
USE AdventureWorks2012;
GO
IF OBJECT_ID ('dbo.Gloves', 'U') IS NOT NULL
DROP TABLE dbo.Gloves;
GO
-- Create Gloves table.
SELECT ProductModelID, Name
INTO dbo.Gloves
FROM Production.ProductModel
WHERE ProductModelID IN (3, 4);
GO

-- Here is the simple union.

USE AdventureWorks2012;
GO
SELECT ProductModelID, Name
FROM Production.ProductModel
WHERE ProductModelID NOT IN (3, 4)
UNION
SELECT ProductModelID, Name
FROM dbo.Gloves
ORDER BY Name;
GO

Q.Usar SELECT INTO con UNION

En el ejemplo siguiente, la clusula INTO de la segunda instruccin SELECT especifica
que la tabla denominada ProductResults contiene el conjunto final de resultados de la unin
de las columnas designadas de las tablas ProductModel y Gloves. Tenga en cuenta que la
tabla Gloves se crea en la primera instruccin SELECT.

Transact-SQL
USE AdventureWorks2012;
GO
IF OBJECT_ID ('dbo.ProductResults', 'U') IS NOT NULL
DROP TABLE dbo.ProductResults;
GO
IF OBJECT_ID ('dbo.Gloves', 'U') IS NOT NULL
DROP TABLE dbo.Gloves;
GO
-- Create Gloves table.
SELECT ProductModelID, Name
INTO dbo.Gloves
FROM Production.ProductModel
WHERE ProductModelID IN (3, 4);
GO

USE AdventureWorks2012;
GO
SELECT ProductModelID, Name
INTO dbo.ProductResults
FROM Production.ProductModel
WHERE ProductModelID NOT IN (3, 4)
UNION
SELECT ProductModelID, Name
FROM dbo.Gloves;
GO

SELECT ProductModelID, Name

FROM dbo.ProductResults;

R.Usar UNION con dos instrucciones SELECT y

ORDER BY
El orden de algunos parmetros empleados con la clusula UNION es importante. En el
ejemplo siguiente se muestra el uso correcto e incorrecto de UNION en dos instrucciones
SELECT en las que se va a cambiar el nombre de una columna en el resultado.

Transact-SQL
USE AdventureWorks2012;
GO
IF OBJECT_ID ('dbo.Gloves', 'U') IS NOT NULL
DROP TABLE dbo.Gloves;
GO
-- Create Gloves table.
SELECT ProductModelID, Name
INTO dbo.Gloves
FROM Production.ProductModel
WHERE ProductModelID IN (3, 4);
GO
/* INCORRECT */
USE AdventureWorks2012;
GO
SELECT ProductModelID, Name
FROM Production.ProductModel
WHERE ProductModelID NOT IN (3, 4)
ORDER BY Name
UNION
SELECT ProductModelID, Name
FROM dbo.Gloves;
GO

/* CORRECT */
USE AdventureWorks2012;
GO
SELECT ProductModelID, Name
FROM Production.ProductModel
WHERE ProductModelID NOT IN (3, 4)
UNION
SELECT ProductModelID, Name
FROM dbo.Gloves
ORDER BY Name;
GO

S.Usar UNION de tres instrucciones SELECT para

mostrar los efectos de ALL y los parntesis
En los siguientes ejemplos se utiliza UNION para combinar los resultados de tres tablas que
tienen las mismas 5 filas de datos. En el primer ejemplo se utiliza UNION ALL para
mostrar los registros duplicados y se devuelven las 15 filas. En el segundo ejemplo se
utiliza UNION sin ALL para eliminar las filas duplicadas de los resultados combinados de
las tres instrucciones SELECT y se devuelven 5 filas.

En el tercer ejemplo se utiliza ALL con el primer UNION y los parntesis incluyen al
segundo UNION que no utiliza ALL. El segundo UNION se procesa en primer lugar
porque se encuentra entre parntesis. Devuelve 5 filas porque no se utiliza la opcin ALL y
se quitan los duplicados. Estas 5 filas se combinan con los resultados del primer SELECT
mediante las palabras clave UNION ALL. Esto no quita los duplicados entre los dos
conjuntos de 5 filas. El resultado final es de 10 filas.

Transact-SQL
USE AdventureWorks2012;
GO
IF OBJECT_ID ('dbo.EmployeeOne', 'U') IS NOT NULL
DROP TABLE dbo.EmployeeOne;
GO
IF OBJECT_ID ('dbo.EmployeeTwo', 'U') IS NOT NULL
DROP TABLE dbo.EmployeeTwo;
GO
IF OBJECT_ID ('dbo.EmployeeThree', 'U') IS NOT NULL
DROP TABLE dbo.EmployeeThree;
GO
SELECT pp.LastName, pp.FirstName, e.JobTitle
INTO dbo.EmployeeOne
FROM Person.Person AS pp JOIN HumanResources.Employee AS e
ON e.BusinessEntityID = pp.BusinessEntityID
WHERE LastName = 'Johnson';
GO
SELECT pp.LastName, pp.FirstName, e.JobTitle
INTO dbo.EmployeeTwo
FROM Person.Person AS pp JOIN HumanResources.Employee AS e
ON e.BusinessEntityID = pp.BusinessEntityID
WHERE LastName = 'Johnson';
GO
SELECT pp.LastName, pp.FirstName, e.JobTitle
INTO dbo.EmployeeThree
FROM Person.Person AS pp JOIN HumanResources.Employee AS e
ON e.BusinessEntityID = pp.BusinessEntityID
WHERE LastName = 'Johnson';
GO
-- Union ALL
SELECT LastName, FirstName, JobTitle
FROM dbo.EmployeeOne
UNION ALL
SELECT LastName, FirstName ,JobTitle
FROM dbo.EmployeeTwo
UNION ALL
SELECT LastName, FirstName,JobTitle
FROM dbo.EmployeeThree;
GO

SELECT LastName, FirstName,JobTitle

FROM dbo.EmployeeOne
UNION
SELECT LastName, FirstName, JobTitle
FROM dbo.EmployeeTwo
UNION
SELECT LastName, FirstName, JobTitle
FROM dbo.EmployeeThree;
GO

SELECT LastName, FirstName,JobTitle

FROM dbo.EmployeeOne
UNION ALL
(
SELECT LastName, FirstName, JobTitle
FROM dbo.EmployeeTwo
UNION
SELECT LastName, FirstName, JobTitle
FROM dbo.EmployeeThree
);
GO