Manejando SQL

CentralFWD
Manejando SQL
(volver al inicio)(visitar Google Fans)

(ir al indice de Articulos, hay muchos mas sobre el tema)

Nickname A Chatear seguro hay alguien conectado

-[ 3x05.txt ]----------------------------------------------------------------
-[ Manejando SQL ]-----------------------------------------------[ ShAd0w5 ]-
--------------------------------------------------------[ [email protected] ]-

5.- Consultas de Accion
-------------------
Las consultas de accion son aquellas que no devuelven ningun registro, son
las encargadas de acciones como a~adir y borrar y modificar registros.

5.1.- DELETE
------
Crea una consulta de eliminacion que elimina los registros de una o mas de
las tablas listadas en la clausula FROM que satisfagan la clausula WHERE.
Esta consulta elimina los registros completos, no es posible eliminar el
contenido de algun campo en concreto. Su sintaxis es:

DELETE Tabla.* FROM Tabla WHERE criterio

DELETE es especialmente util cuando se desea eliminar varios registros. En
una instruccion DELETE con multiples tablas, debe incluir el nombre de
tabla (Tabla.*). Si especifica mas de una tabla desde la que eliminar
registros, todas deben ser tablas de muchos a uno. Si desea eliminar todos
los registros de una tabla, eliminar la propia tabla es mas eficiente que
ejecutar una consulta de borrado.

Se puede utilizar DELETE para eliminar registros de una unica tabla o
desde varios lados de una relacion uno a muchos. Las operaciones de
eliminacion en cascada en una consulta unicamente eliminan desde varios
lados de una relacion. Por ejemplo, en la relacion entre las tablas
Clientes y Pedidos, la tabla Pedidos es la parte de muchos por lo que las
operaciones en cascada solo afectaran a la tabla Pedidos. Una consulta de
borrado elimina los registros completos, no unicamente los datos en campos
especificos. Si desea eliminar valores en un campo especificado, crear una
consulta de actualizacion que cambie los valores a Null.

Una vez que se han eliminado los registros utilizando una consulta de
borrado, no puede deshacer la operacion. Si desea saber que registros se
eliminaran, primero examine los resultados de una consulta de seleccion
que utilice el mismo criterio y despues ejecute la consulta de borrado.

Mantenga copias de seguridad de sus datos en todo momento. Si elimina los
registros equivocados podra recuperarlos desde las copias de seguridad.

DELETE * FROM Empleados WHERE Cargo = 'Vendedor';

5.2.- INSERT INTO
-----------

Agrega un registro en una tabla. Se la conoce como una consulta de datos
a~adidos. Esta consulta puede ser de dos tipo: Insertar un unico registro
o Insertar en una tabla los registros contenidos en otra tabla.

5.2.1.- Para insertar un unico Registro:
--------------------------------

En este caso la sintaxis es la siguiente:

INSERT INTO Tabla (campo1, campo2, .., campoN)
VALUES (valor1, valor2, ..., valorN)

Esta consulta graba en el campo1 el valor1, en el campo2 y valor2 y asi
sucesivamente. Hay que prestar especial atencion a acotar entre comillas
simples (') los valores literales (cadenas de caracteres) y las fechas
indicarlas en formato mm-dd-aa y entre caracteres de almohadillas (#).

5.2.2.- Para insertar Registros de otra Tabla:
--------------------------------------

En este caso la sintaxis es:

INSERT INTO Tabla [IN base_externa] (campo1, campo2, ..., campoN)
SELECT TablaOrigen.campo1, TablaOrigen.campo2, ..., TablaOrigen.campoN
FROM TablaOrigen

En este caso se seleccionaran los campos 1,2, ..., n de la tabla origen y
se grabaran en los campos 1,2,.., n de la Tabla. La condicion SELECT puede
incluir la clausula WHERE para filtrar los registros a copiar. Si Tabla y
TablaOrigen poseen la misma estrucutra podemos simplificar la sintaxis a:

INSERT INTO Tabla SELECT TablaOrigen.* FROM TablaOrigen

De esta forma los campos de TablaOrigen se grabaran en Tabla, para
realizar esta operacion es necesario que todos los campos de TablaOrigen
esten contenidos con igual nombre en Tabla. Con otras palabras que Tabla
posea todos los campos de TablaOrigen (igual nombre e igual tipo).

En este tipo de consulta hay que tener especial atencion con los campos
contadores o autonumericos puesto que al insertar un valor en un campo de
este tipo se escribe el valor que contenga su campo homologo en la tabla
origen, no incrementandose como le corresponde.

Se puede utilizar la instruccion INSERT INTO para agregar un registro
unico a una tabla, utilizando la sintaxis de la consulta de adicion de
registro unico tal y como se mostro anteriormente. En este caso, su codigo
especifica el nombre y el valor de cada campo del registro. Debe
especificar cada uno de los campos del registro al que se le va a asignar
un valor asi como el valor para dicho campo. Cuando no se especifica dicho
campo, se inserta el valor predeterminado o Null. Los registros se agregan
al final de la tabla.

Tambien se puede utilizar INSERT INTO para agregar un conjunto de
registros pertenecientes a otra tabla o consulta utilizando la clausula
SELECT ... FROM como se mostro anteriormente en la sintaxis de la consulta
de adicion de multiples registros. En este caso la clausula SELECT
especifica los campos que se van a agregar en la tabla destino
especificada.

La tabla destino u origen puede especificar una tabla o una consulta.

Si la tabla destino contiene una clave principal, hay que segurarse que
es unica, y con valores no-Null; si no es asi, no se agregaran los
registros. Si se agregan registros a una tabla con un campo Contador, no
se debe incluir el campo Contador en la consulta. Se puede emplear la
clausula IN para agregar registros a una tabla en otra base de datos.

Se pueden averiguar los registros que se agregaran en la consulta
ejecutando primero una consulta de seleccion que utilice el mismo
criterio de seleccion y ver el resultado. Una consulta de adicion copia
los registros de una o mas tablas en otra. Las tablas que contienen los
registros que se van a agregar no se veran afectadas por la consulta de
adicion. En lugar de agregar registros existentes en otra tabla, se puede
especificar los valores de cada campo en un nuevo registro utilizando la
clausula VALUES. Si se omite la lista de campos, la clausula VALUES debe
incluir un valor para cada campo de la tabla, de otra forma fallara
INSERT.

INSERT INTO Clientes SELECT Clientes_Viejos.* FROM Clientes_Nuevos;
INSERT INTO Empleados (Nombre, Apellido, Cargo)
VALUES ('Luis', 'Sanchez', 'Becario');

INSERT INTO Empleados SELECT Vendedores.* FROM Vendedores
WHERE Fecha_Contratacion < Now() - 30;

5.3.- UPDATE
------

Crea una consulta de actualizacion que cambia los valores de los campos
de una tabla especificada basandose en un criterio especifico. Su
sintaxis es:

UPDATE Tabla SET Campo1=Valor1, Campo2=Valor2, ... CampoN=ValorN
WHERE Criterio;

UPDATE es especialmente util cuando se desea cambiar un gran numero de
registros o cuando estos se encuentran en multiples tablas. Puede cambiar
varios campos a la vez. El ejemplo siguiente incrementa los valores
Cantidad pedidos en un 10 por ciento y los valores Transporte en un 3 por
ciento para aquellos que se hayan enviado al Reino Unido.:

UPDATE Pedidos SET Pedido = Pedidos * 1.1, Transporte = Transporte * 1.03
WHERE PaisEnvio = 'VE';

UPDATE no genera ningun resultado. Para saber que registros se van a
cambiar, hay que examinar primero el resultado de una consulta de
seleccion que utilice el mismo criterio y despues ejecutar la consulta de
actualizacion.

UPDATE Empleados SET Grado= 5 WHERE Grado= 2;
UPDATE Productos SET Precio= Precio * 1.1 WHERE Proveedor= 8 AND Familia=3;

Si en una consulta de actualizacion suprimimos la clausula WHERE todos
los registros de la tabla se~alada seran actualizados.

UPDATE Empleados SET Salario = Salario * 1.1

6. Tipos de Datos
--------------

Los tipos de datos SQL se clasifican en 13 tipos de datos primarios y de
varios sinonimos validos reconocidos por dichos tipos de datos.

Tipos de datos primarios:

7.- SubConsultas
------------

Una subconsulta es una instruccion SELECT anidada dentro de una
instruccion SELECT, SELECT...INTO, INSERT..INTO, DELETE, o UPDATE o dentro
de otra subconsulta.

Puede utilizar tres formas de sintaxis para crear una subconsulta:

comparacion [ANY | ALL | SOME] (instruccion sql)
expresion [NOT] IN (instruccion sql)
[NOT] EXISTS (instruccion sql)

En donde:

comparacion: Es una expresion y un operador de comparacion que compara la
expresion con el resultado de la subconsulta.

expresion : Es una expresion por la que se busca el conjunto resultante
de la subconsulta.

instruccion sql : Es una instruccion SELECT, que sigue el mismo formato y
reglas que cualquier otra instruccion SELECT. Debe ir
entre parentesis.

Se puede utilizar una subconsulta en lugar de una expresion en la lista
de campos de una instruccion SELECT o en una clausula WHERE o HAVING. En
una subconsulta, se utiliza una instruccion SELECT para proporcionar un
conjunto de uno o mas valores especificados para evaluar en la expresion
de la clausula WHERE o HAVING.

Se puede utilizar el predicado ANY o SOME, los cuales son sinonimos, para
recuperar registros de la consulta principal, que satisfagan la
comparacion 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);

El predicado ALL se utiliza para recuperar unicamente aquellos registros
de la consulta principal que satisfacen la comparacion con todos los
registros recuperados en la subconsulta. Si se cambia ANY por ALL en el
ejemplo anterior, la consulta devolvera unicamente 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 mas
restrictivo.

El predicado IN se emplea para recuperar unicamente 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 por ciento.:

SELECT * FROM Productos WHERE IDProducto IN
(SELECT IDProducto FROM DetallePedido WHERE Descuento >= 0.25);

Inversamente se puede utilizar NOT IN para recuperar unicamente aquellos
registros de la consulta principal para los que no hay ningun registro de
la subconsulta que contenga un valor igual.

El predicado EXISTS (con la palabra reservada NOT opcional) se utiliza en
comparaciones de verdad/falso para determinar si la subconsulta devuelve
algun registro.

Se puede utilizar tambien alias del nombre de la tabla en una subconsulta
para referirse a tablas listadas en la clausula 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 el mismo titulo. 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.

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 DISTINCTROW NombreProducto, Precio_Unidad FROM Productos
WHERE (Precio_Unidad = (SELECT Precio_Unidad FROM Productos WHERE
Nombre_Producto = "Caraotas Negras");

Obtiene una lista con el nombre y el precio unitario de todos los
productos con el mismo precio que las caraotas negras.

SELECT DISTINCTROW Nombre_Contacto, Nombre_Compa~ia, Cargo_Contacto,
Telefono FROM Clientes WHERE (ID_Cliente IN (SELECT DISTINCTROW
ID_Cliente FROM Pedidos WHERE Fecha_Pedido >= #04/1/99# <#07/1/99#);

Obtiene una lista de las compa~ias y los contactos de todos los clientes
que han realizado un pedido en el segundo trimestre de 1999.

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 DISTINCTROW Pedidos.Id_Producto, Pedidos.Cantidad,
(SELECT DISTINCTROW 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 Codigo del Producto y la Cantidad pedida de la tabla pedidos,
extrayendo el nombre del producto de la tabla de productos.

8. Consultas de Referencias Cruzadas
---------------------------------

Una consulta de referencias cruzadas es aquella que nos permite
visualizar los datos en filas y en columnas, estilo tabla, por ejemplo:

------------------------------------
| Producto / A~o | 2000 | 2001 |
------------------------------------
| Pantalones | 1.250 | 3.000 |
| Camisas | 8.560 | 1.253 |
| Zapatos | 4.369 | 2.563 |
------------------------------------

Si tenemos una tabla de productos y otra tabla de pedidos, podemos
visualizar en total de productos pedidos por a~o para un articulo
determinado, tal y como se visualiza en la tabla anterior.

La sintaxis para este tipo de consulta es la siguiente:

TRANSFORM funcion agregada instruccion select PIVOT campo pivot
[IN (valor1[, valor2[, ...]])]

En donde:

funcion agregada: Es una funcion SQL agregada que opera sobre los datos
seleccionados.

instruccion select: Es una instruccion SELECT.

campo pivot: Es el campo o expresion que desea utilizar para crear las
cabeceras de la columna en el resultado de la consulta.

valor1, valor2: Son valores fijos utilizados para crear las cabeceras de
la columna.

Para resumir datos utilizando una consulta de referencia cruzada, se
seleccionan los valores de los campos o expresiones especificadas como
cabeceras de columnas de tal forma que pueden verse los datos en un
formato mas compacto que con una consulta de seleccion.

TRANSFORM es opcional pero si se incluye es la primera instruccion de una
cadena SQL. Precede a la instruccion SELECT que especifica los campos
utilizados como encabezados de fila y una clausula GROUP BY que especifica
el agrupamiento de las filas. Opcionalmente puede incluir otras clausulas
como por ejemplo WHERE, que especifica una seleccion adicional o un
criterio de ordenacion.

Los valores devueltos en campo pivot se utilizan como encabezados de
columna en el resultado de la consulta. Por ejemplo, al utilizar las
cifras de ventas en el mes de la venta como pivot en una consulta de
referencia cruzada se crearian 12 columnas. Puede restringir el campo }
pivot para crear encabezados a partir de los valores fijos (valor1,
valor2) listados en la clausula opcional IN.

Tambien puede incluir valores fijos, para los que no existen datos, para
crear columnas adicionales.

Ejemplos:

TRANSFORM Sum(Cantidad) AS Ventas SELECT Producto, Cantidad FROM
Pedidos WHERE Fecha Between #01-01-01# And #12-31-01# GROUP BY Producto
ORDER BY Producto PIVOT DatePart("m", Fecha);

Crea una consulta de tabla de referencias cruzadas que muestra las ventas
de productos por mes para un a~o especifico. Los meses aparecen de
izquierda a derecha como columnas y los nombres de los productos aparecen
de arriba hacia abajo como filas.

TRANSFORM Sum(Cantidad) AS Ventas SELECT Compania FROM Pedidos
WHERE Fecha Between #01-01-01# And #12-31-01# GROUP BY Compania
ORDER BY Compania PIVOT "Trimestre " & DatePart("q", Fecha)
In ('Trimestre1','Trimestre2', 'Trimestre 3', 'Trimestre 4');

Crea una consulta de tabla de referencias cruzadas que muestra las ventas
de productos por trimestre de cada proveedor en el a~o indicado. Los
trimestres aparecen de izquierda a derecha como columnas y los nombres de
los proveedores aparecen de arriba hacia abajo como filas.

Un caso practico:

Se trata de resolver el siguiente problema: tenemos una tabla de
productos con dos campos, el codigo y el nombre del producto, tenemos
otra tabla de pedidos en la que anotamos el codigo del producto, la fecha
del pedido y la cantidad pedida. Deseamos consultar los totales de
producto por a~o, calculando la media anual de ventas.

Estructura y datos de las tablas:

1. Articulos:
-------------------
| ID | Nombre |
-------------------
| 1 | Zapatos |
| 2 | Pantalones |
| 3 | Blusas |
-------------------

2. Pedidos:

------------------------------
| Id | Fecha | Cantidad |
------------------------------
| 1 | 11/11/2000 | 250 |
| 2 | 11/11/2000 | 125 |
| 3 | 11/11/2000 | 520 |
| 1 | 12/10/2000 | 50 |
| 2 | 04/05/2000 | 250 |
| 3 | 05/08/2000 | 100 |
| 1 | 01/01/2001 | 40 |
| 2 | 02/08/2001 | 60 |
| 3 | 05/10/2001 | 70 |
| 1 | 12/12/2001 | 8 |
| 2 | 15/12/2001 | 520 |
| 3 | 17/10/2001 | 1250 |
------------------------------

Para resolver la consulta planteamos la siguiente consulta:

TRANSFORM Sum(Pedidos.Cantidad) AS Resultado SELECT Nombre AS Producto,
Pedidos.Id AS Codigo, Sum(Pedidos.Cantidad) AS TOTAL, Avg(Pedidos.Cantidad)
AS Media FROM Pedidos INNER JOIN Articulos ON Pedidos.Id = Articulos.Id
GROUP BY Pedidos.Id, Articulos.Nombre PIVOT Year(Fecha);

y obtenemos el siguiente resultado:

--------------------------------------------------------
| Producto | Codigo | TOTAL | Media | 2000 | 2001 |
--------------------------------------------------------
| Zapatatos | 1 | 348 | 87 | 300 | 48 |
| Pantalones | 2 | 955 | 238,75 | 375 | 580 |
| Blusas | 3 | 1940 | 485 | 620 | 1320 |
--------------------------------------------------------

Comentarios a la consulta:
--------------------------

La clasula TRANSFORM indica el valor que deseamos visualizar en las
columnas que realmente pertenecen a la consulta, en este caso 2000 y 2001,
puesto que las demas columnas son opcionales.

SELECT especifica el nombre de las columnas opcionales que deseamos
visualizar, en este caso Producto, Codigo, Total y Media, indicando el
nombre del campo que deseamos mostrar en cada columna o el valor de la
misma. Si incluimos una funcion de calculo el resultado se hara en base a
los datos de la fila actual y no al total de los datos.

FROM especifica el origen de los datos. La primera tabla que debe figurar
es aquella de donde deseamos extraer los datos, esta tabla debe contener
al menos tres campos, uno para los titulos de la fila, otros para los
titulos de la columna y otro para calcular el valor de las celdas.

En este caso en concreto se deseaba visualizar el nombre del producto,
como el tabla de pedidos solo figuraba el codigo del mismo se a~adio una
nueva columna en la clausula select llamada Producto que se corresponda
con el campo Nombre de la tabla de articulos. Para vincular el codigo del
articulo de la tabla de pedidos con el nombre del misma de la tabla
articulos se inserto la clausula INNER JOIN.

La clausula GROUP BY especifica el agrupamiento de los registros,
contrariamente a los manuales de instruccion esta clausula no es opcional
ya que debe figurar siempre y debemos agrupar los registros por el campo
del cual extraemos la informacion. En este caso existen dos campos del
cual extraemos la informacion: pedidos.cantidad y articulos.nombre, por
ellos agrupamos por los campos.

Para finalizar la clausula PIVOT indica el nombre de las columnas no
opcionales, en este caso 2000 y 2001 y como vamos a el dato que aparecera
en las columnas, en este caso empleamos el a~o en que se produjo el
pedido, extrayendolo del campo pedidos.fecha.

Otras posibilidades de fecha de la clausula pivot son las siguientes:

a. Para agrupamiento por Trimestres
PIVOT "Tri " & DatePart("q",[Fecha]);

b. Para agrupamiento por meses (sin tener en cuenta el a~o)
PIVOT Format([Fecha],"mmm")
In ("Ene", "Feb", "Mar", "Abr", "May", "Jun", "Jul",
"Ago", "Sep", "Oct", "Nov", "Dic");

c. Para agrupar por dias
PIVOT Format([Fecha],"Short Date");

9. Consultas de Union Internas
---------------------------

Las vinculaciones entre tablas se realiza mediante la clausula INNER que
combina registros de dos tablas siempre que haya concordancia de valores
en un campo comun. Su sintaxis es:

SELECT campos FROM tb1 INNER JOIN tb2 ON tb1.campo1 comp tb2.campo2

En donde

tb1, tb2: Son los nombres de las tablas desde las que se combinan los
registros.

campo1, campo2: Son los nombres de los campos que se combinan. Si no son
numericos, los campos deben ser del mismo tipo de datos y
contener el mismo tipo de datos, pero no tienen que tener
el mismo nombre.
comp: Es cualquier operador de comparacion relacional.

Se puede utilizar una operacion INNER JOIN en cualquier clausula FROM.
Esto crea una combinacion por equivalencia, conocida tambien como union
interna. Las combinaciones Equi son las mas comunes; estas combinan los
registros de dos tablas siempre que haya concordancia de valores en un
campo comun a ambas tablas. Se puede utilizar INNER JOIN con las tablas
departamentos y Empleados para seleccionar todos los empleados de cada
departamento. Por el contrario, para seleccionar todos los departamentos
(incluso si alguno de ellos no tiene ningun empleado asignado) se emplea
LEFT JOIN o todos los empleados (incluso si alguno no esta asignado a
ningun departamento), en este caso RIGHT JOIN.

Si se intenta combinar campos que contengan datos Memo u Objeto OLE, se
produce un error. Se pueden combinar dos campos numericos cualesquiera,
incluso si son de diferente tipo de datos. Por ejemplo, puede combinar un
campo Numerico para el que la propiedad Size de su objeto Field esta
establecida como Entero, y un campo Contador.

El ejemplo siguiente muestra como podria combinar las tablas Categorias y
Productos basandose en el campo IDCategoria:

SELECT Nombre_Categoria, NombreProducto
FROM Categorias INNER JOIN Productos
ON Categorias.IDCategoria = Productos.IDCategoria;

En el ejemplo anterior, IDCategoria es el campo combinado, pero no esta
incluido en la salida de la consulta ya que no esta incluido en la
instruccion SELECT. Para incluir el campo combinado, incluir el nombre del
campo en la instruccion SELECT, en este caso, Categorias.IDCategoria.

Tambien se pueden enlazar varias clausulas ON en una instruccion JOIN,
utilizando la sintaxis siguiente:

SELECT campos
FROM tabla1 INNER JOIN tabla2
ON tb1.campo1 comp tb2.campo1 AND
ON tb1.campo2 comp tb2.campo2) OR
ON tb1.campo3 comp tb2.campo3)];

Tambien puede anidar instrucciones JOIN utilizando la siguiente sintaxis:

SELECT campos
FROM tb1 INNER JOIN
(tb2 INNER JOIN [( ]tb3
[INNER JOIN [( ]tablax [INNER JOIN ...)]
ON tb3.campo3 comp tbx.campox)]
ON tb2.campo2 comp tb3.campo3)
ON tb1.campo1 comp tb2.campo2;

Un LEFT JOIN o un RIGHT JOIN puede anidarse dentro de un INNER JOIN, pero
un INNER JOIN no puede anidarse dentro de un LEFT JOIN o un RIGHT JOIN.

Ejemplo:

SELECT DISTINCTROW Sum([Precio unidad] * [Cantidad]) AS [Ventas],
[Nombre] & " " & [Apellidos] AS [Nombre completo] FROM [Detalles de pedidos],
Pedidos, Empleados, Pedidos INNER JOIN [Detalles de pedidos] ON Pedidos.
[ID de pedido] = [Detalles de pedidos].[ID de pedido], Empleados INNER JOIN
Pedidos ON Empleados.[ID de empleado] = Pedidos.[ID de empleado] GROUP BY
[Nombre] & " " & [Apellidos];

Crea dos combinaciones equivalentes: una entre las tablas Detalles de
pedidos y Pedidos, y la otra entre las tablas Pedidos y Empleados. Esto
es necesario ya que la tabla Empleados no contiene datos de ventas y la
tabla Detalles de pedidos no contiene datos de los empleados. La consulta
produce una lista de empleados y sus ventas totales.

Si empleamos la clausula INNER en la consulta se seleccionaran solo
aquellos registros de la tabla de la que hayamos escrito a la izquierda
de INNER JOIN que contengan al menos un registro de la tabla que hayamos
escrito a la derecha. Para solucionar esto tenemos dos clausulas que
sustituyen a la palabra clave INNER, estas clausulas son LEFT y RIGHT.

LEFT toma todos los registros de la tabla de la izquierda aunque no
tengan ningun registro en la tabla de la izquierda. RIGHT realiza la
misma operacion pero al contrario, toma todos los registros de la tabla
de la derecha aunque no tenga ningun registro en la tabla de la izquierda.

10. Consultas de Union Externas
---------------------------

Se utiliza la operacion UNION para crear una consulta de union,
combinando los resultados de dos o mas consultas o tablas independientes.

Su sintaxis es:

[TABLE] consulta1 UNION [ALL] [TABLE]
consulta2 [UNION [ALL] [TABLE] consultan [ ... ]]

En donde:

consulta1, consulta2 ,... : Son instrucciones SELECT, el nombre de una
consulta almacenada o el nombre de una tabla
almacenada precedido por la palabra clave
TABLE.

Puede combinar los resultados de dos o mas consultas, tablas e
instrucciones SELECT, en cualquier orden, en una unica operacion UNION.

El ejemplo siguiente combina una tabla existente llamada Nuevas Cuentas y
una instruccion SELECT:

TABLE [Nuevas Cuentas] UNION ALL SELECT * FROM Clientes
WHERE [Cantidad pedidos] > 1000;

Si no se indica lo contrario, no se devuelven registros duplicados cuando
se utiliza la operacion UNION, no obstante puede incluir el predicado ALL
para asegurar que se devuelven todos los registros. Esto hace que la
consulta se ejecute mas rapidamente. Todas las consultas en una operacion
UNION deben pedir el mismo numero de campos, no obstante los campos no
tienen porque tener el mismo tama~o o el mismo tipo de datos.

Se puede utilizar una clausula GROUP BY y/o HAVING en cada argumento
consulta para agrupar los datos devueltos. Puede utilizar una clausula
ORDER BY al final del ultimo argumento consulta para visualizar los datos
devueltos en un orden especifico.

SELECT [Nombre de compa~ia], Ciudad FROM Proveedores WHERE
Pais = 'Brasil' UNION SELECT [Nombre de compa~ia], Ciudad FROM Clientes
WHERE Pais = "Brasil"

Recupera los nombres y las ciudades de todos proveedores y clientes de
Brasil

SELECT [Nombre de compa~ia], Ciudad FROM Proveedores WHERE
Pais = 'Brasil' UNION SELECT [Nombre de compa~ia], Ciudad FROM Clientes
WHERE Pais = 'Brasil' ORDER BY Ciudad

Recupera los nombres y las ciudades de todos proveedores y clientes
radicados en Brasil, ordenados por el nombre de la ciudad

SELECT [Nombre de compa~ia], Ciudad FROM Proveedores WHERE
Pais = 'Brasil' UNION SELECT [Nombre de compa~ia], Ciudad FROM Clientes
WHERE Pais = 'Brasil' UNION SELECT [Apellidos], Ciudad FROM Empleados
WHERE Region = 'America del Sur'

Recupera los nombres y las ciudades de todos los proveedores y clientes
de brasil y los apellidos y las ciudades de todos los empleados de
America del Sur

TABLE [Lista de clientes] UNION TABLE [Lista de proveedores]

Recupera los nombres y codigos de todos los proveedores y clientes.

--EOF--

-[ 4x05.txt ]----------------------------------------------------------------
-[ Manejando SQL (III Parte) ]-----------------------------------[ ShAd0w5 ]-
------------------------------------------------------[ [email protected] ]-

11. Estructuras de las Tablas
-------------------------

11.1 Creacion de Tablas Nuevas
-------------------------

Si se esta utilizando el motor de datos de Microsoft para acceder a bases
de datos access, solo se puede emplear esta instruccion para crear bases
de datos propias de access. Su sintaxis es:

CREATE TABLE tabla (campo1 tipo (tama~o) indice1 ,
campo2 tipo (tama~o) indice2 , ...,
indice multicampo , ... )

En donde:

* tabla: Es el nombre de la tabla que se va a crear.

* campo1, campo2: Es el nombre del campo o de los campos que se van a
crear en la nueva tabla. La nueva tabla debe contener,
al menos, un campo.

* tipo: Es el tipo de datos de campo en la nueva tabla. (Ver Tipos de
Datos)

* tama~o:Es el tama~o del campo solo se aplica para campos de tipo texto.

* indice1, indice2: Es una clausula CONSTRAINT que define el tipo de
indice a crear. Esta clausula en opcional.

* indice multicampos: Es una clausula CONSTRAINT que define el tipo de
indice multicampos a crear. Un indice multi campo es aquel que esta indexado por el contenido de varios campos. Esta clausula en opcional.

CREATE TABLE Empleados (Nombre TEXT (25) , Apellidos TEXT (50));

Crea una nueva tabla llamada Empleados con dos campos, uno llamado Nombre
de tipo texto y longutid 25 y otro llamado apellidos con longitud 50.

CREATE TABLE Empleados (Nombre TEXT (10), Apellidos TEXT,
Fecha_Nacimiento DATETIME) CONSTRAINT IndiceGeneral UNIQUE
([Nombre], [Apellidos], [Fecha_Nacimiento]);

Crea una nueva tabla llamada Empleados con un campo Nombre de tipo texto y
longitud 10, otro con llamado Apellidos de tipo texto y longitud
predeterminada (50) y uno mas llamado Fecha_Nacimiento de tipo Fecha/Hora.

Tambien crea un indice unico (no permite valores repetidos) formado por
los tres campos.

CREATE TABLE Empleados (ID INTEGER CONSTRAINT IndicePrimario PRIMARY,
Nombre TEXT, Apellidos TEXT, Fecha_Nacimiento DATETIME);

Crea una tabla llamada Empleados con un campo Texto de longitud
predeterminada (50) llamado Nombre y otro igual llamado Apellidos, crea
otro campo llamado Fecha_Nacimiento de tipo Fecha/Hora y el campo ID de
tipo entero el que establece como clave principal.

11.2 La clausula CONSTRAINT
----------------------

Se utiliza la clausula CONSTRAINT en las instrucciones ALTER TABLE y
CREATE TABLE para crear o eliminar indices. Existen dos sintaxis para
esta clausula dependiendo si desea Crear o Eliminar un indice de un unico
campo o si se trata de un campo multiindice. Si se utiliza el motor de
datos de Microsoft, solo podra utilizar esta clausula con las bases de
datos propias de dicho motor.

Para los indices de campos unicos:

CONSTRAINT nombre {PRIMARY KEY | UNIQUE | REFERENCES tabla externa
[(campo externo1, campo externo2)]}

Para los indices de campos multiples:

CONSTRAINT nombre {PRIMARY KEY (primario1[, primario2 [, ...]]) |
UNIQUE (unico1[, unico2 [, ...]]) |
FOREIGN KEY (ref1[, ref2 [, ...]]) REFERENCES tabla externa [(campo
externo1 [,campo externo2 [, ...]])]}

* nombre: Es el nombre del indice que se va a crear.

* primarioN: Es el nombre del campo o de los campos que forman el indice
primario.

* unicoN: Es el nombre del campo o de los campos que forman el indice de
clave unica.

* refN: Es el nombre del campo o de los campos que forman el indice externo
(hacen referencia a campos de otra tabla).

* tabla externa: Es el nombre de la tabla que contiene el campo o los
campos referenciados en refN.

* campos externos: Es el nombre del campo o de los campos de la tabla
externa especificados por ref1, ref2, ..., refN

Si se desea crear un indice para un campo cuando se esta utilizando las
instrucciones ALTER TABLE o CREATE TABLE la clausula CONTRAINT debe
aparecer inmediatamente despues de la especificacion del campo indexeado.

Si se desea crear un indice con multiples campos cuando se esta utilizando
las instrucciones ALTER TABLE o CREATE TABLE la clausula CONSTRAINT debe
aparecer fuera de la clausula de creacion de tabla.

-------------------------------------------------------------------------
| Tipo de Indice | Descripcion |
-------------------------------------------------------------------------
| UNIQUE | Genera un indece de clave unica. Lo que implica que |
| | los registros de la tabla no pueden contener el |
| | mismo valor en los campos indexados. |
-------------------------------------------------------------------------
| PRIMARY KEY | Genera un indice primario el campo o los campos |
| | especificados. Todos los campos de la clave principal
| | deben ser unicos y no nulos, cada tabla solo puede |
| | contener una unica clave principal. |
-------------------------------------------------------------------------
| FOREIGN KEY | Genera un indice externo (toma como valor del indice|
| | campos contenidos en otras tablas). Si la clave |
| | principal de la tabla externa consta de mas de un |
| | campo, se debe utilizar una definicion de indice de |
| | multiples campos, listando todos los campos de |
| | referencia, el nombre de la tabla externa, y los |
| | nombres de los campos referenciados en la tabla |
| | externa en el mismo orden que los campos de |
| | referencia listados. Si los campos referenciados son|
| | la clave principal de la tabla externa, no tiene que|
| | especificar los campos referenciados, predeterminado|
| | por valor, el motor Jet se comporta como si la clave|
| | principal de la tabla externa fueran los campos |
| | referenciados . |
-------------------------------------------------------------------------

11.3 Creacion de indices
-------------------

Si se utiliza el motor de datos Jet de Microsoft solo se pueden crear
indices en bases de datos del mismo motor. La sintaxis para crear un
indice en ua tabla ya definida en la siguiente:

CREATE [ UNIQUE ] INDEX indice
ON tabla (campo [ASC|DESC][, campo [ASC|DESC], ...])
[WITH { PRIMARY | DISALLOW NULL | IGNORE NULL }]

En donde:

* indice: Es el nombre del indice a crear.

* tabla: Es el nombre de una tabla existentes en la que se creara el
indice.

* campo: Es el nombre del campo o lista de campos que consituyen el
indice.

* ASC|DESC: Indica el orden de los valores de lso campos ASC indica un
orden ascendente (valor predeterminado) y DESC un orden
descendente.

* UNIQUE: Indica que el indice no puede contener valores duplicados.

* DISALLOW NULL: Prohibe valores nulos en el indice.

* IGNORE NULL: Excluye del indice los valores nulos incluidos en los
campos que lo componen.

* PRIMARY: Asigna al indice la categoria de clave principal, en cada tabla
solo puede existir un unico indice que sea "Clave Principal".
Si un indice es clave principal implica que que no puede
contener valores nulos ni duplicados.

Se puede utilizar CREATE INDEX para crear un pseudo indice sobre una tabla
adjunta en una fuente de datos ODBC tal como SQL Server que no tenga
todavia un indice. No necesita permiso o tener acceso a un servidor remoto
para crear un pseudo indice, ademas la base de datos remota no es
consciente y no es afectada por el pseudo indice. Se utiliza la misma
sintaxis para las tabla adjunta que para las originales. Esto es
especialmente util para crear un indice en una tabla que seria de solo
lectura debido a la falta de un indice.

CREATE INDEX MiIndice ON Empleados (Prefijo, Telefono);

Crea un indice llamado MiIndice en la tabla empleados con los campos
Prefijo y Telefono.

CREATE UNIQUE INDEX MiIndice ON Empleados (ID) WITH DISALLOW NULL;

Crea un indice en la tabla Empleados utilizando el campo ID, obligando
que que el campo ID no contenga valores nulos ni repetidos.

11.4 Modificar el Dise~o de una Tabla
--------------------------------

Modifica el dise~o de una tabla ya existente, se puden modificar los
campos o los indices existentes. Su sintaxis es:

ALTER TABLE tabla {ADD {COLUMN tipo de campo[(tama~o)] [CONSTRAINT indice]
CONSTRAINT indice multicampo} |
DROP {COLUMN campo I CONSTRAINT nombre del indice} }

En donde:

* tabla: Es el nombre de la tabla que se desea modificar.

* campo: Es el nombre del campo que se va a a~adir o eliminar.

* tipo: Es el tipo de campo que se va a a~adir.

* tama~o: El el tama~o del campo que se va a a~adir (solo para campos de
texto).

* indice: Es el nombre del indice del campo (cuando se crean campos) o el
nombre del indice de la tabla que se desea eliminar.

* indice multicampo: Es el nombre del indice del campo multicampo (cuando
se crean campos) o el nombre del indice de la tabla
que se desea eliminar.

--------------------------------------------------------------------------
| Operacion | Descripcion |
--------------------------------------------------------------------------
| ADD COLUMN | Se utiliza para a~adir un nuevo campo a la tabla, |
| | indicando el nombre, el tipo de campo y opcionalmente el |
| | tama~o (para campos de tipo texto). |
--------------------------------------------------------------------------
| ADD | Se utliza para agregar un indice de multicampos o de un |
| | unico campo. |
--------------------------------------------------------------------------
| DROP COLUMN | Se utliza para borrar un campo. Se especifica unicamente |
| | el nombre del campo. |
--------------------------------------------------------------------------
| DROP | Se utiliza para eliminar un indice. Se especifica |
| | unicamente el nombre del indice a continuacion de la |
| | palabra reservada CONSTRAINT. |
--------------------------------------------------------------------------

ALTER TABLE Empleados ADD COLUMN Salario CURRENCY;

Agrega un campo Salario de tipo Moneda a la tabla Empleados.

ALTER TABLE Empleados DROP COLUMN Salario;

Elimina el campo Salario de la tabla Empleados.

ALTER TABLE Pedidos ADD CONSTRAINT RelacionPedidos FOREIGN KEY
(ID_Empleado) REFERENCES Empleados (ID_Empleado);

Agrega un indice externo a la tabla Pedidos. El indice externo se basa en
el campo ID_Empleado y se refiere al campo ID_Empleado de la tabla
Empleados. En este ejemplo no es necesario indicar el campo junto al
nombre de la tabla en la clausula REFERENCES, pues ID_Empleado es la clave
principal de la tabla Empleados.

ALTER TABLE Pedidos DROP CONSTRAINT RelacionPedidos;

Elimina el indide de la tabla Pedidos.

12 Consultas con Parametros
------------------------

Las consultas con parametros son aquellas cuyas condiciones de busqueda se
definen mediante parametros. Si se ejecutan directamente desde la base de
datos donde han sido definidas aparecera un mensaje solicitando el valor
de cada uno de los parametros. Si deseamos ejecutarlas desde una aplicacion
hay que asignar primero el valor de los parametros y despues ejecutarlas.

Su sintaxis es la siguiente:

PARAMETERS nombre1 tipo1, nombre2 tipo2, ... , nombreN tipoN Consulta

En donde:

* nombre: Es el nombre del parametro.
* tipo: Es el tipo de datos del parametro.
* consulta: Una consulta SQL.

Puede utilizar nombre pero no tipo de datos en una clausula WHERE o
HAVING.

PARAMETERS Precio_Minimo Currency, Fecha_Inicio DateTime;
SELECT IDPedido, Cantidad FROM Pedidos WHERE Precio > Precio_Minimo
AND FechaPedido >= Fecha_Inicio;

El ejemplo siguiente muestra como utilizar los parametros en el programa
de Visual Basic:

Public Sub GeneraConsulta()

Dim SQL As String
Dim Qd As QueryDef
Dim Rs As Recordset

SQL = "PARAMETERS Precio_Minimo Currency, Fecha_Inicio DateTime; "
SQL = SQL & "SELECT IDPedido, Cantidad FROM Pedidos WHERE Precio > "
SQL = SQL & "Precio_Minimo AND FechaPedido >= Fecha_Inicio; "

Set Qd = BaseDatos.CreateQueryDef(MiConsulta, SQL)

Qd.Parameters!Precio_Minimo = 2
Qd.Parameters!FechaInicio = #31/12/95#

Set Rs = Qd.OpenRecordset()

End Sub

Ejemplo:

PARAMETERS [Escriba los Apellidos:] Text; SELECT * FROM Empleados
WHERE [Escriba los Apellidos:] = [Apellidos];

La ejecucion desde la base de datos solicita al usuario los apellidos del
empleado y despues muestra los resultados.

13. Bases de Datos Externas
-----------------------

Para el acceso a bases de datos externas se utiliza la clausula IN. Se
puede acceder a base de datos dBase, Paradox o Btrieve. Esta clausula solo
permite la conexion de una base de datos externa a la vez. Una base de
datos externa es una base de datos que no sea la activa. Aunque para
mejorar los rendimientos es mejor adjuntarlas a la base de datos actual y
trabajar con ellas.

Para especificar una base de datos que no pertenece a Access Basic, se
agrega un punto y coma (;) al nombre y se encierra entre comillas simples.
Tambien puede utilizar la palabra reservada DATABASE para especificar la
base de datos externa. Por ejemplo, las lineas siguientes especifican la
misma tabla:

FROM Tabla IN '[dBASE IV; DATABASE=C:\DBASE\DATOS\VENTAS;]';
FROM Tabla IN 'C:\DBASE\DATOS\VENTAS' 'dBASE IV;'

* Acceso a una base de datos externa de Microsoft Access:

SELECT IDCliente FROM Clientes IN MISDATOS.MDB WHERE IDCliente Like 'A*';

En donde MISDATOS.MDB es el nombre de una base de datos de Microsoft
Access que contiene la tabla Clientes.

* Acceso a una base de datos externa de dBASE III o IV:

SELECT IDCliente FROM Clientes IN 'C:\DBASE\DATOS\VENTAS' 'dBASE IV';
WHERE IDCliente Like 'A*';

Para recuperar datos de una tabla de dBASE III+ hay que utilizar 'dBASE
III+;' en lugar de 'dBASE IV;'.

* Acceso a una base de datos de Paradox 3.x o 4.x:

SELECT IDCliente FROM Clientes IN 'C:\PARADOX\DATOS\VENTAS'
'Paradox 4.x;' WHERE IDCliente Like 'A*';

Para recuperar datos de una tabla de Paradox version 3.x, hay que
sustituir 'Paradox 4.x;' por 'Paradox 3.x;'.

* Acceso a una base de datos de Btrieve:

SELECT IDCliente FROM Clientes IN 'C:\BTRIEVE\DATOS\VENTAS\FILE.DDF'
'Btrieve;' WHERE IDCliente Like 'A*';

C:\BTRIEVE\DATOS\VENTAS\FILE.DDF es la ruta de acceso y nombre de archivo
del archivo de definicion de datos de Btrieve.

14. Omitir los Permisos de Ejecucion
--------------------------------

En entornos de bases de datos con permisos de seguridad para grupos de
trabajo se puede utilizar la clausula WITH OWNERACCESS OPTION para que el
usuario actual adquiera los derechos de propietario a la hora de ejecutar
la consulta. Su sintaxis es:

instruccion sql WITH OWNERACCESS OPTION

SELECT Apellido, Nombre, Salario FROM Empleados ORDER BY Apellido
WITH OWNERACCESS OPTION;

Esta opcion requiere que este declarado el acceso al fichero de grupo de
trabajo (generalmente system.mda o system .mdw) de la base de datos
actual.

15 La Clausula PROCEDURE
---------------------

Esta clausula es poco usual y se utiliza para crear una consulta a la
misma vez que se ejecuta, opcionalmente define los parametros de la misma.
Su sintaxis es la siguiente:

PROCEDURE NombreConsulta Parametro1 tipo1, .... , ParametroN tipon ConsultaSQL

En donde:

* NombreConsulta: Es el nombre con se guardara la consulta en la base de
datos.
* Parametro: Es el nombre de parametro o de los parametros de dicha
consulta.
* tipo: Es el tipo de datos del parametro.

* ConsultaSQL: Es la consulta que se desea grabar y ejecutar.

PROCEDURE Lista_Categorias; SELECT DISTINCTROW Nombre_Categoria,
ID_Categoria FROM Categorias ORDER BY Nombre_Categoria;

Asigna el nombre Lista_de_categorias a la consulta y la ejecuta.

PROCEDURE Resumen Fecha_Inicio DateTime, Fecha_Final DateTime; SELECT
DISTINCTROW Fecha_Envio, ID_Pedido, Importe_Pedido, Format(Fecha_Envio,
"yyyy") AS A~o FROM Pedidos WHERE Fecha_Envio Between Fecha_Inicio
And Fecha_Final;

Asigna el nombre Resumen a la consulta e incluye dos parametros.

16 ANEXOS
------

16.1 Resolucion de Problemas
-----------------------

16.1.1 Buscar Informacion duplicada en un campo de una tabla
-----------------------------------------------------

Para generar este tipo de consultas lo mas sencillo es utilizar el
asistente de consultas de Access, editar la sentencia SQL de la consulta
y pegarla en nuestro codigo. No obstante este tipo de consulta se consigue
de la siguiente forma:

SELECT DISTINCTROW Lista de Campos a Visualizar FROM Tabla
WHERE CampoDeBusqueda In (SELECT CampoDeBusqueda FROM Tabla As psudonimo
GROUP BY CampoDeBusqueda HAVING Count(*)>1 ) ORDER BY CampoDeBusqueda;

Un caso practico, si deseamos localizar aquellos empleados con igual
nombre y visualizar su codigo correspondiente, la consulta seria la
siguiente:

SELECT DISTINCTROW Empleados.Nombre, Empleados.IdEmpleado
FROM Empleados WHERE Empleados.Nombre In (SELECT Nombre FROM
Empleados As Tmp GROUP BY Nombre HAVING Count(*)>1)
ORDER BY Empleados.Nombre;

16.1.2 Recuperar Registros de una tabla que no contengan registros
relacionados en otra.
------------------------------------------------------------

Este tipo de consulta se emplea en situaciones tales como saber que
productos no se han vendido en un determinado periodo de tiempo,

SELECT DISTINCTROW Productos.IdProducto, Productos.Nombre FROM Productos
LEFT JOIN Pedidos ON Productos.IdProducto = Pedidos.IdProduct WHERE
(Pedidos.IdProducto Is Null) AND (Pedidos.Fecha Between #01-01-02# And
#01-30-02#);

La sintaxis es sencilla, se trata de realizar una union interna entre dos
tablas seleccionadas mediante un LEFT JOIN, establecimiendo como condicion
que el campo relacionado de la segunda sea Null.

16.2 Utlizar SQL desde Visual Basic
------------------------------

Existen dos tipos de consultas SQL: las consultas de seleccion (nos
devuelven datos) y las consultas de accion (aquellas que no devuelven
ningun registro). Ambas pueden ser tratadas en Visual Basic pero de forma
diferente.

Las consultas de seleccion se ejecutan recogiendo la informacion en un
recordset previamente definido mediante la instruccion openrecordset(),
por ejemplo:

Dim SQL as String
Dim RS as recordset

SQL = "SELECT * FROM Empleados;"
Set RS=MiBaseDatos.OpenRecordSet(SQL)

Si la consula de seleccion se encuentra almacenada en una consulta de la
base de datos:

Set RS=MiBaseDatos.OpenRecordset("MiConsulta")

Las consultas de accion, al no devolver ningun registro, no las podemos
asignar a ningun recordset, en este caso la forma de ejecutarlas es
mediante los metodos Execute y ExecuteSQL (para bases de datos ODBC), por
ejemplo:

Dim SQL as string

SQL = "DELETE * FROM Empleados WHERE Categoria = 'Ordenanza';"
MiBaseDatos.Execute SQL

DatePart
--------

Esta funcion devuelve una parte se~alada de una fecha concreta. Su
sintaxis es:

DatePart(Parte, Fecha, ComienzoSemana, ComienzoA~o)

Parte representa a la porcion de fecha que se desea obtener, los posibles
valores son:

yyyy: A~o
q: Trimestre
m: Mes
y: Dia del a~o
d: Dia del mes
w: Dia de la semana
ww: Semana del a~o
h: Hora
m: Minutos
s: Segundos

ComienzoSemana indica el primer dia de la semana. Los posibles valores
son:

0: Utiliza el valor pode efecto del sistema
1: Domingo (Valor predeterminado)
2: Lunes
3: Martes
4: Miercoles
5: Jueves
6: Viernes
7: Sabado

ComienzoA~o indica cual es la primera semana del a~o; los posibles valores
son:

0: Valor del sistema
1: Comienza el a~o el 1 de enero (valor predeterminado).
2: Empieza con la semana que tenga al memos cuatro dias en el nuevo a~o.
3: Empieza con la semana que este contenida completamente en el nuevo a~o.

16.4 Evaluar valores antes de ejecutar la Consuta
--------------------------------------------

Dentro de una sentencia SQL podemos emplear la funcion iif para indicar
las condiciones de busqueda. La sintaxis de la funcion iif es la
siguiente:

iif(Expresion,Valor1,Valor2)

En donde Expresion es la sentencia que evaluamos; si Expresion es
verdadera entonces se devuelve Valor1, si Expresion es falsa se devuelve
Valor2.

SELECT * Total FROM Empleados WHERE Apellido =
iff(TX_Apellido.Text <> '', TX_Apellido.Text, *) ;

Supongamos que en un formulario tenemos una casilla de texto llamanda
TX_Apellido. Si cuando ejecutamos esta consulta la casilla contiene algun
valor se devuelven todos los empleados cuyo apellido coincida con el texto
de la casilla, en caso contrario se devuelven todos los empleados.

SELECT Fecha, Producto, Cantidad, (iif(CodigoPostal>=28000 And
CodigoPostal <=28999,'Merida','Nacional')) AS Destino FROM Pedidos;

Esta consulta devuelve los campos Fecha, Nombre del Producto y Cantidad de
la tabla pedidos, a~adiendo un campo al final con el valor Merida si el
codigo posta esta dentro del intervalo, en caso contario devuelve
Nacional.

16.5 Un Peque~o Manual de Estilo
---------------------------

Siempre es bueno intentar hacer las cosas de igual modo para que el
mantenimiento y la revision nos sea una labor lo mas sencilla posible. En
lo que a mi respecta utilizo las siguiente normas a la hora de elaborar
sentecias SQL:

* Las clausulas siempre las escribo con Mayusculas.
* Los operadores logicos de sentencias siempre con Mayusculas.
* Las operaciones siempre la primera letra con mayusculas y el resto en
minusculas.
* Los operadores logicos incluidos en otros operadores la primera letra
con mayusculas y el resto con minuculas.
* Los Nombres de las Tablas, Campos y Consultas, los escribo siempre la
primera letra con mayusculas y el resto con minusculas, en algunos casos
utilizo el caracter "_" para definir mejor el nombre: Detalles_Pedidos.

Aunque con el motor Jet se pueden utilizar acentos y espacios en blanco
para nombrar los campos, las tablas y las consultas no los utilizo porque
cuando se exportar tablas a otros sistemas los acentos y los espacios en
blanco pueden producir errores innecesarios.

Recuerda siempre que si utilizas espacios en blanco para llamar tablas o
consultas cada vez que hagas referencias a ellos en una consulta debes
incluir sus nombres entre corchetes.

SELECT [ID de Pedido], [Nombre del Producto], Cantidad FROM [Detalles del
Pedido];

Para enviar esta pagina a un amigo solo coloca el link en un e-mail:

(volver al inicio)
Agregar a los Favoritos | Establecer como inicio

Contador gratuito

Hosted by www.Geocities.ws