Sie sind auf Seite 1von 160

Índice General

Semana 1…………………………………………………… Manipulación de datos en SQL 2008

Semana 2……………………... Procedimientos Almacenados I

Semana 3……………………… Procedimientos Almacenados II Parámetros de entrada y salida

Semana 4……………………… Procedimientos almacenados III Vistas

Semana 5………………………………………… Practica I

Semana 6………………………………………… Acceso a datos con ADO NET

Semana 7- 8……………………………………… Ado – Net con Procedimientos Almacenados

Semana 9………………………………………… Practica II

Semana 10……………………………………….. Examen Parcial

Semana 11…………………………………......... Clases y creación de librerías

Semana 12……………………………………….. LIBRERÍA DE CLASES CON BD

Semana 13 – 14………………………………….. Aplicaciones con 3 Capas

Semana 15……………………………………….. Practica III

Semana 16……………………………………….. CREACIÓN DE REPORTES

Semana 17……………………………………….. CREACIÓN DE SUB REPORTES

Semana 18 ………………………………………. PRESENTACION DE TRABAJO FINAL

Semana 19……………………………………….. Examen Final

Semana 20……………………………………….. Examen Sustitutorio

Ing. Alberto Moreno C.


Semana 1 Manipulación de datos en SQL 2005
La sentencia Select

La sentencia Select es una sentencia SQL, que pertenece al conjunto del


Lenguaje de
Manipulación de Datos, y que sirve para recuperar registros de una o varias
tablas, de una o varias bases de datos. Su sintaxis es la siguiente:

SELECT <atributos> FROM <tablas>


[WHERE <condicion>]
[GROUP BY <atributos>]
[HAVING <condición>]
[ORDER BY <atributos>]

Donde las mayúsculas representan palabras reservadas, y lo encerrado


entre corchetes es opcional, puede ser omitido. Una vez vista la anterior
forma de representación, vamos a detenernos en la sintaxis de la sentencia
Select. Se compone de tres partes:

SELECT <atributos>: permite hacer una proyección de las tablas, es


decir, seleccionar los campos que deseamos recuperar de la base de
datos, separados por comas. Si se especifica el símbolo *, se
obtendrán todos los campos de la tabla.

FROM <tablas>: permite especificar la tabla de la cual se desean


obtener los datos. Si se especifica más de una tabla, éstas irán
separadas por comas.

WHERE <condición>: permite establecer una condición de


recuperación de las filas de la/s tabla/s. Sólo se obtendrán aquellas
consultas que verifiquen dicha condición, que será opcional. En el
caso de que se omita esta parte, se recuperarán todas las filas.

GROUP BY <atributos>: permite establecer una selección de campos


cuando se utilizan funciones escalares o de conteo (ya se verá más
adelante lo que significa.

HAVING <condición>: establece una condición para los atributos


obtenidos como resultado de la aplicación de funciones escalares.

ORDER BY <atributos>: permite obtener el resultado de la consulta


ordenado por los atributos especificados.

En el caso de que se especifiquen varias tablas, en la cláusula FROM, será


conveniente denotar los campos de la cláusula SELECT precedidos por el
nombre de la tabla donde se encuentra y un punto, para que, en el caso de
que dicho campo exista en más de una tabla, se sepa en cada momento a
cuál de ellos nos estamos refiriendo, evitando en este caso el problema de
ambigüedad.

Si por ejemplo, deseamos obtener todos los valores de los atributos title y
price de la tabla titles, deberíamos escribir el siguiente Código fuente.

SELECT title, price FROM titles

De esta manera, obtenemos todas las filas, ya que no hemos dado ninguna
condición, de la tabla titles (especificada en la cláusula FROM), de las cuales
sólo visualizaremos los valores de los atributos title y price (especificados
en la cláusula SELECT). Si por el contrario, deseamos obtener todos los
atributos de dicha tabla, deberíamos escribir el siguiente Código fuente.

SELECT * FROM titles

Puesto que hemos especificado el literal * dentro de la cláusula SELECT, la


anterior sentencia nos devuelve todos los atributos de todas las filas de la
tabla titles, es decir, nos devuelve toda la información almacenada en ella.

La cláusula Where

La forma de usar el Transact SQL para realizar consultas realizando una


proyección horizontal (es decir, seleccionando las filas), es mediante la
opción WHERE. A continuación de esta palabra reservada, se debe
especificar la condición lógica que se debe evaluar, para obtener aquellas
filas que la cumplen.

Para expresar una expresión lógica se pueden emplear cualquiera de los


operadores de
Transact SQL cuyo resultado devuelva un valor lógico, aunque también se
pueden utilizar operadores de cadena. Estos operadores serán vistos en
detalle en el siguiente capítulo, pero básicamente son los siguientes:

>: Compara si una expresión es mayor que otra

<: Compara si una expresión es menor que otra

>=: compara si una expresión es mayor o igual que otra

<=: compara si una expresión es menor o igual que otra


<>: Compara si una expresión es distinta que otra
LIKE: compara todas las cadenas que verifican un patrón de búsqueda

NOT LIKE: compara todas las cadenas que no verifican un patrón de


búsqueda
BETWEEN: compara todas las cadenas que están comprendidas en un rango
de valores

IN: compara todas las cadenas que están contenidas en una lista Por
ejemplo, si queremos obtener los títulos cuyos derechos de autor sean
mayores del 10 %, digitaremos el siguiente Código.

SELECT * FROM titleauthor WHERE


royaltyper > 10

De la misma forma, si queremos obtener todos los títulos cuyo precio no


supere los 2$, ejecutaremos el Código siguiente.

SELECT * FROM titles WHERE price <= 2

Si queremos obtener el nombre de los autores cuya primera letra este


comprendida entre la C y la H, y que a continuación tenga el literal 'urry',
ejecutamos el Código siguiente.

SELECT au_fname FROM authors WHERE au_fname LIKE '[C-


H]urry'

O si queremos obtener la ciudad de todos los autores, que se corresponda


con San Francisco o con Salt Lake City, ejecutaremos el Código siguiente.

SELECT city FROM authors WHERE city in ('San Francisco','Salt Lake City')

Si se desea conocer todos los títulos cuyo precio oscila entre 1 y 2 dólares,
ejecutaremos el Código siguiente.

SELECT title FROM titles WHERE price


BETWEEN 1 AND 2
La cláusula Group By

La cláusula GROUP BY agrupa, como su propio nombre indica, filas que


tienen el mismo valor para un atributo, en grupos distintos. Por ejemplo, si
queremos obtener el apellido de todos los autores, ejecutamos el Código
siguiente.
SELECT au_lname FROM autors
Si nos fijamos en el resultado obtenido, tenemos que existen dos autores,
cuyo apellido es el mismo, Ringer. Por lo tanto, se muestran dos filas iguales
para este apellido, una por cada autor que se apellida Ringer. Supongamos
ahora, que lo único que nos interesa es obtener todos los apellidos que sean
distintos. Para ello deberemos agrupar los autores cuyo apellido sea el
mismo en un único grupo, y a continuación mostrar los grupos, en lugar de
las filas. Con esto garantizamos que sólo se mostrará una fila por cada
apellido distinto, ya que sólo mostramos una fila del grupo, en lugar de
todas. Esto que parece tan complicado, se resume en una sentencia, usando
la cláusula GROUP BY.

SELECT au_lname FROM authors GROUP BY


au_lname

En ella, lo que se hace es simplemente un select, pero no de las filas de la


tabla, sino de los grupos obtenidos a partir de la cláusula GROUP BY.
Puesto que deseamos agrupar o el apellido, detrás de esta cláusula se debe
determinar el atributo au_lname, garantizando así que todas las filas cuyo
valor de este atributo sea igual, irán al mismo grupo.

La cláusula Having

La cláusula HAVING es similar a la cláusula WHERE, salvo que aquella se


usa como condición de búsqueda cuando se especifica la cláusula GROUP
BY. Por lo tanto el funcionamiento es similar al ya visto para WHERE. La
única diferencia es que HAVING se aplica a condiciones de grupo. Por
ejemplo, si dada la anterior sentencia de agrupación, deseamos que sólo se
muestre el autor cuyo apellido sea Ringer, ejecutaremos el Código siguiente.

SELECT au_lname FROM authors GROUP BY au_lname HAVING au_lname =


'Ringer'

La cláusula Order By

La cláusula ORDER BY determina el orden de visualización de las filas


obtenidas en la sentencia SELECT. A continuación de dicha palabra
reservada, se debe especificar el atributo o los atributos por los cuales se
ordenará el resultado obtenido en la consulta.

Por ejemplo, si queremos mostrar el nombre y apellido de todos los autores


de nuestra base de datos pubs, bastará con ejecutar la sentencia que
aparece en el siguiente Código fuente donde el atributo especificado a
continuación de la cláusula ORDER BY, es decir, au_lname, determina cómo
se ordenarán las filas que se mostrarán, en este caso alfabéticamente por el
apellido.

SELECT au_lname, au_fname FROM authors ORDER BY au_lname


Funciones escalares para Select

Entendemos por funciones escalares, todas aquellas que permiten realizar


operaciones de conteo de filas, suma de atributos, obtención de medias, etc.
Dichas funciones se especifican a continuación de la palabra reservada
SELECT. Las funciones que soporta la sentencia SELECT en el Transact SQL
son las siguientes:

SUM: Realiza una suma acumulativa de un atributo para todas las filas
accedidas mediante una consulta SQL.
Por ejemplo, supongamos que tenemos una tabla de pedidos, con los
atributos cod_cliente, cod_material y precio. Si queremos obtener la suma
del precio de todos los pedidos almacenados, bastará con realizar una
función de tipo SUM, como la que vemos en el Código siguiente.

SELECT sum(precio) FROM pedido

La anterior consulta obtiene la suma del precio para todas las filas de la
tabla pedido, ya que no hemos especificado ninguna condición en la
cláusula WHERE.
Si ahora queremos obtener la suma total de todos los pedidos realizados por
el cliente cuyo código es "R12CE", debemos realizar la misma consulta, pero
especificando una condición para obtener únicamente las filas cuyo
cod_cliente es "R12CE":

SELECT sum(precio) FROM pedido WHERE cod_cliente =


"R12CE"

COUNT: Cuenta todas las filas de las tablas accedidas mediante una
consulta SQL.
Por ejemplo, si tenemos una tabla cliente, con todos los clientes de una
empresa de servicios, con los atributos DNI, nombre, apellidos, dirección y
población, y queremos saber todos los clientes que tenemos, deberemos
realizar un count, para obtener todas el número de filas de la tabla
ejecutamos el Código siguiente.

SELECT count(DNI) FROM cliente

En el anterior ejemplo, al existir el mismo número de filas, sea cual sea el


atributo que seleccionemos, podríamos haber escogido cualquier otro. En
general, se suele escribir el siguiente Código fuente.

SELECT count(*) FROM cliente


Si ahora queremos saber el número de clientes que viven en Madrid,
deberemos realizar un conteo de todas las filas con la condición de que el
atributo población sea Madrid.

SELECT count(*) FROM cliente WHERE poblacion = "Madrid"

Si queremos saber cuántos títulos tenemos en nuestra base de datos,


digitaremos el siguiente Código fuente.

SELECT count(*) FROM titles

Y si queremos saber cuántos títulos tenemos, cuyo precio es mayor de 20 $,


deberemos realizar lo mismo, pero especificando esta condición en la
cláusula
WHERE. Al resultado de la búsqueda le llamaremos caros.

SELECT count(*) caros FROM titles WHERE price > 20

AVG: Realiza una media aritmética de los atributos para todas las filas
accedidas mediante la consulta SQL.
Si por ejemplo tenemos una tabla de materiales, con los atributos
cod_material, descripción, precio y cantidad_pedida, y queremos saber la
cantidad media pedida de todos los materiales, deberemos realizar una
media aritmética, teniendo en cuenta todas las filas de la tabla:

SELECT avg(cantidad_pedida) FROM material

La anterior sentencia, internamente, realiza primero una suma de todos los


valores, y a continuación la divide por el número total de filas accedidas, es
decir, realiza la media aritmética.
Volviendo a nuestra cultural base de datos pubs, si queremos saber la media
del precio de los títulos que tenemos disponibles, deberemos ejecutar el
Código siguiente.

SELECT avg(price) media FROM titles

MAX: Obtiene el máximo valor del atributo especificado, de entre


todas las filas seleccionadas mediante la sentencia SQL.
Supóngase, por ejemplo, que tenemos la tabla de materiales descrita
anteriormente. Si queremos saber el material más caro, deberemos realizar
un SELECT con la cláusula Max, que obtenga el mayor valor para el atributo
precio de todas las filas.
Para nuestro ejemplo, si queremos saber cuál es el libro más caro,
ejecutaremos el Código siguiente.

SELECT max(price) caro FROM titles

MIN: Obtiene el mínimo valor del atributo especificado, de entre todas


las filas seleccionadas mediante la sentencia SQL. Si queremos saber
cuál es el libro más barato de nuestra base de datos, deberemos
ejecutar el Código siguiente.

SELECT min(price) barato FROM titles

La sentencia Insert

La otra gran sentencia de manipulación de datos es INSERT. Si SELECT nos


permitía recuperar datos, INSERT nos va a permitir añadirlos al esquema, es
decir, con esta sentencia podemos añadir información a la base de datos.
Recordemos que estamos en el modelo relacional, por lo que la información
se añadirá a una tabla en forma de filas. Si sólo queremos insertar un valor
para un atributo, el resto de los de la tabla deberá contener el valor nulo
(NULL). Sin embargo, habrá ciertas ocasiones en que esto no será posible,
cuando el atributo esté definido como NO NULO, en cuyo caso deberemos
especificar un valor para éste. La sintaxis de esta sentencia es:

INSERT INTO tabla (atributos) VALUES (valores)

Donde tabla especifica la tabla en la cual se añadirá la fila, atributos es una


lista de atributos separados por comas que determinan los atributos para los
cuales se darán valores, y que se darán para estos atributos, separados por
comas. Por ejemplo, si queremos añadir un nuevo autor a nuestra base de
datos, deberemos ejecutar el Código siguiente.

INSERT INTO authors (au_id, au_lname, au_fname) VALUES ('409-99-9876', 'Pepe',


'Perez')

Destacar que si el valor a introducir es alfanumérico, deberá ir encerrado


entre comillas, mientras que si es numérico no. Pues bien, si ejecutamos la
anterior sentencia, tenemos el siguiente error:

Server: Msg 515, Level 16, State 2, Line 1


Cannot insert the value NULL into column 'contract', table
'pubs.dbo.authors'; column does not allow nulls. INSERT fails. The
statement has been terminated.
La razón es que no hemos dado valor al atributo contract, que ha sido
definido como no nulo.
Por lo tanto, rectificamos el Código anterior, para dar un valor al campo
contract.

INSERT INTO authors (au_id, au_fname, au_lname, contract) VALUES ('409-99-9876', 'Pepe',
'Perez', 1)

El valor que hemos dado al atributo contract es un 1, ya que está definido


como tipo binario, es decir, sólo admite dos valores, 0 para especificar que
no está contratado, y 1 para el caso contrario.
Al ejecutar esta sentencia, obtenemos como resultado

(1 row(s) affected)

Lo que nos indica que la fila se ha insertado con éxito. Podemos


comprobarlo ejecutando un SELECT sobre dicha fila.

SELECT * FROM authors WHERE au_id = '409-99-9876'

La sentencia Update

El objetivo de la sentencia UPDATE es actualizar los valores de una o varias


filas de una tabla, sin necesidad de borrarla e insertarla de nuevo. La sintaxis
es la siguiente:

UPDATE tabla SET atributo1 = valor1, atributo2 = valor2,... WHERE Condición

Donde tabla especifica la tabla donde se encuentran las filas que queremos
actualizar, condición especifica la condición que se debe cumplir para
actualizar las filas, y lo que viene a continuación de SET especifica la
asignación de los nuevos valores a los atributos. Por lo tanto se actualizarán
todas las filas que cumplan la condición especificada. Si queremos cambiar
el nombre al autor que hemos insertado en el anterior apartado, deberemos
escribir el Código siguiente.

UPDATE authors SET au_fname = 'Pepito' WHERE au_id = '409-


99-9876'

Lo que hacemos con la anterior sentencia es buscar el autor insertado, por


el código (condición where), y a continuación actualizar el valor del atributo
nombre de la fila obtenida a Pepito. Si ejecutamos la anterior sentencia,
obtenemos el resultado: (1 row(s) affected) lo que quiere decir que la fila ha
sido actualizada con éxito.
Podemos comprobarlo ejecutando el Código.

SELECT * FROM authors WHERE au_id = '409-99-9876'

La sentencia Delete

El objeto de la sentencia DELETE es el de borrar filas de una tabla. Para


poder borrar filas en una tabla se deben cumplir las condiciones de
seguridad determinadas por el administrador, y deben de cumplirse también
las reglas de integridad referencial. La sintaxis es la siguiente:

DELETE FROM tabla WHERE condición

Donde tabla especifica la tabla sobre la cual queremos borrar las filas, y
condición especifica la condición que se debe cumplir para que se borren
las filas. Si omitimos la condición, se borrarán todas las filas de la tabla, es
decir, la sentencia que aparece en el Código siguiente borra todas las filas
de la tabla authors.

DELETE authors

Por ejemplo, si queremos borrar la fila que hemos creado en la tabla autores,
deberemos ejecutar el siguiente Código fuente. Obteniendo el siguiente
resultado:

(1 row(s) affected)

DELETE FROM authors WHERE au_id = '409-99-


9876'

Lo que viene a decir que la fila se ha borrado. Para comprobarlo, ejecutamos


la sentencia que muestra el Código siguiente. cuyo resultado es: (0 row(s)
affected), lo que quiere decir que la fila no se encuentra en la tabla, es decir,
ha sido borrada.

SELECT * FROM authors WHERE au_id = '409-99-9876'

Sentencias condicionales

Las sentencias condicionales son aquellas que permiten discriminar entre


diversas sentencias, según se cumpla el valor de una expresión lógica.
Existen dos tipos de sentencias condicionales. La primera de ellas tiene la
siguiente sintaxis:
IF expresion_logica
sentencia1
[ELSE sentencia2]

La sentencia 1 sólo se ejecutará si el resultado de la evaluación de la


expresión lógica es verdadero. En otro caso, se ejecutará la sentencia 2,
correspondiente a la parte ELSE (opcional). Si se desea especificar un
conjunto de sentencias, en lugar de una sola, éstas deberán ir encerradas
entre las palabras reservadas BEGIN y END. Si deseamos obtener los títulos
almacenados cuando éstos superen las 10 unidades, y el número de ellos
cuando no lo superen, ejecutaremos el Código siguiente.

IF (SELECT count(*) FROM titles) > 10


BEGIN
SELECT title FROM titles
END
ELSE
BEGIN
SELECT count(*) FROM titles
END

En definitiva, la sentencia SELECT title FROM titles sólo se ejecuta cuando


se cumple la condición (SELECT count(*) FROM titles) > 10. En otro caso, se
ejecutará la rama ELSE, que devuelve el número de títulos almacenados en
la tabla titles.

Otra forma de ejecutar sentencias de forma condicional, corresponde a la


sentencia CASE. La sintaxis es la siguiente:

CASE expresion1
WHEN expresion2 THEN resultado1
WHEN expresion3 THEN resultado2
...
[ELSE resultado3]

La anterior sentencia compara la expresión 1, con el resto de expresiones


especificadas a continuación de la palabra reservada WHEN. Si alguna de
estas expresiones se cumple, se devolverá el resultado correspondiente
especificado a continuación de la palabra reservada THEN. Si llegados al
final, no ha verificado ninguna de las expresiones, se devolverá el resultado
especificado a continuación del ELSE.

Por ejemplo, si queremos saber el nombre de los estados de los autores, en


lugar de las iníciales, podemos ejecutar el siguiente Código fuente.
SELECT state = CASE state
WHEN 'CA' THEN 'California'
WHEN 'OR' THEN 'Oregon'
ELSE 'Otro'
END
FROM authors

En este caso se comprueba el valor del atributo state, y si este es igual a CA,
se devolverá California, si es OR se devolverá Oregon, y en otro caso se
devolverá el literal 'Otro'.

SELECCIÓN DE TODAS LAS COLUMNAS

A veces es conveniente visualizar el contenido de todas las


columnas de una tabla. Esto puede ser particularmente útil cuando uno va a
utilizar por primera vez una base de datos y desea obtener una rápida
comprensión de su estructura y de los datos que contiene. Por
conveniencia, SQL permite utilizar un asterisco (*) en lugar de la lista de
selección como abreviatura de “todas las columnas”.

Muestra todos los datos de la Tabla OFICINAS.

SELECT * FROM OFICINAS

FILAS DUPLICADAS (DINSTINCT)

Si una consulta incluye la clave primaria de una tabla en su lista de


selección, entonces cada fila de resultados será única (ya que la clave
primaria tiene un valor diferente en cada fila). El DINSTINCT hace que el valor
de las filas no se repita

Listar los años de las facturas, pero los años no se deben de repetir

select distinct year(OrderDate) as Año from orders

El resultado será

RESUMEN
La sentencia SELECT se utiliza para expresar una consulta SQL.
Toda sentencia SELECT produce una tabla de resultados que contienen una
o más columnas y cero o más filas.
La cláusula FROM especifica la(s) tabla(s) que contiene(n) los datos a
recuperar por una consulta.

La cláusula SELECT especifica la(s) columna(s) de datos a incluir en


los resultados de la consulta, que pueden ser columnas de datos de la base
de datos o columnas calculadas.

La cláusula WHERE selecciona las filas a incluir en los resultados


aplicando una condición de búsqueda a las filas de la base de datos.

Una condición de búsqueda puede seleccionar filas mediante


comparación de valores, mediante comparación de un valor con un rango o
un grupo de valores, por correspondencia con un patrón de cadena o por
comprobación de valores NULL.

Las condiciones de búsqueda simples pueden combinarse mediante


AND, OR y NOT para formar condiciones de búsqueda más complejas.

La cláusula ORDER BY especifica que los resultados de la consulta


deben ser ordenados en sentido ascendente o descendente, basándose en
los valores de una o más columnas.

Las consultas resumen utilizan funciones de columna SQL para


condensar una columna de valores en un único valor que resuma la
columna.

Las funciones de columna pueden calcular el promedio, suma, el


valor mínimo y máximo de una columna, contar el número de valores de
datos de una columna o contar el número de filas de los resultados de la
consulta.

Una consulta resumen sin una cláusula GROUP BY genera una única
fila de resultados, resumiendo todas las filas de una tablas o de un conjunto
compuestos de tablas.

Una consulta resumen con una cláusula GROUP BY genera múltiples


filas de resultados.
Modelo de Base de Datos para el desarrollo de las Practicas

Ejercicios Prácticos
Usar la BD Ventas

Se desea saber cuántas veces a facturado cada Empleado, mostrar los


campos Cod_Emp,nombre,[Facturas Emitidas].

Mostrara todas las Facturas pares emitida en los meses impares por
empleado más antiguo, mostrar los campos Num_Fact,Sub_Total,Igv,Total,
[meses en letras].

Mostrar los 2 Productos más vendidos de todas las facturas.

Mostrar los clientes cuyo total de facturación sea mayor 1200, los campos a
mostrar son Cod_cli,nom_cli,[Total Facturado].

Mostrar todas las facturas emitidas y su cantidad de productos vendidos de


todos los empleados cuya antiguedad de trabajo sea mayor a 14 años. Los
campos a mostrar son Num_fact,Sub_total,igv,total,[Cantida de productos].

Mostrar los productos cuya segunda letra inicie con 'a' y su stock sea mayor
a 300.

Mostrar los 3 productos más vendidos de todas las facturas en entre el mes
enero y marzo en letras.

Mostrar las facturas impares emitidas al cliente 'C0003'.

Mostrar las facturas pares emitidas por el empleado menos antiguo.

Mostrar el Empleado que no ha emitido ningún tipo de facturación.

Mostrar las 2 facturas con mayor y menor total, los campos a mostrar son
num_fact,Sub_total,igv,total.

Mostrar la antiguedad laboral de cada empleado, los campos a mostrar son


Cod_Emp, Nombre, Fecha_ing,[Antiguedad Laboral].

Usando el Charindex(expresion1,expresion2[,posicion inicial]) devuelve la


posición inicial de la expresión especificada en una cadena de caracteres.
Listar solo los nombres de los clientes, usando Charindex.
nom_cli Nombres
------------------------------------ ------------------
Gianmarco, Sanchez Zavala Gianmarco
Listar solo los apellidos materno y paterno de los clientes.
Nom_cli Apellidos
-------------------------------------- ------------------------------
Gianmarco, Sanchez Zavala Sanchez Zavala
Listar solo el apellido paterno de los Clientes.
Nom_Cli Apellido Paterno
------------------------------ ------------------------------
Gianmarco, Sanchez Zavala Sanchez
Mostrar los productos con mayor y menor cantidad vendida de todas las
facturas emitidas.
Cod_Prod descrip precio stock
-------- ------------------------------ ------------------------------------------------- ------
P0001 Leche evaporada 2.0 23
P0003 Azucar 1.8 465

Ejercicios Propuestos
Usar la BD Ventas

Mostrar todos los productos que no posean un comentario en el campo


TxMtvEli.

Mostrar todas las columnas de la tabla detalle ordenado por cod_prod en


forma descendente y num_fact en forma ascendente.

Mostrar todas las facturas excepto la factura '000002'.

Mostrar las facturas que se encuentran en el rango '000004' hasta el numero


'000010' mostrar en el resultado solo los campos
Num_fact,Sub_Total,igv,total.

Mostrar solo las siguientes facturas '000002','000007','000009','000012', en el


cual incluya en el resultado los campos Num_Fact,Cod_Cli,Cod_Emp,Total.

Mostrar todas las Facturas Excepto las siguientes facturas '000005','000003'.

Mostrar los Clientes cuyo nombre inicien con la letra 'C' o la letra 'A'.

Mostrar los Clientes cuyo nombres termine con letra 'A' y 'O'

LIKE=> Determina si una cadena de caracteres dada coincide o no con un


determinado modelo. Un modelo puede incluir caracteres normales y
carácter comodín. % carácter comodín.

Sintaxis: match_expression [ NOT ] LIKE pattern [ ESCAPE


escape_character ]

Usando Like mostrar los nombres de los empleados cuyo nombre inicie con
la letra 'M'.
Usando Like mostrar los nombres de los empleados cuya segunda letra de
su nombre inicie con la letra 'A'.

Usando Like, mostrar los Empleados cuyo nombre termine con la letra Z.

Usando Like mostrar los Empleados cuyo apellido paterno inicie con la letra
'S' Sabiendo que el nombre tiene este formato Julio, Saavedra Rondon.

Usando Like mostrar todos los empleados excepto los empleados cuyo
apellido paterno inicie con la letra „A‟.

Usando Like mostrar todos los Empleados cuyo nombre no inicie con la letra
C ó la letra M.

Mostrar todos los productos que fueron ingresados el año 1994.

Mostrar todas las facturas que fueron registrados en Enero de 1997.

Mostrar el número de factura, el día Facturado en letras, y el Mes facturado


en letras de la tabla facturas. El resultado será así:

Num_Fact Dia Mes


-------- ------------------------------ ------------------------------
000001 Martes Enero
000002 Viernes Enero

Mostrar el número de Factura, y la fecha completa en cadena de caracteres.


El resultado será así:

Num_Fact Fecha
-------- ----------------------------------------------
000001 Lima Martes 2 de Enero de 1996
000002 Lima Viernes 5 de Enero de 1996

Mostrar el código del empleado, la edad del empleado y la fecha de


nacimiento de la tabla empleado.

Mostrar los productos cuya primera letra inicie con 'A', el stock sea mayor a
100 y la fecha de ingreso sea el año 1994.

Mostrar el detalle de los productos vendidos de la Factura Nro.'000001', los


campos a mostrar son Num_Fact,Descrip,precio,cant,total=(precio * cant).

Mostrar el nombre y precio más alto de la tabla producto.


Mostrar el promedio, él máximo y el mínimo del campo precio de la tabla
producto.
Mostrar cuantos años se han emitido las facturas a la fecha, mostrar el
campo Num_fact, Fecha, [Total de años].

Mostrar el total de productos vendidos de la Factura Nro.'000001'.

Mostrar la cantidad de facturas emitidas por cada cliente, mostrar los


campos cod_cli,[Cantidad de facturas].

Mostrar los clientes que hayan tenido más de 10 facturas emitidas, los
campos a mostrar son Nom_Cli,[Cantidad de Facturas].

Mostrar todos los productos vendidos por un año de venta. Campos a


mostrar cod_prod,descrip,[cantidad de productos].

Subconsultas:
Una subconsulta es una consulta SELECT que devuelve un valor único y
está anidada en una instrucción SELECT, INSERT, UPDATE o DELETE, o
dentro de otra subconsulta. Una subconsulta se puede utilizar en cualquier
parte en la que se permita una expresión.

Usando subconsultas, mostrar todas las columnas del producto más caro.
Mostrar los 3 productos más caros, los campos a mostrar son cod_prod,
descrip, precio.

Mostrar las facturas del Empleado más antiguo, los campos a mostrar son
Num_Fact,Sub_total,igv,total.

Mostrar los clientes que no han sido facturado.

Mostrar los productos que no se han vendido.

Mostrar la Actividad de la factura por medio del campo FgEli que es de tipo
bit(0,1), si es 0 "Emitida",si es 1 "Cancelado", los campos a mostrar son
num_fact,Sub_total,igv,total, [Estado de Factura].
Usando el Charindex(expresion1,expresion2[,posicion inicial]) devuelve la
posición inicial de la expresión especificada en una cadena de caracteres.

Mostrar todos los clientes cuyo apellido inicie con la letra 'A'

Cod_Cli nom_cli
--------- ------------------------------
C0010 Williams, Anderson Lorin
Semana 2 Procedimientos Almacenados I
Vimos que SQL Server ofrece dos alternativas para asegurar la integridad de
datos, la integridad:
DECLARATIVA, mediante el uso de restricciones (constraints), valores
predeterminados (defaults) y reglas (rules) y

PROCEDIMENTAL, mediante la implementación de procedimientos


almacenados y desencadenadores (triggers).

Nos detendremos ahora en procedimientos almacenados


Un procedimiento almacenado es un conjunto de instrucciones a las que se
les da un nombre, que se almacena en el servidor. Permiten encapsular
tareas repetitivas.

SQL Server permite los siguientes tipos de procedimientos almacenados:


del sistema: están almacenados en la base de datos "master" y llevan
el prefijo "sp_"; permiten recuperar información de las tablas del
sistema y pueden ejecutarse en cualquier base de datos.

locales: los crea el usuario.

temporales: pueden ser locales, cuyos nombres comienzan con un


signo numeral (#), o globales, cuyos nombres comienzan con 2 signos
numeral (##). Los procedimientos almacenados temporales locales
están disponibles en la sesión de un solo usuario y se eliminan
automáticamente al finalizar la sesión; los globales están disponibles
en las sesiones de todos los usuarios.

extendidos: se implementan como bibliotecas de vínculos dinámicos


(DLL, Dynamic-Link Libraries), se ejecutan fuera del entorno de SQL
Server. Generalmente llevan el prefijo "xp_". No los estudiaremos.

Al crear un procedimiento almacenado, las instrucciones que contiene se


analizan para verificar si son correctas sintácticamente. Si no se detectan
errores, SQL Server guarda el nombre del procedimiento almacenado en la
tabla del sistema "sysobjects" y su contenido en la tabla del sistema
"syscomments" en la base de datos activa. Si se encuentra algún error, no
se crea.

Un procedimiento almacenado puede hacer referencia a objetos que no


existen al momento de crearlo. Los objetos deben existir cuando se ejecute
el procedimiento almacenado.
Ventajas:
comparten la lógica de la aplicación con las otras aplicaciones, con lo
cual el acceso y las modificaciones de los datos se hacen en un solo
sitio.
permiten realizar todas las operaciones que los usuarios necesitan
evitando que tengan acceso directo a las tablas.

reducen el tráfico de red; en vez de enviar muchas instrucciones, los


usuarios realizan operaciones enviando una única instrucción, lo cual
disminuye el número de solicitudes entre el cliente y el servidor.

Creación, modificación y eliminación de Store Procedure

Los procedimientos almacenados se crean en la base de datos seleccionada,


excepto los procedimientos almacenados temporales, que se crean en la
base de datos "tempdb".

En primer lugar se deben tipear y probar las instrucciones que se incluyen


en el procedimiento almacenado, luego, si se obtiene el resultado esperado,
se crea el procedimiento.

Los procedimientos almacenados pueden hacer referencia a tablas, vistas, a


funciones definidas por el usuario, a otros procedimientos almacenados y a
tablas temporales.

Un procedimiento almacenado pueden incluir cualquier cantidad y tipo de


instrucciones, excepto:
Create default, create procedure, create rule, create trigger y create view.
Se pueden crear otros objetos (por ejemplo índices, tablas), en tal caso
deben especificar el nombre del propietario; se pueden realizar inserciones,
actualizaciones, eliminaciones, etc.

Si un procedimiento almacenado crea una tabla temporal, dicha tabla sólo


existe dentro del procedimiento y desaparece al finalizar el mismo. Lo mismo
sucede con las variables.

Hemos empleado varias veces procedimientos almacenados del sistema


("sp_help", "sp_helpconstraint", etc.), ahora aprenderemos a crear nuestros
propios procedimientos almacenados.

Para crear un procedimiento almacenado empleamos la instrucción "create


procedure".

La sintaxis básica parcial es:


Create procedure NOMBREPROCEDIMIENTO
as INSTRUCCIONES a realizar;
Para diferenciar los procedimientos almacenados del sistema de los
procedimientos almacenados locales use un prefijo diferente a "sp_" cuando
les el nombre.
Con las siguientes instrucciones creamos un procedimiento almacenado
llamado "pa_libros_limite_stock" que muestra todos los libros de los cuales
hay menos de 10 disponibles:

Create proc pa_libros_limite_stock


as
select *from libros
where cantidad <=10;

Entonces, creamos un procedimiento almacenado colocando "create


procedure" (o "create proc", que es la forma abreviada), luego el nombre del
procedimiento y seguido de "as" las sentencias que definen el
procedimiento.

"create procedure" debe ser la primera sentencia de un lote.

Para ejecutar el procedimiento almacenado creado anteriormente tipeamos:


exec pa_libros_limite_stock;
Entonces, para ejecutar un procedimiento almacenado colocamos "execute"
(o "exec") seguido del nombre del procedimiento.

Cuando realizamos un ejercicio nuevo, siempre realizamos las mismas


tareas: eliminamos la tabla si existe, la creamos y luego ingresamos algunos
registros. Podemos crear un procedimiento almacenado que contenga todas
estas instrucciones:

Create procedure pa_crear_libros


as
if object_id('libros')is not null
drop table libros;
create table libros(
codigo int identity,
titulo varchar(40),
autor varchar(30),
editorial varchar(20),
precio decimal(5,2),
primary key(codigo)
);
insert into libros values('Uno','Richard Bach','Planeta',15);
insert into libros values('Ilusiones','Richard Bach','Planeta',18);
insert into libros values('El aleph','Borges','Emece',25);
insert into libros values('Aprenda PHP','Mario Molina','Nuevo siglo',45);
insert into libros values('Matemática estas ahi','Paenza','Nuevo siglo',12);
insert into libros values('Java en 10 minutos','Mario Molina','Paidos',35);
Y luego lo ejecutamos cada vez que comenzamos un nuevo ejercicio y así
evitamos tipear tantas sentencias:
exec pa_crear_libros;

Los procedimientos almacenados se eliminan con "drop procedure".

Sintaxis:
drop procedure NOMBREPROCEDIMIENTO;

Eliminamos el procedimiento almacenado llamado "pa_libros_autor":

drop procedure pa_libros_autor;

Si el procedimiento que queremos eliminar no existe, aparece un mensaje de


error, para evitarlo, podemos emplear esta sintaxis:

if object_id('NOMBREPROCEDIMIENTO') is not null


drop procedure NOMBREPROCEDIMIENTO;

Eliminamos, si existe, el procedimiento "pa_libros_autor", si no existe,


mostramos un mensaje:

if object_id('pa_libros_autor') is not null


drop procedure pa_libros_autor
else
select 'No existe el procedimiento "pa_libros_autor"';
"drop procedure" puede abreviarse con "drop proc".

Se recomienda ejecutar el procedimiento almacenado del sistema


"sp_depends" para ver si algún objeto depende del procedimiento que
deseamos eliminar.

Podemos eliminar una tabla de la cual dependa un procedimiento, SQL


Server lo permite, pero luego, al ejecutar el procedimiento, aparecerá un
mensaje de error porque la tabla referenciada no existe.

Aplicaciones prácticas

 Problema:

Trabajamos con la tabla "libros" de una base de datos llamada librería.

--Eliminamos la tabla si existe y la creamos nuevamente:


if object_id('libros') is not null
drop table libros;
Create table libros(
codigo int identity,
titulo varchar(40),
autor varchar(30),
editorial varchar(20),
precio decimal(5,2),
primary key(codigo)
);

--Ingresamos algunos registros:


insert into libros values ('Uno','Richard Bach','Planeta',15);
insert into libros values ('Ilusiones','Richard Bach','Planeta',12);
insert into libros values ('El aleph','Borges','Emece',25);
insert into libros values ('Aprenda PHP','Mario Molina','Nuevo siglo',50);
insert into libros values ('Matematica estas ahi','Paenza','Nuevo siglo',18);
insert into libros values ('Puente al infinito','Bach
Richard','Sudamericana',14);
insert into libros values ('Antología','J. L. Borges','Paidos',24);
insert into libros values ('Java en 10 minutos','Mario Molina','Siglo XXI',45);
insert into libros values ('Cervantes y el quijote','Borges-
Casares','Planeta',34);

--Eliminamos el procedimiento almacenado "pa_libros_autor" si existe:


if object_id('pa_libros_autor') is not null
drop procedure pa_libros_autor;

--Creamos el procedimiento para que reciba el nombre de un autor y muestre


todos los libros del --autor solicitado:
Create procedure pa_libros_autor
@autor varchar(30)
as
select titulo, editorial,precio
from libros
where autor= @autor;
--Ejecutamos el procedimiento:
exec pa_libros_autor 'Richard Bach';

--Empleamos la otra sintaxis (por nombre) y pasamos otro valor:


exec pa_libros_autor @autor='Borges';

--Eliminamos, si existe, el procedimiento "pa_libros_autor_editorial":


if object_id('pa_libros_autor_editorial') is not null
drop procedure pa_libros_autor_editorial;

--Creamos un procedimiento "pa_libros_autor_editorial" que recibe 2


parámetros, el nombre de un autor y el de una editorial:
Create procedure pa_libros_autor_editorial
@autor varchar(30),
@editorial varchar(20)
as
select titulo, precio
from libros
where autor= @autor and
editorial=@editorial;

--Ejecutamos el procedimiento enviando los parámetros por posición:


exec pa_libros_autor_editorial 'Richard Bach','Planeta';

--Ejecutamos el procedimiento enviando otros valores y lo hacemos por


nombre:
exec pa_libros_autor_editorial @autor='Borges',@editorial='Emece';

--Si ejecutamos el procedimiento omitiendo los parámetros, aparecerá un


mensaje de error.
--Eliminamos, si existe, el procedimiento "pa_libros_autor_editorial2":
if object_id('pa_libros_autor_editorial2') is not null
drop procedure pa_libros_autor_editorial2;
--Creamos el procedimiento almacenado "pa_libros_autor_editorial2" que
recibe los --mismos parámetros, esta vez definimos valores por defecto para
cada parámetro:
Create procedure pa_libros_autor_editorial2
@autor varchar(30)='Richard Bach',
@editorial varchar(20)='Planeta'
as
select titulo,autor,editorial,precio
from libros
where autor= @autor and
editorial=@editorial;

--Ejecutamos el procedimiento anterior sin enviarle valores para verificar que


usa los --valores por defecto:

exec pa_libros_autor_editorial2;

--Muestra los libros de "Richard Bach" y editorial "Planeta" (valores por


defecto).
--Enviamos un solo parámetro al procedimiento:

exec pa_libros_autor_editorial2 'Planeta';

--SQL Server asume que es el primero, y no hay registros cuyo autor sea
"Planeta".
--Especificamos el segundo parámetro, enviando parámetros por nombre:
exec pa_libros_autor_editorial2 @editorial='Planeta';

--Muestra los libros de "Richard Bach" (valor por defecto para "autor") de la
editorial --enviada como argumento ("Planeta").
--Ejecutamos el procedimiento enviando parámetros por nombre en distinto
orden:

exec pa_libros_autor_editorial2 @editorial='Nuevo siglo',@autor='Paenza';


--Definimos un procedimiento empleando patrones de búsqueda (antes
verificamos si --existe para eliminarlo):

if object_id('pa_libros_autor_editorial3') is not null


drop procedure pa_libros_autor_editorial3;

Create proc pa_libros_autor_editorial3


@autor varchar(30) = '%',
@editorial varchar(30) = '%'
as
select titulo,autor,editorial,precio
from libros
where autor like @autor and
editorial like @editorial;

--Ejecutamos el procedimiento enviando parámetro por posición, asume que


es el primero:

exec pa_libros_autor_editorial3 'P%';

--La sentencia anterior ejecuta el procedimiento almacenado


"pa_libros_autor_editorial3" ---enviando un valor que es asumido como el
primero y para el segundo parámetro toma el --valor por defecto; muestra los
libros cuyo autor comience con "P", de cualquier editorial.

--Ejecutamos el procedimiento especificando que el valor corresponde al


segundo --parámetro:

exec pa_libros_autor_editorial3 @editorial='P%';

--La sentencia anterior ejecuta el procedimiento almacenado


"pa_libros_autor_editorial3" ---enviando un valor para el segundo parámetro,
para el primer parámetro toma el valor por --defecto; muestra los libros de
cualquier autor cuya editorial comience con "P".
--La sentencia siguiente muestra lo mismo que la anterior:

exec pa_libros_autor_editorial3 default, 'P%';

Ejercicios Propuestos
Usar la base de datos Ventas
1. Crear un procedimiento almacenado que muestre los datos del cliente que tiene
mayor cantidad de facturas emitidas.
2. Crear un procedimiento almacenado que incremente a 25% al producto más barato.
3. Crear un procedimiento almacenado que reciba varios parámetros de entrada, que
permita la inserción de un empleado, y a la vez genere el código del empleado, junto
con la inserción del registro.
4. Crear un procedimiento almacenado que reciba como parámetro de entrada un
intervalo de fechas y un código de cliente, y muestre como resultado las 3 facturas
con mayor precio de ese cliente, los campos a mostrar son : num_fac, sub_total,
igv, total
5. Crear un procedimiento almacenado que muestre todas las facturas que fueron
emitidos solo en los meses pares.
6. Crear un procedimiento almacenado que muestre las utilidades ganada por factura,
sabiendo que la utilidad es igual a ((precio-pre_cos)*cant), los campos a mostrar
num_fac, [utilidad de factura].
7. Crear un procedimiento almacenado que muestre los datos de la factura con mayor
utilidad ganada.
8. Crear un procedimiento almacenado que reciba varios parámetros de entrada, que
permita la inserción, y a la vez genere el código del producto, junto con la inserción
del producto.
9. Crear un procedimiento almacenado que permita mostrar el detalle de una o más
facturas, este procedimiento almacenado debe de permitir el ingreso de una o varias
facturas.

Por ejemplo [nombre del procedimiento] “'000001','000002','000003'”

10. Crear un procedimiento almacenado que muestre las facturas que tiene mayor y
menor total de venta, utilice la tabla facturas

Semana 3 Procedimientos Almacenados II


Parámetros de entrada y salida
 DE ENTRADA

Los procedimientos almacenados pueden recibir y devolver información;


para ello se emplean parámetros, de entrada y salida, respectivamente.
Veamos los primeros. Los parámetros de entrada posibilitan pasar
información a un procedimiento.
Para que un procedimiento almacenado admita parámetros de entrada se
deben declarar variables como parámetros al crearlo. La sintaxis es:
create proc NOMBREPROCEDIMIENTO
@NOMBREPARAMETRO TIPO =VALOR POR DEFECTO as SENTENCIAS a
realizar.

Los parámetros se definen luego del nombre del procedimiento,


comenzando el nombre con un signo arroba (@). Los parámetros son locales
al procedimiento, es decir, existen solamente dentro del mismo. Pueden
declararse varios parámetros por procedimiento, se separan por comas.
Cuando el procedimiento es ejecutado, deben explicitarse valores para cada
uno de los parámetros (en el orden que fueron definidos), a menos que se
haya definido un valor por defecto, en tal caso, pueden omitirse. Pueden ser
de cualquier tipo de dato (excepto cursor).

Luego de definir un parámetro y su tipo, opcionalmente, se puede


especificar un valor por defecto; tal valor es el que asume el procedimiento
al ser ejecutado si no recibe parámetros. Si no se coloca valor por defecto,
un procedimiento definido con parámetros no puede ejecutarse sin valores
para ellos. El valor por defecto puede ser "null" o una constante, también
puede incluir comodines si el procedimiento emplea "like".

Creamos un procedimiento que recibe el nombre de un autor como


parámetro para mostrar todos los libros del autor solicitado:

Create procedure pa_libros_autor


@autor varchar(30)
as
select titulo, editorial,precio from libros where autor= @autor;

El procedimiento se ejecuta colocando "execute" (o "exec") seguido del


nombre del procedimiento y un valor para el parámetro:

exec pa_libros_autor 'Borges';

Creamos un procedimiento que recibe 2 parámetros, el nombre de un autor y


el de una editorial:
Create procedure pa_libros_autor_editorial
@autor varchar(30),
@editorial varchar(20)
as
select titulo, precio from libros
where autor= @autor and editorial=@editorial;

El procedimiento se ejecuta colocando "execute" (o "exec") seguido del


nombre del procedimiento y los valores para los parámetros separados por
comas:

exec pa_libros_autor_editorial 'Richard Bach','Planeta';

Los valores de un parámetro pueden pasarse al procedimiento mediante el


nombre del parámetro o por su posición. La sintaxis anterior ejecuta el
procedimiento pasando valores a los parámetros por posición. También
podemos emplear la otra sintaxis en la cual pasamos valores a los
parámetros por su nombre:

exec pa_libros_autor_editorial @editorial='Planeta', @autor='Richard Bach';

Cuando pasamos valores con el nombre del parámetro, el orden en que se


colocan puede alterarse.

No podríamos ejecutar el procedimiento anterior sin valores para los


parámetros. Si queremos ejecutar un procedimiento que permita omitir los
valores para los parámetros debemos, al crear el procedimiento, definir
valores por defecto para cada parámetro:

Create procedure pa_libros_autor_editorial2


@autor varchar(30)='Richard Bach',
@editorial varchar(20)='Planeta'
as
select titulo, autor,editorial,precio from libros
where autor= @autor and editorial=@editorial;

Podemos ejecutar el procedimiento anterior sin enviarle valores, usará los


predeterminados.

Si enviamos un solo parámetro a un procedimiento que tiene definido más


de un parámetro sin especificar a qué parámetro corresponde (valor por
posición), asume que es el primero. Es decir, SQL Server asume que los
valores se dan en el orden que fueron definidos, no se puede interrumpir la
secuencia.

Si queremos especificar solamente el segundo parámetro, debemos emplear


la sintaxis de paso de valores a parámetros por nombre:
exec pa_libros_autor_editorial2 @editorial='Paidos';

Podemos emplear patrones de búsqueda en la consulta que define el


procedimiento almacenado y utilizar comodines como valores por defecto:
Create proc pa_libros_autor_editorial3
@autor varchar(30) = '%',
@editorial varchar(30) = '%'
as
select titulo,autor,editorial,precio from libros
where autor like @autor and editorial like @editorial;

La sentencia siguiente ejecuta el procedimiento almacenado


"pa_libros_autor_editorial3" enviando un valor por posición, se asume que
es el primero.

exec pa_libros_autor_editorial3 'P%';

La sentencia siguiente ejecuta el procedimiento almacenado


"pa_libros_autor_editorial3" enviando un valor para el segundo parámetro,
para el primer parámetro toma el valor por defecto:

exec pa_libros_autor_editorial3 @editorial='P%';

También podríamos haber tipiado:

exec pa_libros_autor_editorial3 default, 'P%';

 DE SALIDA

Los procedimientos almacenados pueden devolver información; para ello se


emplean parámetros de salida. El valor se retorna a quien realizó la llamada
con parámetros de salida. Para que un procedimiento almacenado devuelva
un valor se debe declarar una variable con la palabra clave "output" al crear
el procedimiento:

CREATE PROCEDURE NOMBREPROCEDIMIENTO


@PARAMETROENTRADA TIPO =VALORPORDEFECTO,
@PARAMETROSALIDA TIPO=VALORPORDEFECTO output
as
SENTENCIAS
select @PARAMETROSALIDA=SENTENCIAS;

Los parámetros de salida pueden ser de cualquier tipo de datos, excepto


text, ntext e image.

Creamos un procedimiento almacenado al cual le enviamos 2 números y


retorna el promedio:

Create procedure pa_promedio


@n1 decimal(4,2), @n2 decimal(4,2), @resultado decimal(4,2) output
as
select @resultado=(@n1+@n2)/2;

Al ejecutarlo también debe emplearse "output":

declare @variable decimal(4,2)


execute pa_promedio 5,6, @variable output select @variable;

Declaramos una variable para guardar el valor devuelto por el


procedimiento; ejecutamos el procedimiento enviándole 2 valores y
mostramos el resultado.

La instrucción que realiza la llamada al procedimiento debe contener un


nombre de variable para almacenar el valor retornado.
Creamos un procedimiento almacenado que muestre los títulos, editorial y
precio de los libros de un determinado autor (enviado como parámetro de
entrada) y nos retorne la suma y el promedio de los precios de todos los
libros del autor enviado:

Create procedure pa_autor_sumaypromedio


@autor varchar(30)='%', @suma decimal(6,2) output, @promedio
decimal(6,2) output
as
select titulo,editorial,precio from libros where autor like @autor
select @suma=sum(precio) from libros where autor like @autor
select @promedio=avg(precio) from libros where autor like @autor;

Ejecutamos el procedimiento y vemos el contenido de las variables en las


que almacenamos los parámetros de salida del procedimiento:

declare @s decimal(6,2), @p decimal(6,2)

execute pa_autor_sumaypromedio 'Richard Bach', @s output, @p output

select @s as total, @p as promedio;

Ejecución de procedimientos almacenados

Podemos ingresar datos en una tabla con el resultado devuelto por un


procedimiento almacenado.
La instrucción siguiente crea el procedimiento "pa_ofertas", que ingresa
libros en la tabla "ofertas":
Create proc pa_ofertas
as
select titulo,autor,editorial,precio from libros where precio<50;
La siguiente instrucción ingresa en la tabla "ofertas" el resultado del
procedimiento "pa_ofertas":
insert into ofertas exec pa_ofertas;
Las tablas deben existir y los tipos de datos deben coincidir.

Aplicaciones prácticas

 Problema:

Trabajamos con la tabla "libros" de una librería.


--Eliminamos la tabla si existe y la creamos nuevamente:
if object_id('libros') is not null drop table libros;

Create table libros(


codigo int identity,
titulo varchar(40),
autor varchar(30),
editorial varchar(20),
precio decimal(5,2),
primary key(codigo)
);

--Ingresamos algunos registros:


insert into libros values ('Uno','Richard Bach','Planeta',15);
insert into libros values ('Ilusiones','Richard Bach','Planeta',12);
insert into libros values ('El aleph','Borges','Emece',25);
insert into libros values ('Aprenda PHP','Mario Molina','Nuevo siglo',50);
insert into libros values ('Matemática estas ahi','Paenza','Nuevo siglo',18);
insert into libros values ('Puente al infinito','Richard
Bach','Sudamericana',14);
insert into libros values ('Antología','J. L. Borges','Paidos',24);
insert into libros values ('Java en 10 minutos','Mario Molina','Siglo XXI',45);
insert into libros values ('Antología','Borges','Planeta',34);

--Eliminamos la tabla "ofertas" si existe y la creamos con los mismos


campos de la tabla "libros":
if object_id('ofertas') is not null drop table ofertas;

create table ofertas(


titulo varchar(40),
autor varchar(30),
editorial varchar(20),
precio decimal(5,2)
);

--Eliminamos el procedimiento llamado "pa_ofertas", si existe:

if object_id('pa_ofertas') is not null


drop procedure pa_ofertas;

--Creamos el procedimiento para que seleccione los libros cuyo precio no


supera los 30 pesos:

Create proc pa_ofertas


as
select titulo,autor,editorial,precio from libros where precio<=30;

--Vamos a ingresar en la tabla "ofertas" el resultado devuelto por el


procedimiento --almacenado "pa_ofertas":

insert into ofertas exec pa_ofertas;

--Veamos el contenido de "ofertas":

select *from ofertas;

--Eliminamos la tabla "libros_por_editorial" si existe y luego creamos la tabla


con dos campos: nombre de editorial y cantidad:
if object_id('libros_por_editorial') is not null
drop table libros_por_editorial;

Create table libros_por_editorial(


editorial varchar(20),
cantidad int
);

--Eliminamos el procedimiento llamado "pa_libros_por_editorial", si existe:

if object_id('pa_libros_por_editorial') is not null


drop procedure pa_libros_por_editorial;

--Creamos el procedimiento para que cuente la cantidad de libros de cada


editorial:

Create proc pa_libros_por_editorial


as
select editorial,count(*)
from libros
group by editorial;

--Vamos a ingresar en la tabla "libros_por_editorial" el resultado devuelto


por el procedimiento almacenado "pa_libros_por_editorial":
insert into libros_por_editorial exec pa_libros_por_editorial;
--Veamos el contenido de la tabla "libros_por_editorial":
select *from libros_por_editorial;

Ejercicios Propuestos
Usar la base de datos Neptuno

1. Crear un SP que muestre cuales son los productos que tienen el mayor precio de la
tabla productos. Los campos a mostrar son:
Ejemplo: Exec usp_ProductoMayor
2. Crear un SP que muestre todos los Pedidos de un cliente ingresado. Los datos a
mostrar son:
Ejemplo: Exec usp_PedidosporCliente 'ALFKI'

3. crear un SP que muestre la cantidad de pedidos vendidos por un empleado ingresado.


Ejemplo: Exec usp_PedidosporEmpleado 1

4. Crear un SP que muestre todos los Productos cuyo pais de proveedor sea ingresado, y
la unidad de precio sea mayor al dato ingresado.Mostrara el siguiente resultado.
Ejemplo: Exec usp_ProductosporPaisyPrecioUnidad 'Estados Unidos',20

5. Crear un SP que permita mostrar todos los datos de una tabla ingresada.
Set Quoted_Identifier off --los literales deben delimitarse con comillas dobles.
Set Quoted_Identifier on --los literales deben delimitarse con comillas simples.
Ejemplo: Exec usp_MostrarTablas 'Empleados'

6. Crear un SP que que permita mostrar todos los productos cuya segunda palabra del
nombre del producto inicia por una letra ingresada,el precio unidad sea mayor al dato
ingresado, y las unidades en existencia sea mayor al dato ingresado.
Ejemplo: Exec usp_Productospor3Parametros 'd',40,50
7. Crear un SP que muestre cuantos productos existen cuyo precio unidad este entre 15 y
50. Utilice un parametro de salida OUTPUT para obtener el resultado.
Ejemplo de ejecucion del procedimiento almacenado con parametro de salida:
Declare @precio int
Exec usp_CantidadProductos @precio Output
print 'Existen '+ convert(varchar(2),@precio)+' Productos'

8. Crear un SP que permita la insercion de un registro en la tabla alumnos.

Nombre de Campo Tipo de Dato Longitud


Alu_cod Char 5
Alu_dir Varchar 50
Alu_edad Int
Alu_fecing Smalldatetime

9. Crear un SP que permita la insercion de un registro en la tabla alumnos y a la vez genere


el codigo alfanumerico del alumnos como 'A0000'.
10. Crear un SP que permita la actualizacion de todos los datos de un alumno por medio de
un codigo ingresado.
11. Crear un SP que permita eliminar un alumno por medio de un codigo ingresado.
12. Crear un SP que permita eliminar uno o mas alumnos mediante el ingreso de uno o mas
codigo de alumnos.
13. Crear un procedimiento que permita realizar la busqueda de productos por uno o mas
palabras.
Ejemplo: Exec usp_busquedaProductos 'Ta'

Semana 4 Procedimientos almacenados III


Vistas
INTRODUCCION

Las tablas de una base de datos definen la estructura y organización


de sus datos. Sin embargo, SQL también permite mirar los datos
almacenados de otros modos mediante la definición de vistas alternativas de
datos. Una vista es una consulta SQL que está permanentemente
almacenada en la base de datos y a la que se le asigna un nombre. Los
resultados de una consulta almacenada son “visibles” a través de la vista y
SQL permite acceder a estos resultados como si fueran, de hecho, una tabla
“real” en la base de datos.

Las vistas son parte importante de SQL, por varias razones:

Las vistas permiten acomodar el aspecto de una base de datos de


modo que diferentes usuarios la vean desde diferentes perspectivas.
Las vistas permiten restringir acceso a los datos, permitiendo que
diferentes usuarios sólo vean ciertas filas o ciertas columnas de una tabla.
Las vistas simplifican el acceso a la base de datos mediante la
presentación de la estructura de los datos almacenados del modo que sea
más natural a cada usuario.

¿Qué es una vista?

Una vista es una “tabla virtual” en la base de datos cuyos contenidos


están definidos por una consulta. Para el usuario de la base de datos, la
vista aparece igual que una tabla real, con un conjunto de columnas
designadas y filas de datos. Pero a diferencia de una tabla real, una vista no
existe en la base de datos como conjunto almacenado de valores. En su
lugar, las filas y columnas de datos visibles a través de la vista son los
resultados producidos por la consulta que define la vista. SQL crea la ilusión
de la vista dándole a ésta un nombre semejante a un nombre de tabla y
almacenando la definición de la vista en la base de datos.

Ventajas de las vistas

Seguridad. Cada usuario puede obtener permiso para acceder a la


base de datos únicamente a través de un pequeño conjunto de vistas que
contienen los datos específicos que el usuario está autorizado a ver,
restringiendo así el acceso del usuario a los datos almacenados.
Simplicidad de consulta. Una vista puede extraer datos de varias
tablas diferentes y presentarlos como una única tabla, haciendo que
consultas multi tabla se formulen como consultas de una sola tabla con
respecto a la vista.
Simplicidad estructurada. Las vistas pueden dar a un usuario una
visión “personalizada” de la estructura de la base de datos presentando ésta
como un conjunto de tablas virtuales que tienen sentido para ese usuario.
Aislamiento frente al cambio. Una vista puede presentar una imagen
consistente inalterada de la estructura de la base de datos incluso si las
tablas fuentes subyacentes se dividen, reestructuran o cambian de nombre.
Integridad de datos. Si se accede a los datos y se introducen a través
de una vista, el DBMS puede comprobar automáticamente los datos para
asegurarse que satisfacen restricciones de integridad especificadas.

Desventajas de las vistas

Rendimiento. Las vistas crean la apariencia de una tabla, pero el


DBMS debe traducir las consultas con respecto a la vista en consultas con
respecto a las tablas fuente subyacente.
Restricciones de actualización. Cuando un usuario trata de actualizar
filas de una vista, el DBMS debe traducir la petición a una actualización
sobre las filas de las tablas fuente subyacente.

Creación De Una Vista (Create View)

La sentencia CREATE VIEW se utiliza para crear una vista. La


sentencia asigna un nombre a la vista y especifica la consulta que define la
vista. Para crear la vista con éxito es preciso tener permiso para acceder a
todas las tablas referenciadas en la consulta. Solamente se especifican los
nombres de las columnas; el tipo de datos, la longitud y las otras
características de cada columna se deducen de la definición de las columnas
en las tablas fuente. Si la lista de nombres de columnas se omite de la
sentencia CREATE VIEW, cada columna de la vista adopta el nombre de la
columna correspondiente de la consulta. La lista de nombres de columnas
debe ser especificada si la consulta incluye columnas calculadas o si
produce dos columnas con nombres idénticos.

Aunque todas las vistas se crean del mismo modo en la práctica se


utilizan diferentes tipos de vistas para propósitos diferentes.

1. Vistas horizontales

Un uso común de las vistas es restringir el acceso de un usuario a


las filas seleccionadas de una tabla. Por ejemplo, puede ser deseable que un
director de ventas solamente vea filas de REPVENTAS correspondientes a
los vendedores de la región propia del director. Para lograr esto, se pueden
definir dos vistas, del modo siguiente:

Crea una vista que muestre a los vendedores de la región Este.

CREATE VIEW REPESTE AS SELECT * FROM REPVENTAS WHERE OFICINA_REP IN


(11, 12, 13)

Define una vista que contiene únicamente las oficinas de la región


Este.

CREATE VIEW OFICINASESTE AS SELECT *FROM OFICINAS WHERE REGION =


'Este'

2. Vistas verticales

Otro uso habitual de las vistas es restringir el acceso de un usuario a


sólo ciertas columnas de una tabla. Por ejemplo, en nuestra base de datos,
el departamento de procesamiento de pedidos puede necesitar acceder al
número de empleado, su nombre y la asignación de oficina. Sin embargo, no
hay necesidad de que el personal de procesamiento de pedidos vea las
ventas actuales del vendedor o su cuota. Esta vista selectiva de la Tabla
REPVENTAS puede ser construida con la vista siguiente:

Crea una vista mostrando información seleccionada de cada


vendedor.

CREATE VIEW INFOREP AS SELECT NUM_EMPL, NOMBRE, OFICINA_REP FROM


REPVENTAS

Define una vista de la Tabla OFICINAS para el personal de


procesamiento de pedidos que incluye la ciudad, el número de oficina y
región.

CREATE VIEW INFOOFICINA AS SELECT OFICINA, CIUDAD, REGION FROM OFICINAS

3. Vistas con subconjuntos fila/columna

Es bastante habitual definir una vista que divida una tabla fuente
tanto por la dimensión horizontal como por la vertical, como en este
ejemplo:

Define una vista que contiene el número de cliente, el nombre de


empresa y el límite de crédito de todos los clientes asignados a Bill Adams
(empleado número 105)

CREATE VIEW CLIEBILL AS SELECT NUM_CLIE, EMPRESA, LIMITE_CREDITO


FROM CLIENTES WHERE REP_CLIE = 105

Los datos visibles a través de esta vista son un subconjunto


fila/columna de la Tabla CLIENTES. Sólo las columnas explícitamente
designadas en la lista de selección de la vista y las filas que satisfacen la
condición de búsqueda son visibles a través de la vista.

ELIMINACION DE UNA VISTA

Debido a que las vistas se comportan como tablas, y una vista no


puede tener el mismo nombre que una tabla, muchos productos DBMS
utilizan la sentencia DROP TABLE para eliminar vistas. Otras
implementaciones SQL proporcionan la sentencia DROP VIEW:

RESUMEN

Una vista es una tabla virtual definida mediante una consulta. La


vista `parece contener filas y columnas de datos, al igual que una tabla
“real”, pero los datos visibles a través de la vista son, de hecho, los
resultados de la consulta.

Una vista puede ser un subconjunto simple fila/columna de una única


tabla, puede sumarizar una tabla (una vista agrupada) o puede extraer sus
datos de dos o más tablas (una vista compuesta).

Una vista puede ser referenciada como una tabla real en una
sentencia SELECT, INSERT, DELETE o UPDATE. Sin embargo, las vistas más
complejas no pueden ser actualizadas; son vistas de sólo lectura.

Las vistas suelen utilizarse para simplificar la estructura aparente de


una base de datos, para simplificar consultas y para proteger ciertas filas y/o
columnas frente a acceso no autorizado.

Ejercicios Propuestos

Usar la base de datos Neptuno

1. Crear una vista que permita visualizar los 2 empleados con mayor cantidad de Pedidos.
(usar tablas Empleados y Pedidos)

2. Crear una vista que permita visualizar todos productos por Proveedor.(Usar tablas
Proveedores y Productos)

3. Crear una vista que permita visualizar los datos del empleado mas joven. (Usar tabla
Empleados)

4. Crear una vista que permita visualizar todos los empleados con mas años de trabajo y
los empleados con menor años trabajo. (Usar tabla Empleados)
5.

6. Crear una vista que permita visualizar los productos y su categoria, cuya unidad de
precio sea mayor al promedio de precios de unidad. ( Usar tablas Categorias y
Productos)

Semana 6 Acceso a datos con ADO NET

ADO .NET es la nueva versión del modelo de objetos ADO (ActiveX Data
Object), es decir la estrategia que ofrece Microsoft para el acceso a datos.
ADO .NET ha sido ampliado para cubrir todas las necesidades que ADO no
ofrecía, y está diseñado para trabajar con conjuntos de datos
desconectados, lo que permite reducir el tráfico de red. ADO .NET utiliza
XML con formato universal de transmisión de los datos.
Estructura del modelo de objetos

Ámbitos con nombre de ADO .NET

La instalación por defecto de la plataforma .NET aporta cinco ámbitos con


nombre namespaces relacionados con ADO.NET, a los cuales habría que
añadir uno o más por cada proveedor adicional que pudiéramos instalar
después. Estos cinco ámbitos son:

System.Data: Aloja las clases independientes del origen de datos, así como
las interfaces que deben implementar las clases dependientes.

System.Data.Common: Contiene clases que facilitan la implementación de


las interfaces existentes en System,.Data por parte de los distintos
proveedores de datos, asi como otras compartidas por todos los
proveedores.
System.Data.OleDb : Corresponde al proveedor ADO.NET que permite
utilizar cualquier controlador OLE DB para conectar con un origen de datos.
En el se encuentran implementaciones especificas de clases para
comunicarse mediante OLE DB.

System.Data.SqlClient : Como el anterior, alberga clases especificas para


operar sobre un determinado origen de datos, en este caso SQL Server.
System.Data.OracleClient : Correspondiente al proveedor nativo para acceso
a datos Oracle. Al igual que System.Data.SqlClient o Sytem.Data.OleDb,
contiene implementaciones especificas de clases que facilitan la conexión y
comunicación con este RDBMS (Sistema de administración de base de datos
Relacional).

Proveedores de acceso a datos

Los proveedores de acceso a datos es la capa inferior de la parte


correspondiente al acceso de datos y es la responsable de establecer la
comunicación con las fuentes de datos.

En este conjunto de nombres de espacio, encontraremos casi siempre las


clases Connection, Command, DataAdapter y DataReader como las clases
más generales, las cuales nos permiten establecer la conexión con la fuente
de datos.

Proveedor de acceso a datos de .NET Framework

Dentro del entorno .NET Framework, encontramos un nutrido conjunto de


proveedores de acceso a datos.
Estos son los siguientes:

ODBC .NET Data Provider


OLE DB .NET Data Provider
Oracle Client .NET Data Provider
SQL Server .NET Data Provider

Estos proveedores de acceso a datos incluidos en Microsoft .NET


Framework, los podemos encontrar en los nombres de espacio:

System.Data.Odbc
System.Data.OleDb
System.Data.OracleClient
System.Data.SqlClient

El objeto Connection
Este objeto es el encargado de establecer una conexión física con una base
de datos determinada.

Para establecer la conexión con una determinada fuente de datos, no sólo


debemos establecer la cadena de conexión correctamente, sino que además
deberemos usar los parámetros de conexión y el proveedor de acceso a
datos adecuado.

Con este objeto, podremos además abrir y cerrar una conexión.


Dentro del objeto Connection tenemos

Provider: Se utiliza para indicar el nombre del proveedor de datos. El


proveedor de datos es el programa desde donde vas a obtener la
información que vas a manejar en tu aplicación y puede ser SQL,
Access, MySQL, Oracle, etc.

DataSource: Se utiliza para indicar el nombre del servidor donde se


encuentra la base de datos a conectare. El servidor es la computadora
donde se ha instalado por ejemplo el SQL Server. En los objetos
SQLConnection se puede utilizar también el parámetro Server.

Initial Catalog: Se utiliza para indicar el nombre de la bases de datos a


la cual nos queremos conectar. En los objetos SQLConnection se
puede utilizar también el parámetro DataBase.

User ID: Se utiliza para indicar el nombre del usuario que se conecta a
la base de datos.

Pwd: Se utiliza para indicar la clave del usuario que esta conectándose
a la base de datos.

Integrated Security: Permite indicar si la conexión a la base de datos


va a tener seguridad integrada, es decir, si dentro de la cadena de
conexión se va a especificar el Id del usuario y su contraseña.
Cuando le asignamos el valor False a este parámetro de conexión, se
debe especificar el Id del usuario y su contraseña. Cuando le
asignamos el valor True significa que no vamos a indicar el Id del
usuario ni su contraseña. En este caso, SQL Server utiliza los datos
nombre de usuario y contraseña que ingresaste al iniciar Windows.
El valor SSPI es el valor recomendado para este parámetro porque es
similar al valor True e indica que se va a utilizar autenticación
Windows.

El objeto Command

Este objeto es el que representa una determinada sentencia SQL o un Stored


Procedure.

Aunque no es obligatorio su uso, en caso de necesitarlo, lo utilizaremos


conjuntamente con el objeto DataAdapter que es el encargado de ejecutar la
instrucción indicada.
El objeto DataAdapter

Este objeto es quizás el objeto más complejo y a la vez complicado de todos


los que forman parte de un proveedor de acceso a datos en .NET.

Cuando deseamos establecer una comunicación entre una fuente de datos y


un DataSet, utilizamos como intermediario a un objeto DataAdapter.
A su vez, un DataAdapter contiene 4 objetos que debemos conocer:
SelectCommand es el objeto encargado de realizar los trabajos de selección
de datos con una fuente de datos dada.

En sí, es el que se encarga de devolver y rellenar los datos de una fuente de


datos a un DataSet.

DeleteCommand es el objeto encardago de realizar las acciones de borrado


de datos.

InsertCommand es el objeto encardago de realizar las acciones de inserción


de datos.

UpdateCommand es el objeto encardago de realizar las acciones de


actualización de datos.

Los objetos DeleteCommand, InsertCommand y UpdateCommand son los


objetos que se utilizan para manipular y transmitir datos de una fuente de
datos determinada, al contrario del objeto SelectCommand que tan sólo
interactúa con la fuente de datos para recuperar una porción o todos los
datos indicados en el objeto Command anteriormente comentado.

El objeto DataReader

Este objeto es el utilizado en una sóla dirección de datos. Establece una


conexión en un modo de solo lectura. Se trata de un objeto de acceso a
datos muy rápido.

Este objeto puede usar a su vez el objeto Command o el método


ExecuteReader.
La clase DataSet

Puede que sea la capa más externa e importante del modelo ADO.NET, pero
es la que contiene quizás, el modelo de colecciones y trabajo que más le
puede resultar familiar al programador de Visual Basic 6, sobre todo a los
anteriormente comentados RecordSets.

El DataSet contiene en sí, un conjunto de datos que han sido volcados desde
el proveedor de datos.

De esa forma, podemos trabajar con. De hecho, por marcar una similitud con
el RecordSet, el DataSet está preparado para trabajar con fuentes de datos
desconectadas.

La clase DataView

Este objeto nos permite crear múltiples vistas de nuestros datos, además de
permitirnos presentar los datos.

Es la clase que nos permite representar los datos de la clase DataTable,


permitiéndonos editar, ordenar y filtrar, buscar y navegar por un conjunto de
datos determinado.

La clase DataTable

Este objeto nos permite representar una determinada tabla en memoria, de


modo que podamos interactuar con ella.

A la hora de trabajar con este objeto, debemos tener en cuenta el nombre


con el cuál definamos una determinada tabla, ya que los objetos declarados
en el DataTable es sensitivo a mayúsculas y minúsculas.
Lo que sí está claro es que el modelo de datos de ADO.NET que hemos visto,
quedaría resumido en cuanto a la conectividad de la manera en la que se
representa en la figura.

Semana 7- 8 Ado – Net con Procedimientos Almacenados

Ejercicio Práctico Nro. 1

Lo primero que vamos a hacer es abrir el Visual Studio 2005.

Ahora vamos a crear un Proyecto, para ellos nos vamos a Archivo y luego
seleccionamos Nuevo Proyecto
Ahora seleccionamos Visual Basic y seleccionamos Aplicación para
Windows (se le asigna el nombre de Mantenimiento_Clientes)

Ahora crearemos el siguiente diseño.

Ahora importamos el Proveedor de la Base de Datos, en este caso será el


SQL

Imports System.Data.SqlClient
Public Class Form1

Ahora crearemos nuestra cadena de conexión


Imports System.Data.SqlClient
Public Class Form1
Dim cn As New SqlConnection("Server=(local);Integrated
Security=yes;Database=BDFactura")

Crearemos un Procedimiento en el SQL cual se encargara de mostrar el


Listado de todos los Clientes
----------Listado_Cliente----------------
-----------------------------------------
--Creamos Ahora el Procedimiento
create Procedure Listado_Cliente
as
select cli_codigo,cli_nombre,cli_telefono,cli_ruc,cli_direccion from Clientes

Ahora en el Visual Studio creamos un procedimiento el cual se encargara de


mostrar el listado de los clientes

Sub Listado()
Dim da As New SqlDataAdapter("Listado_Cliente", cn)
Dim dt As New DataTable
da.Fill(dt)
DataGridView1.DataSource = dt
End Sub

Ahora realizaremos el llamado a nuestro procedimiento para que cuando


cargue el formulario me liste los Clientes

Private Sub Form1_Load(…) Handles MyBase.Load


Listado()
End Sub

A continuación crearemos un Procedimiento Limpiar, el cual se encargara de


Limpiar todas las cajas de texto

Sub Limpiar()
'Creamos una variable de tipo control
Dim ctrl As Control
'Recorreremos todos los controles que 'existen dentro de mi
GroupBox1
For Each ctrl In Me.GroupBox1.Controls
'Preguntaremos si son TextBox
If TypeOf ctrl Is TextBox Then
ctrl.Text = ""
End If
Next
End Sub
Ahora crearemos un Procedimiento almacenado en el SQL el cual me
generara el código del cliente, dicho código será parámetro de salida
----------Genera_Codigo----------------
--Creamos Ahora el Procedimiento
Create procedure Genera_Codigo
@cod_cli char(5) Output
AS
Set @cod_cli=(Select Max(Cli_codigo) From Clientes)
set @cod_cli=isnull(@cod_cli,'0000')
Set @cod_cli='C'+right('0000'+rtrim(right(@cod_cli,4)+1),4)
Go
--Vamos a comprobar el Procedimiento
Declare @codigo char(5)
Exec Genera_Codigo @codigo Output
print @codigo

Ahora programaremos el Botón Nuevo

Private Sub btnnuevo_Click(…) Handles btnnuevo.Click


Limpiar()
Dim cmd As New SqlCommand("Genera_Codigo", cn)
cmd.CommandType = CommandType.StoredProcedure

Dim paramResultado As SqlParameter = New


SqlParameter("@cod_cli", SqlDbType.Char, 5)

paramResultado.Direction = ParameterDirection.Output
cmd.Parameters.Add(paramResultado)
cn.Open()
cmd.ExecuteReader()
cn.Close()
lblcod.Text = paramResultado.Value
End Sub

Ahora crearemos un procedimiento almacenado en el SQL, el cual me


registre al Cliente

----------Grabar_Cliente------------
------------------------------------
--Creamos Ahora el Procedimiento
create procedure Grabar_Cliente
@cod varchar(5),
@nom varchar(25),
@tel int,
@ruc varchar(11),
@dir varchar(30)
as
insert into clientes values(@cod,@nom,@tel,@ruc,@dir)
Nota:
MsgBox("Desea Grabar", 4 + 32, "Mensaje")
4 Botones Yes o No
32 Icono de Informacion
6 Si le dimos Yes
7 Si le dimos No

Ahora programaremos en el Botón Grabar

Private Sub btngrabar_Click(…) Handles btngrabar.Click

If (MsgBox("Desea Grabar", 4 + 32, "Mensaje") = 6) Then


Dim cod, nom, ruc, dir As String
Dim tel As Integer : cod = lblcod.Text : nom = txtnom.Text
ruc = txtruc.Text : dir = txtdir.Text : tel = txttel.Text

Dim cmd As New SqlCommand("Grabar_Cliente", cn)


cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@cod",SqlDbType.VarChar,5).Value = cod
cmd.Parameters.Add("@nom",SqlDbType.VarChar,25).Value = nom
cmd.Parameters.Add("@tel",SqlDbType.Int).Value = tel
cmd.Parameters.Add("@ruc",SqlDbType.VarChar,11).Value = ruc
cmd.Parameters.Add("@dir",SqlDbType.VarChar, 30).Value = dir

Dim rpta As Integer '1 Grabo 0 No Grabo


'Abrimos la conecion
cn.Open() : rpta = cmd.ExecuteNonQuery() : cn.Close()

If (rpta = 1) Then
MsgBox("Se Grabo Correctamente", 32, "Mensaje")
Listado()
Else
MsgBox("Error al Grabar", 16, "Mensaje")
End If

End If
End Sub

Ahora pasaremos los datos del DatagridView a las cajas del Textos para
realizar las modificaciones
Private Sub DataGridView1_CurrentCellChanged(…) Handles
DataGridView1.CurrentCellChanged

Try
Dim posi As Integer
'Fila Seleccionada
posi = DataGridView1.CurrentCell.RowIndex
lblcod.Text = DataGridView1(0, posi).Value txtnom.Text =
DataGridView1(1, posi).Value
txttel.Text = DataGridView1(2, posi).Value
txtruc.Text = DataGridView1(3, posi).Value
txtdir.Text = DataGridView1(4, posi).Value
Catch ex As Exception
End Try
End Sub

Ahora crearemos un procedimiento almacenado en el SQL, el cual se


encargara de la actualización de los datos del cliente

----------Actualizar_Cliente-------
--Creamos Ahora el Procedimiento
create procedure Actualizar_Cliente
@cod varchar(5),@nom varchar(25),
@tel int,@ruc varchar(11),
@dir varchar(30)
as
update clientes set cli_nombre=@nom,cli_telefono=@tel,
cli_ruc=@ruc,cli_direccion=@dir where cli_codigo=@cod

Ahora programaremos en el botón Modificar

Private Sub btnactualiz_Click(…) Handles btnactualiz.Click


If (MsgBox("Desea Actualizar", 4 + 32, "Mensaje") = 6) Then
Dim cod, nom, ruc, dir As String
Dim tel As Integer : cod = lblcod.Text:nom = txtnom.Text:ruc = txtruc.Text
dir = txtdir.Text :tel = txttel.Text
Dim cmd As New SqlCommand("Actualizar_Cliente", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@cod", SqlDbType.VarChar, 5).Value = cod
cmd.Parameters.Add("@nom", SqlDbType.VarChar, 25).Value = nom
cmd.Parameters.Add("@tel", SqlDbType.Int).Value = tel
cmd.Parameters.Add("@ruc", SqlDbType.VarChar, 11).Value = ruc
cmd.Parameters.Add("@dir", SqlDbType.VarChar, 30).Value = dir
Dim rpta As Integer
cn.Open()
rpta = cmd.ExecuteNonQuery()
cn.Close()
If (rpta = 1) Then
MsgBox("Se Actualizo Correctamente", 32, "Mensaje")
Listado()
Else
MsgBox("Error al Actualizar", 16, "Mensaje")
End If : End If : End Sub
Ahora crearemos un procedimiento almacenado en el SQL, el cual se
encargara de eliminar a un cliente

----------Eliminar_Cliente------
--Creamos Ahora el Procedimiento
create procedure Eliminar_Cliente
@cod varchar(5)
as
delete from clientes where cli_codigo=@cod

Ahora programaremos en el botón Eliminar

Private Sub btneliminar_Click(…) Handles btneliminar.Click


If (MsgBox("Desea Eliminar", 4 + 32, "Mensaje") = 6) Then
Dim cod As String
cod = lblcod.Text
Dim cmd As New SqlCommand("Eliminar_Cliente", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@cod", SqlDbType.VarChar, 5).Value = cod
Dim rpta As Integer
cn.Open()
rpta = cmd.ExecuteNonQuery()
cn.Close()
If (rpta = 1) Then
MsgBox("Se Elimino Correctamente", 32, "Mensaje")
Else
MsgBox("Error al Elimino", 16, "Mensaje")
End If
End If
End Sub

Ahora compilaremos nuestro formulario presionando F5


Ejercicio Práctico Nro. 2

Lo primero que vamos hacer es crear los procedimientos almacenados en el


SQL

use northwind
go
----------Listado_Cliente----------------
-----------------------------------------
--Creamos Ahora el Procedimiento
create Procedure Listado_Empleado
as
select EmployeeID,LastName + ' , '+ FirstName as Nombre_apellido
from Employees
go
----------Facturas vendidas----------------
-----------------------------------------
--Creamos Ahora el Procedimiento
create Procedure Facturas_Empleado
@codven int
as
select OrderID,convert(char(10),OrderDate,103) Fecha,ShipCountry
from Orders
where EmployeeID=@codven
go
----------Facturas vendidas----------------
-----------------------------------------
--Creamos Ahora el Procedimiento
create Procedure Mostrar_Foto
@codven int
as
select Photo from Employees
where EmployeeID=@codven
go

Ahora lo que vamos a hacer es abrir el Visual Studio 2005

Ahora vamos a crear un Proyecto, para ellos nos vamos a Archivo y luego
seleccionamos Nuevo Proyecto

Ahora seleccionamos Visual Basic y seleccionamos Aplicación para


Windows Se le dara erl nombre de Consultas

Ahora realizaremos el siguiente diseño:

Lo primero que realizaremos es importar estas 2 librerías

Imports System.Data.SqlClient
Imports System.IO 'MemoryStream

A continuación crearemos nuestra cadena de conexión


Imports System.Data.SqlClient
Imports System.IO 'MemoryStream
Public Class Consulta
Dim cn As New SqlConnection("Server=(local);Integrated Security=yes;database=northwind")

Ahora programaremos para que cuando cargue el formulario me liste los


empleados

Private Sub Consulta_Load(…) Handles MyBase.Load


Dim da As New SqlDataAdapter("Listado_Empleado", cn)
Dim dt As New DataTable
da.Fill(dt)
ListBox1.DataSource = dt
ListBox1.DisplayMember = "Nombre_apellido"
ListBox1.ValueMember = "EmployeeID"
'StretchImage ajusta la imagen al tamaño del PictureBox1
PictureBox1.SizeMode = PictureBoxSizeMode.StretchImage
End Sub

Crearemos nuestro procedimiento para Mostrar la foto

Sub Mostrar_imagen(ByVal cod As Integer)


Dim cmd As New SqlCommand("Mostrar_Foto", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@codven", SqlDbType.Int).Value = cod

Dim da As New SqlDataAdapter(cmd)


Dim dt As New DataTable
da.Fill(dt)

Dim imagen() As Byte


imagen = dt.Rows(0)(0)
Dim ms As New MemoryStream
Dim offset As Integer = 78 'estableciendo un desplazamiento de bytes es un buffer
'//donde se debe de comenzar la escritura Escribimos los datos en memoria
ms.Write(imagen, offset, imagen.Length - offset)
Dim bmp As Bitmap
bmp = New Bitmap(ms)
'Bitmap bmp = new Bitmap(ms);
ms.Close() 'cierra la secuencia de memoria y libera recursos
'//Bitmap es un objeto usado para trabajar con imagenes 'definidas por datos en pixel.
PictureBox1.SizeMode = PictureBoxSizeMode.StretchImage
PictureBox1.Image = bmp
End Sub

Ahora programaremos en el ListBox, para que cuando seleccionemos uno


de los empleados nos visualice las fotos y las facturas vendidas por dicho
empleado
Private Sub ListBox1_SelectedIndexChanged(…) Handles
ListBox1.SelectedIndexChanged

Try
Dim cod As Integer = CInt(ListBox1.SelectedValue)
Dim cmd As New SqlCommand("Facturas_Empleado", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@codven", SqlDbType.Int).Value = cod

Dim da As New SqlDataAdapter(cmd)


Dim dt As New DataTable
da.Fill(dt)
DataGridView1.DataSource = dt
Mostrar_imagen(cod)
Catch ex As Exception
End Try
End Sub

Presionamos finalmente F5

Ejercicio Práctico Nro. 3

Lo primero que vamos hacer es crear los procedimientos almacenados en el


SQL
use BDfactura
go
----Facturas Realizadas
create procedure Lista_Facturas
as
select fac_numero, convert(char(10),fac_fecha,103) Fecha
from fac_cabe
go

--Detalle de las Facturas Seleccionadas


set quoted_identifier off
go

create procedure Lista_Detalle


@fac varchar(255)
as
exec("select fac_numero,a.art_codigo,art_nombre,art_precio,art_cantidad,
(art_precio*art_cantidad) Total
from articulos as a,fac_deta fd
where a.art_codigo=fd.art_codigo
and fac_numero in ("+@fac+")")
go
--probamos el procedimiento

Lista_Detalle "'F0001','F0002','F0003'"

Ahora lo que vamos a hacer es abrir el Visual Studio 2005

Ahora vamos a crear un Proyecto, para ellos nos vamos a Archivo y luego
seleccionamos Nuevo Proyecto

Ahora seleccionamos
Ahora crearemos el siguiente diseño

Ahora en el primer DataGridView1 nos vamos a la esquina de la parte


superior y nos debe quedar de la siguiente manera

Ahora seleccionamos la opción Editar columnas

A continuación vamos agregar las columnas, para ello seleccionamos

Ahora vamos agregar una columna con CheckBox y le damos agregar


Ahora vamos agregar una columna el cual nos va a mostrar el código de la
Factura

Y en sus propiedades, colocamos fac_numero porque es el campo que


queremos visualizar

Ahora agregaremos otro para la fecha de la columna


Al final nos quedara de la siguiente manera

Ahora lo primero que realizaremos es importar nuestra librería para poder


conectarnos al SQL

Imports System.Data.SqlClient

A continuación crearemos nuestra cadena de conexión

Dim cn As New SqlConnection("Server=(local);Integrated


Security=yes;database=BDfactura")

A continuación programaremos para que cuando cargue el formulario me


llene el 1er DatagridView con todas las facturas realizadas
Private Sub DatagridViewCheckBox_Load(…) Handles MyBase.Load
Dim da As New SqlDataAdapter("Lista_Facturas", cn)
Dim dt As New DataTable
da.Fill(dt)
DataGridView1.DataSource = dt
End Sub

Ahora programaremos en el botón


Private Sub btnMostrar_Click(…) Handles btnMostrar.Click
Dim codigos As String = ""
For a As Integer = 0 To DataGridView1.Rows.Count - 1
'Ahora preguntamos si se le dio Checked
If (DataGridView1(0, a).Value = True) Then
'Trim extrae espacios en Blanco
codigos += "'" & Trim(DataGridView1(1, a).Value) & "',"
End If
Next
'por Ejm si seleccionamos 'F0001','F0002','F0003',
If (codigos.Length >= 1) Then 'Si seleccionamos algo
'Para eliminar la ultima coma
Dim tamaño As Integer
tamaño = codigos.Length - 1
Dim codfinal As String = Mid(codigos, 1, tamaño)
Dim cmd As New SqlCommand("Lista_Detalle", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@fac", SqlDbType.VarChar).Value = codfinal
Dim da As New SqlDataAdapter(cmd)
Dim dt As New DataTable
da.Fill(dt)
DataGridView2.DataSource = dt
End If

Finalmente presionamos F5

Ejercicios Propuestos

1. Realizar el siguiente formulario bajo las siguientes condiciones:


Cuando se dé clic en cualquier RadioButton realizara la búsqueda por
las letras comprendidas entre ellas, la caja de texto podrá ser la
búsqueda pero solo de los rangos de la letra que han sido
seleccionado, mostramos los clientes seleccionados en un Listview,
seleccionamos un cliente y nos mostrara las facturas realizadas por
ese cliente.

2. En un Listview nos mostrara todos los proveedores, cuando


seleccionamos uno o más proveedores con el botón Mostrar nos listara
todos los productos que tienen los proveedores seleccionados

3. Mostrar en un ListBox las regiones, cuando seleccionamos una región nos


mostrara los territorios de dicha región, cuando seleccionamos la región nos
mostrara los empleados que viven en dicha región, seleccionamos un
empleado y nos mostrara las ventas realizadas por dicho empleado.
4. Mostrar un listado de categorías, cuando seleccionamos la categoría nos
visualizara la foto respectiva, y a la vez nos mostrara los productos que se
encuentran en dicha categoría.
También nos permitirá hacer un filtrado de las facturas que son mayores al
monto ingresado.
Ejercicios Propuestos
Hará uso de la base de datos Northwind

Aplicación 1:

Desarrollara esta aplicación bajo las siguientes consideraciones:

1. Cuando cargue el formulario, se deberá demostrar en un Listbox1 2 campos el


código y los nombres de los empleados, tanto el primero como el último nombre del
empleado.
2. Al seleccionar un Item del listbox1, se deberá mostrar en un dataGridView1 las 5
órdenes más caras pares, que se hayan emitido en los meses impares del empleado
seleccionado. Mostrando en los resultados el total por orden emitida.
3. Y por último se deberá demostrar la suma de toda la columna Total del
dataGridView1, en un label.
APLICACIÓN 2:

Desarrollar esta aplicación bajos las siguientes condiciones:

1. Cuando cargue el formulario, se deberá demostrar en un comboBox1, todos los


países de la tabla Customers.
2. Cuando seleccione un país del ComboBox1, se deberá demostrar en el
dataGridView1, todas las ciudades del país seleccionado, y a la vez la cantidad de
códigos postales que tiene dicha ciudad.
3. Cuando seleccione una ciudad del dataGridView1, se deberá demostrar en el
dataGridView2 todos los clientes que pertenece a esa ciudad. Muestre solo 4
campos.
4. Y por último se deberá de visualizar en un label, la cantidad de clientes que existen
por país.
Aplicación 3:

Realice una búsqueda de clientes mediante cadenas en una caja de texto, el resultado los
mostrara en un control DataGridView1, el campo Tipo Cliente será Cliente VIP cuando el
cliente tenga más de 10 Ordenes compradas, si no será un tipo de cliente Normal. Al
seleccionar un cliente en el DataGridview1 mostrara las ordenes vendidas en un Listbox,
mostrando los campos concatenados.
Semana 11 Clases y creación de librerías
Ejercicio Práctico Nro. 1

Lo primero que vamos a hacer es abrir el Visual Studio 2005.


Ahora vamos a crear un Proyecto, para ellos nos vamos a Archivo y luego
seleccionamos Nuevo Proyecto

Este será el modelo a desarrollar


Lo primero que vamos a realizar es crear nuestros procedimientos
almacenados en el SQL

Nuestro primer procedimiento almacenado me listara el código y nombre del


cliente pero solo de los clientes que tengan facturas

----------Listado_Cliente----------------
-----------------------------------------
--Creamos Ahora el Procedimiento
create Procedure Listado_Cliente
as
select cli_codigo,cli_nombre from clientes where cli_codigo
in(select distinct cli_codigo from ac_cabe)
go

Ahora crearemos un procedimiento almacenado el cual me listara las


facturas del cliente dependiendo del código del cliente
----------Facturas_Cliente----------------

--Creamos Ahora el Procedimiento


create Procedure Facturas_Cliente
@cod varchar(5)
as
select fac_numero from fac_cabe where cli_codigo=@cod
go
Por último crearemos un procedimiento el cual nos mostrara el detalle de la
factura dependiendo de la factura ingresada

----------Detalle de la Factura-----------

--Creamos Ahora el Procedimiento


create procedure Detalle_Factura
@fac varchar(5)
as
select fac_numero,a.art_codigo,art_nombre,art_precio,art_cantidad,
(art_precio* art_cantidad) as Total from Articulos as a, Fac_deta as fd
where a.art_codigo = fd.art_codigo
and fd.fac_numero=@fac
go

Ahora crearemos nuestro diseño en el Visual Studio Net el siguiente diseño


Una vez creado el diseño del formulario, ahora vamos agregar una clase a
nuestro proyecto, para ello seleccionamos el Proyecto y luego Clic Agregar y
finalmente seleccionamos Clase

Ahora a nuestra clase lo llamaremos clsconexion


En esta clase crearemos una función el cual me devuelva mi cadena de
conexión, y así poder usarla en todas las demás clases

Imports System.Data.SqlClient
Public Class clsconexion
Function cn() As String
Dim cadena As String
cadena = "Server=(local);Integrated Security=SSPI;"
cadena += "Database=bdfactura"
Return cadena
End Function
End Class

Ahora crearemos otra clase el cual llamaremos a todos nuestros


procedimientos almacenados, además llamaremos a nuestra clase
clsconexion ya que en ella está mi conexión

Y ahora programaremos lo siguiente

Imports System.Data.SqlClient

Public Class clsfunciones


Dim clase As New clsconexion
'clase.cn llamo a mi cadena de conexion
Dim cn As New SqlConnection(clase.cn)

'Esta funcion me Listara a los clientes q tengan Facturas


Function Lista_Cliente() As DataTable
Dim da As New SqlDataAdapter("Listado_Cliente", cn)
Dim dt As New DataTable
da.Fill(dt)
Return dt
End Function

'Esta funcion nos mostrara la facturas del cliente


Function Facturas_Clientes(ByVal cod As String) As DataTable
Dim cmd As New SqlCommand("Facturas_Cliente", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@cod", SqlDbType.VarChar).Value = cod
Dim da As New SqlDataAdapter(cmd)
Dim dt As New DataTable
da.Fill(dt)
Return dt
End Function

'Esta funcion nos mostrara el detalle de la facturas


Function Detalle_Factura(ByVal fac As String) As DataTable
Dim cmd As New SqlCommand("Detalle_Factura", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@fac", SqlDbType.VarChar).Value = fac
Dim da As New SqlDataAdapter(cmd)
Dim dt As New DataTable
da.Fill(dt)
Return dt
End Function
End Class

Ahora en el formulario vamos a importar

Imports System.Data.SqlClient

Ahora llamaremos a nuestra clase clsfunciones

Imports System.Data.SqlClient
Public Class Form1
Dim funcion As New clsfunciones

Ahora programaremos para que cuando cargue el formulario me liste los


clientes.

Private Sub Form1_Load(…) Handles MyBase.Load


Dim dtcliente As New DataTable
dtcliente = funcion.Lista_Cliente
'creamos un TreeNode principal el cual
'tendra el listado de Clientes
Dim padre As New TreeNode
Tvclientes.Nodes.Clear()
For a As Integer = 0 To dtcliente.Rows.Count - 1
padre = New TreeNode(dtcliente.Rows(a)(1))
Tvclientes.Nodes.Add(padre)
'Facturas de cada Cliente
Dim dt As New DataTable : 'dr(0) tiene el codigo del Cliente
dt = funcion.Facturas_Clientes(dtcliente.Rows(a)(0))
For b As Integer = 0 To dt.Rows.Count - 1
'Agregamos las subnodos del padre
padre.Nodes.Add(dt.Rows(b)(0).ToString)
Next
Next
End Sub

Ahora programaremos en el Tvclientes

Private Sub Tvclientes_AfterSelect(…) Handles Tvclientes.AfterSelect


Try
If (Tvclientes.SelectedNode.Level = 0) Then
'si seleccionamos el Cliente limpiamos
'el dgfacturas
dgfacturas.DataSource = DBNull.Value
End If

'Si seleccionamos la Factura


If (Tvclientes.SelectedNode.Level = 1) Then
'Capturamos el nro de la Factura seleccionada
Dim fac As String = Tvclientes.SelectedNode.Text
Dim dt As New DataTable
dt = funcion.Detalle_Factura(fac)
dgfacturas.DataSource = dt
lblsuma.Text = dt.Compute("sum(Total)", "")
End If
Catch ex As Exception
End Try
End Sub

Finalmente presionamos F5 y nos debe quedar de la siguiente manera


Ejercicio Práctico Nro. 2

Lo primero que vamos a hacer es abrir el Visual Studio y crear una


aplicacion de Windows

Este será el modelo a desarrollar


Lo primero que vamos a realizar es crear nuestros procedimientos
almacenados en el SQL

Nuestro primer procedimiento almacenado nos listara el código y nombre


del cliente pero solo de los clientes que tengan facturas.

----------Listado_Cliente----------------
-----------------------------------------

--Creamos Ahora el Procedimiento


create Procedure Listado_Cliente
as
select cli_codigo,cli_nombre from clientes
where cli_codigo in(select distinct cli_codigo from fac_cabe)
go

Ahora crearemos un procedimiento almacenado el cual me listara todas las


facturas de todos los clientes, esto dependerá de los códigos que le
mandemos como parámetros.

----------Facturas_Varios_Cliente----------------
-----------------------------------------
--Habilita el uso de las comillas
set quoted_identifier off
--Creamos Ahora el Procedimiento
create Procedure Facturas_Varios_Cliente
@codigos varchar(255)
as
exec("select fac_numero,c.cli_codigo,cli_nombre "+
"from fac_cabe as fc,clientes as c "+
"where fc.cli_codigo=c.cli_codigo and "+
"c.cli_codigo in(" +@codigos +") "+
"order by c.cli_codigo asc")
Go

Ahora vamos a probar como funciona nuestro procedimiento almacenado,


como nos daremos cuenta los códigos están dentro de las comillas

Ahora crearemos nuestro diseño en el Visual Studio Net el siguiente diseño

Una vez creado el diseño del formulario, ahora vamos agregar una clase a
nuestro proyecto, para ello seleccionamos el Proyecto y luego Clic Agregar y
finalmente seleccionamos Clase
Ahora a nuestra clase lo llamaremos clsconexion

En esta clase crearemos una función el cual me devuelva mi cadena de


conexión, y así poder usarla en todas las demás clases.

Imports System.Data.SqlClient

Public Class clsconexion


Function cn() As String
Dim cadena As String
cadena = "Server=(local);Integrated Security=SSPI;"
cadena += "Database=bdfactura"
Return cadena
End Function
End Class

Ahora crearemos otra clase el cual llamaremos a todos nuestros


procedimientos almacenados, además llamaremos a nuestra clase
clsconexion ya que en ella está mi conexión

Imports System.Data.SqlClient

Public Class clsfunciones


Dim clase As New clsconexion
Dim cn As New SqlConnection(clase.cn)
'Esta funcion me Listara a los clientes q tengan Facturas
Function Lista_Cliente() As DataTable
Dim da As New SqlDataAdapter("Listado_Cliente", cn)
Dim dt As New DataTable
da.Fill(dt)
Return dt
End Function

'Esta funcion nos mostrara las facturas de los cliente


Function Facturas_varios_Clientes(ByVal cod As String) As DataTable
Dim cmd As New SqlCommand("Facturas_Varios_Cliente", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@codigos", SqlDbType.VarChar).Value = cod
Dim da As New SqlDataAdapter(cmd)
Dim dt As New DataTable
da.Fill(dt)
Return dt
End Function
End Class

Ahora volvemos al diseño de nuestro formulario, para ello vamos a


importar

Imports System.Data.SqlClient

Ahora llamaremos a nuestra clase clsfunciones

Imports System.Data.SqlClient
Public Class Form1
Dim clase As New clsfunciones

Ahora programaremos para que cuando cargue el formulario me liste los


clientes

Private Sub Form2_Load(…) Handles MyBase.Load


Dim dt As New DataTable
formato()
Dim lstitem As ListViewItem
dt = clase.Lista_Cliente
For a As Integer = 0 To dt.Rows.Count - 1
lstitem = ListView1.Items.Add(dt.Rows(a)(0))
lstitem.SubItems.Add(dt.Rows(a)(1))
Next
End Sub
'Procedimiento que le da formato al ListView1
Sub formato()
With ListView1
.CheckBoxes = True 'Mostramos CheckBoxes en el ListView1
.View = View.Details 'Vista Detalle
.GridLines = True 'Lineas de separacion filas y columnas
.Columns.Add("Codigo del Cliente", 120, HorizontalAlignment.Center)
.Columns.Add("Nombre del Cliente", 300, HorizontalAlignment.Left)
End With
End Sub

Ahora vamos a programar en el botón para que nos muestre las facturas de
los clientes seleccionado
Private Sub BtnBuscar_Click(…) Handles BtnBuscar.Click
Dim cod, codigo As String
Dim tamaño As Integer
cod = ""
Try
For a As Integer = 0 To ListView1.Items.Count - 1
If (ListView1.CheckedItems(a).Checked = True) Then
cod = cod & "'" & ListView1.CheckedItems(a).Text & "',"
End If
Next
Catch ex As Exception
End Try
tamaño = cod.Length 'Tamaño de la cadena
'Le quitamos uno por la coma que sobra
codigo = Mid(cod, 1, tamaño - 1)

Dim dt As New DataTable


dt = clase.Facturas_varios_Clientes(codigo)
DataGridView1.DataSource = dt
'A la columna 2 le damos un ancho de 200
DataGridView1.Columns(2).Width = 200
End Sub

A continuación presionamos F5
Ejercicio Práctico Nro. 3

Lo primero que vamos a realizar es crear nuestros procedimientos


almacenados que vamos a utilizar.

use BDfactura
--LISTADO de las Facturas
create procedure Lista_Facturas
as
select fac_numero, convert(char(10),fac_fecha,103) Fecha from fac_cabe
go

--Detalle de las Facturas Seleccionadas


create procedure Lista_Detalle
@fac varchar(255)
as
select fac_numero,a.art_codigo,art_nombre,art_precio,art_cantidad,
(art_precio*art_cantidad) Total from articulos as a,fac_deta fd
where a.art_codigo=fd.art_codigo and fac_numero=@fac
go

Ahora a continuación vamos a abrir el Visual Studio 2005,


Ahora vamos a crear un Proyecto, para ellos nos vamos a Archivo y luego
seleccionamos Nuevo Proyecto CON EL NOMBRE DE

Ahora crearemos el siguiente diseño

Ahora nos vamos al primer DatagridView y en la parte superior, en la esquina


y le damos editar columnas
Ahora vamos agregar un LinkColumn y en sus propiedades ponemos

Ahora agregamos un campo para la fecha

Al final nos debe quedar de la siguiente manera


Una vez creado el diseño del formulario, ahora vamos agregar una clase a
nuestro proyecto.

Ahora a nuestra clase lo llamaremos clsconexion

En esta clase crearemos una función el cual me devuelva mi cadena de


conexión, y así poder usarla en todas las demás clases

Imports System.Data.SqlClient
Public Class clsconexion
Function cn() As String
Dim cadena As String
cadena = "Server=(local);Integrated Security=SSPI;"
cadena += "Database=bdfactura"
Return cadena
End Function
End Class

Ahora crearemos otra clase el cual llamaremos clsfunciones, ahí estarán


todos nuestros procedimientos almacenados, además llamaremos a nuestra
clase clsconexion.
Imports System.Data.SqlClient
Public Class clsfunciones
Dim clase As New clsconexion
Dim cn As New SqlConnection(clase.cn)
Function Listado_facturas() As DataTable
Dim da As New SqlDataAdapter("Lista_Facturas", cn)
Dim dt As New DataTable
da.Fill(dt)
Return dt
End Function

Function Detalle_Facturas(ByVal fac As String) As DataTable


Dim cmd As New SqlCommand("Lista_Detalle", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@fac", SqlDbType.VarChar).Value = fac

Dim da As New SqlDataAdapter(cmd)


Dim dt As New DataTable
da.Fill(dt)
Return dt
End Function
End Class

Ahora en el formulario vamos a llamar a nuestra clase

Public Class Link_datagridview


Dim funciones As New clsfunciones

Ahora programaremos para que cuando cargue el formulario me liste las


facturas

Private Sub Link_datagridview_Load(…) Handles MyBase.Load


Dim dt As New DataTable
dt = funciones.Listado_facturas
DataGridView1.DataSource = dt
End Sub

Ahora programaremos en el datagridView1


Private Sub DataGridView1_CellContentClick(…) Handles
DataGridView1.CellContentClick
'Pregunto si seleccionamos la 1ra columna
If (e.ColumnIndex = 0) Then
Dim p As Integer
p = DataGridView1.CurrentCell.RowIndex
Dim fac As String = DataGridView1(0, p).Value

Dim dt As New DataTable


dt = funciones.Detalle_Facturas(fac)
DataGridView2.DataSource = dt
End If
End Sub

Finalmente presionamos F5

Ejercicio Práctico Nro. 4

Almacenamiento de imágenes mediante carpeta.


Paso 1: Creación de Procedimientos Almacenados en una base de datos de su elección.

Create table EmpleadosImagen(


Emp_cod char(5) Primary key,
Emp_nom varchar(100),
)
Create procedure usp_EmpleadosImagen
As
Select * from Empleadosimagen
Go

Create procedure usp_busEmpleadosimagen


@Emp_cod char(5)
As
Select * from EmpleadosImagen Where Emp_cod=@Emp_cod
Go

Create procedure usp_generacodigoEmpleado


@Emp_cod varchar(5) Output
As
Set @Emp_cod=(select max(Emp_cod) from EmpleadosImagen)
Set @Emp_cod='E'+Right('0000'+ltrim(right(isnull(@Emp_cod,'00000'),4)+1),4)
Go

Declare @codigo char(5)


exec usp_generacodigoEmpleado @codigo output
print @codigo

Create procedure usp_insertarEmpleadoimagen


@Emp_cod char(5),@Emp_nom varchar(100)
As
Insert Into EmpleadosImagen values(@Emp_cod,@Emp_nom)
Go

Paso 2: Creación de Proyectos

Paso 3: Crear una carpeta en la unidad C para este ejemplo y guardar las imágenes ahí.
Unidad C:\imagenes

Paso 4: Código fuente en el proyecto Librería de Clase LibreriadeNegocio

Clase ClsFunciones.vb
Imports System.Data
Imports System.Data.SqlClient

Public Class Clsfunciones


Public cn As New SqlConnection("Server=(local);Integrated
Security=SSPI;Database=Neptuno")
Public Function MostrarEmpleados() As DataTable
Dim da As New SqlDataAdapter("usp_EmpleadosImagen", cn)
Dim tbl As New DataTable
da.Fill(tbl)
Return tbl
End Function

Public Function BusquedaEmpleado(ByVal emp_cod As String) As DataTable


Dim cmd As New SqlCommand("usp_busEmpleadosimagen", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@Emp_cod", SqlDbType.VarChar, 5).Value = emp_cod
cn.Open()
Dim tbl As New DataTable
tbl.Load(cmd.ExecuteReader(CommandBehavior.CloseConnection))
Return tbl
End Function

Public Function MostrarCodigoGenerado() As String


Dim cmd As New SqlCommand("usp_generacodigoEmpleado", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@Emp_cod", SqlDbType.VarChar, 5).Direction =
ParameterDirection.Output
cn.Open()
cmd.ExecuteNonQuery()
cn.Close()
Return cmd.Parameters("@Emp_cod").Value
End Function

Public Function GrabarEmpleado(ByVal emp_cod As String, ByVal emp_nom As String)


As Integer
Dim cmd As New SqlCommand("usp_insertarEmpleadoimagen", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@Emp_cod", SqlDbType.VarChar, 5).Value = emp_cod
cmd.Parameters.Add("@Emp_nom", SqlDbType.VarChar, 100).Value = emp_nom
cn.Open()
Dim nresp As Integer = cmd.ExecuteNonQuery()
cn.Close()
Return nresp
End Function
End Class

Paso 5: Creacion de la interfaz de la aplicación, sin olvidar referenciar el proyecto librería de


clase al proyecto Aplicación Windows.
Codigo Fuente:

Imports System.data

Public Class Form1


Dim obj As New LibreriadeNegocio.Clsfunciones
Dim rutafolderimagen As String = ""
Dim tblempl As DataTable

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs)


Handles MyBase.Load
lblcodigo.Text = obj.MostrarCodigoGenerado
MostrarImagen()
End Sub

Sub MostrarImagen()
DataGridView1.Columns.Clear()
tblempl = obj.MostrarEmpleados
DataGridView1.DataSource = tblempl
Dim colimag As New DataGridViewImageColumn
colimag.ImageLayout = DataGridViewImageCellLayout.Normal
DataGridView1.Columns.Add(colimag)
DataGridView1.Columns(2).HeaderText = "Foto"
For i As Integer = 0 To DataGridView1.Rows.Count - 1
DataGridView1.Item(2, i).Value = Image.FromFile("c:\imagenes\" + tblempl.Rows(i)(0)
+ ".jpg")
Next
DataGridView1.AutoResizeRows(DataGridViewAutoSizeRowsMode.AllCells)
End Sub

Private Sub CmdNuevo_Click(ByVal sender As System.Object, ByVal e As


System.EventArgs) Handles CmdNuevo.Click
lblcodigo.Text = obj.MostrarCodigoGenerado
txtnombres.Clear()
PictureBox1.Image = Nothing
End Sub

Private Sub CmdBuscarImagen_Click(ByVal sender As System.Object, ByVal e As


System.EventArgs) Handles CmdBuscarImagen.Click
Dim fileimagen As New OpenFileDialog
fileimagen.Filter = "Archivo imagen(*.bmp,*.jpg,*.gif)|*.jpg"
fileimagen.ShowDialog()
If String.IsNullOrEmpty(fileimagen.FileName) Then
MessageBox.Show("Seleccione una imagen", "Busqueda de Imagen")
Exit Sub
End If
rutafolderimagen = "c:\imagenes\"
Dim nombreimagen As String =
fileimagen.FileName.Substring(fileimagen.FileName.LastIndexOf("\") + 1)
PictureBox1.SizeMode = PictureBoxSizeMode.StretchImage
PictureBox1.Image = Image.FromFile(nombreimagen)
End Sub

Private Sub CmdGrabar_Click(ByVal sender As System.Object, ByVal e As


System.EventArgs) Handles CmdGrabar.Click
Try
If String.IsNullOrEmpty(txtnombres.Text) Then
MessageBox.Show("Ingrese un nombre del Empleado", "Empleado")
Exit Sub
End If
If PictureBox1.Image Is Nothing Then
MessageBox.Show("Seleccione una imagen", "Imagen")
Exit Sub
End If
Dim nresp As Integer = obj.GrabarEmpleado(lblcodigo.Text, txtnombres.Text)
If nresp = 1 Then
MessageBox.Show("El empleado ha sido registrado", "Registro")
End If
MostrarImagen()
Catch ex As Exception
MessageBox.Show(ex.Message)
End Try
End Sub

Private Sub CmdBusqueda_Click(ByVal sender As System.Object, ByVal e As


System.EventArgs) Handles CmdBusqueda.Click
Dim codigo As String = InputBox("Ingrese un codigo", "Busqueda de Empleados",
"E0001")
If String.IsNullOrEmpty(codigo) Then
MessageBox.Show("Ingrese un codigo de Empleado", "Busqueda de Empleado")
Exit Sub
End If
Dim tbl As DataTable = obj.BusquedaEmpleado(codigo)
lblcodigo.Text = tbl.Rows(0)(0).ToString
txtnombres.Text = tbl.Rows(0)(1).ToString
Dim mostrarimagen As String = ""
If rutafolderimagen = "" Then
mostrarimagen = "c:\imagenes\" + tbl.Rows(0)(0).ToString + ".jpg"
Else
mostrarimagen = rutafolderimagen + tbl.Rows(0)(0).ToString + ".jpg"
End If
PictureBox1.SizeMode = PictureBoxSizeMode.StretchImage
PictureBox1.Image = Image.FromFile(mostrarimagen)
End Sub

Private Sub CmdCerrar_Click(ByVal sender As System.Object, ByVal e As


System.EventArgs) Handles CmdCerrar.Click
If MessageBox.Show("Desea Salir", "Imagenes", MessageBoxButtons.YesNo,
MessageBoxIcon.Question) = 6 Then
Exit Sub
End If
End Sub
End Class

Ejercicios Propuestos

Desarrollar la siguiente aplicación con estas consideraciones:

Ejercicio 1:
Cuando cargue el formulario, se deber de mostrar en un listos 2 campos el
código y los nombres de los empleados.
Al seleccionar un ítem del listbox debe mostrar en el datagridview las 5
ordenes más caras pares, que se han emitido en los meses impares del
empleado seleccionado mostrando el total por orden emitida.

También debe mostrar la suma de toda la columna total del datagridview en


un label.
Ejercicio 2:

Cuando se cargue el formulario, se debe mostrar en un combobox, todos los


países de la tabla customers.

Cuando seleccione el país mostrara en un datagridview todas las ciudades


del país así como la cantidad de códigos postales de dicha ciudad.
Cuando seleccione la ciudad del datagridview debe mostrar en otro
datagridview todos los clientes que pertenecen a esa ciudad. (trabajar solo
con 4 campos ).
Ejercicio 3.

Realizar una búsqueda de clientes por una o más letras


coincidentes. El cual mostrara como resultado todos los clientes con su
cantidad de órdenes emitidas, al seleccionar una orden, deberá mostrar la
cantidad de órdenes en un listbox.
Semana 12 LIBRERÍA DE CLASES CON BD

Primero vamos a crear los procedimientos almacenados que vamos a utilizar


en el sql.
use bdfactura
go
----------Listado_Cliente----------------
--Creamos Ahora el Procedimiento
create Procedure Listado_Cliente
as
select cli_codigo,cli_nombre from Clientes
go
----------Facturas_Cliente----------------
--Creamos Ahora el Procedimiento
create Procedure Facturas_Cliente
@cod varchar(5)
as
select fac_numero from fac_cabe where cli_codigo=@cod
go
----------Detalle de la Factura-----------
--Creamos Ahora el Procedimiento
create procedure Detalle_Factura
@fac varchar(5)
as
select fac_numero,a.art_codigo,art_nombre,art_precio,art_cantidad,
(art_precio* art_cantidad) as Total
from Articulos as a, Fac_deta as fd
where a.art_codigo = fd.art_codigo
and fd.fac_numero=@fac
go

Lo primero que vamos a hacer es abrir el Visual Studio 2005,Ahora


crearemos una solución en blanco el cual contendrá 2 proyectos
Ahora crearemos una librería de clases, para ello agregaremos a la solución
un proyecto de librería de clases

Y ahora seleccionaremos

Ahora a nuestra clase le llamaremos clsclase

Ahora programaremos lo siguiente.

Imports System.Data.SqlClient

Public Class clsclase


Dim cn As New SqlConnection("Server=(local);Integrated
Security=SSPI;Database=bdfactura")

'Esta funcion me Listara a los clientes en el Combo


Function Lista_Cliente() As SqlDataReader
Dim dr As SqlDataReader : Dim cmd As New
SqlCommand("Listado_Cliente", cn)
cmd.CommandType = CommandType.StoredProcedure
cn.Open() : dr = cmd.ExecuteReader : Return dr
End Function

'Esta funcion nos mostrara la facturas del cliente


Function Facturas_Clientes(ByVal cod As String) As DataTable
'Si la conexion esta Abierta La cerramos
If (cn.State = ConnectionState.Open) Then
cn.Close()
End If
Dim cmd As New SqlCommand("Facturas_Cliente", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@cod", SqlDbType.VarChar).Value = cod
Dim da As New SqlDataAdapter(cmd) : Dim dt As New DataTable
da.Fill(dt) : Return dt
End Function

'Esta funcion nos mostrara el detalle de la facturas


Function Detalle_Factura(ByVal fac As String) As DataTable
'Si la conexion esta Abierta La cerramos
If (cn.State = ConnectionState.Open) Then
cn.Close()
End If
Dim cmd As New SqlCommand("Detalle_Factura", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@fac", SqlDbType.VarChar).Value = fac
Dim da As New SqlDataAdapter(cmd) : Dim dt As New DataTable :
da.Fill(dt)
Return dt
End Function
End Class

Una vez terminado de crear todas las funciones vamos a generar la DLL

Si nos damos cuenta, nuestro proyecto ha generado una DLL,


A continuación vamos agregar un Proyecto Windows en nuestra solución

Al cual le llamaremos Mi_Proyecto

A continuación agregaremos a nuestro proyecto la DLL que hemos creado,


para ello vamos agregar una referencia
Ahora buscamos nuestra DLL y le damos OK

Ahora importamos a nuestro Proyecto

Imports System.Data
Public Class Form1

Ahora instanciaremos el nombre de nuestra librería

Imports System.Data
Public Class Form1
Dim milibreria As New Libreria_Clases.clsclase

Ahora programaremos para que cuando cargue mi formulario me liste los


clientes
Private Sub Form1_Load(…) Handles MyBase.Load
Dim dr As SqlDataReader
dr = milibreria.Lista_Cliente
While (dr.Read)
Cbocliente.Items.Add(dr(0) & " " & dr(1))
End While
Cbocliente.SelectedIndex = 0
End Sub
Ahora programaremos en el combo
Private Sub Cbocliente_SelectedIndexChanged(…) Handles
Cbocliente.SelectedIndexChanged

Try
Dim cod As String
'Extraemos los 5 Primeros caracteres
cod = Mid(Cbocliente.Text, 1, 5)
'Ahora LLenaremos las Facturas del Cliente
Dim dt As New DataTable
dt = milibreria.Facturas_Clientes(cod)
With Lstcliente
.DataSource = dt
.ValueMember = "fac_numero"
.DisplayMember = "fac_numero"
.SelectedIndex = 0
End With
'Llamamos al Evento de Lstcliente_SelectedIndexChanged
Lstcliente_SelectedIndexChanged(sender, e)
Catch ex As Exception
End Try
End Sub

Y Finalmente programaremos en el Listbox

Private Sub Lstcliente_SelectedIndexChanged(…) Handles


Lstcliente.SelectedIndexChanged.

Try
'Capturamos el Valor del ListBox(Lstcliente)
Dim fac As String = Lstcliente.SelectedValue
Dim dt As New DataTable
dt = milibreria.Detalle_Factura(fac)
dgfacturas.DataSource = dt
Catch ex As Exception
End Try
End Sub

Finalmente presionamos F5 y nos debe salir de la siguiente manera:


Ejercicio Propuesto

Usando la base de datos Ventas

Proyecto Aplicación Windows

Utilizando la base de datos ventas, creara una aplicación que permita realizar un cálculo de
hora trabajadas de los empleados.
Tablas : Empleado, Empl_hor y días.

En el cálculo de horas usted considerara los minutos trabajados también.


Por ejemplo: Si el empleado Pedro trabajo los siguientes días:
Lunes: 8:10 AM – 15:30 PM -- Hora trabajadas: 7 horas y 20 minutos.
Martes: 8:20 AM – 15:30 PM – Horas trabajadas: 7 horas y 10 minutos.
Total de horas trabajadas: 14 horas 30 minutos.
Formulario Propuesto:

Nota: Para este ejemplo de la base de datos ventas, los empleados no tienen minutos de
tardanza y de salida. Pero usted considerara en su programación los minutos trabajados.
(Dado que en eso se basara la revisión del trabajo, modifique la tabla empl_hor, agregando
minutos de trabajos para ver el resultado).
Semana 13 y 14 Aplicaciones con 3 Capas
Ejercicio Práctico Nro. 1

Lo primero que vamos a realizar es crear los procedimientos almacenados


en SQL.
use BDFACTURA
go

----------Listado_Cliente----------------
-----------------------------------------
--Creamos Ahora el Procedimiento
create Procedure Listado_Cliente
as
select cli_codigo,cli_nombre,cli_telefono,cli_ruc,cli_direccion
from Clientes
go

----------Genera_Codigo----------------
-----------------------------------------
--Creamos Ahora el Procedimiento
Create procedure Genera_Codigo
@cod_cli char(5) Output
AS
Set @cod_cli=(Select Max(Cli_codigo) From Clientes)
set @cod_cli=isnull(@cod_cli,'0000')
Set @cod_cli='C'+right('0000'+rtrim(right(@cod_cli,4)+1),4)
Go
--Vamos a comprobar el Procedimiento
Declare @codigo char(5)
Exec Genera_Codigo @codigo Output
print @codigo
go

----------Grabar_Cliente----------------
-----------------------------------------
--Creamos Ahora el Procedimiento
create procedure Grabar_Cliente
@cod varchar(5),
@nom varchar(25),
@tel int,
@ruc varchar(11),
@dir varchar(30)
as
insert into clientes values(@cod,@nom,@tel,@ruc,@dir)
go
----------Actualizar_Cliente----------------
-----------------------------------------
--Creamos Ahora el Procedimiento
create procedure Actualizar_Cliente
@cod varchar(5),
@nom varchar(25),
@tel int,
@ruc varchar(11),
@dir varchar(30)
as
update clientes set cli_nombre=@nom,cli_telefono=@tel,
cli_ruc=@ruc,cli_direccion=@dir where cli_codigo=@cod
go
----------Eliminar_Cliente----------------
-----------------------------------------
--Creamos Ahora el Procedimiento
create procedure Eliminar_Cliente
@cod varchar(5)
as
delete from clientes where cli_codigo=@cod
go

Ahora vamos a crear una solución en blanco a la cual la llamaremos


Solucion 1

Ahora le agregamos una biblioteca de clases le llamaremos Capa De Datos

Por defecto este proyecto nos crea una clase, nosotros le cambiaremos de
nombre y lo llamaremos capa de datos

Ahora programaremos lo siguiente.

Imports System.Data.SqlClient

Public Class Capa_Datos


Dim cn As New SqlConnection("Server=(local);Integrated Security=yes;
Database=bdfactura")

Function D_Listado_Clientes() As DataTable


Dim da As New SqlDataAdapter("Listado_Cliente", cn)
Dim dt As New DataTable
da.Fill(dt)
Return dt
End Function

Function D_Grabar_Cliente(ByVal cod As String, ByVal nom As String, ByVal


tel As Integer, ByVal ruc As String, ByVal dir As String) As Integer
Dim cmd As New SqlCommand("Grabar_Cliente", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@cod", SqlDbType.VarChar).Value = cod
cmd.Parameters.Add("@nom", SqlDbType.VarChar).Value = nom
cmd.Parameters.Add("@tel", SqlDbType.Int).Value = tel
cmd.Parameters.Add("@ruc", SqlDbType.VarChar).Value = ruc
cmd.Parameters.Add("@dir", SqlDbType.VarChar).Value = dir
cn.Open()
Dim p As Integer = 0
p = cmd.ExecuteNonQuery
Return p
End Function

Function D_Actualizar_Cliente(ByVal cod As String, ByVal nom As String,


ByVal tel As Integer, ByVal ruc As String, ByVal dir As String) As Integer
Dim cmd As New SqlCommand("Actualizar_Cliente", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@cod", SqlDbType.VarChar).Value = cod
cmd.Parameters.Add("@nom", SqlDbType.VarChar).Value = nom
cmd.Parameters.Add("@tel", SqlDbType.Int).Value = tel
cmd.Parameters.Add("@ruc", SqlDbType.VarChar).Value = ruc
cmd.Parameters.Add("@dir", SqlDbType.VarChar).Value = dir
cn.Open()
Dim p As Integer = 0
p = cmd.ExecuteNonQuery
Return p
End Function

Function D_Eliminar_Cliente(ByVal cod As String) As Integer


Dim cmd As New SqlCommand("Eliminar_Cliente", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@cod", SqlDbType.VarChar).Value = cod
cn.Open()
Dim p As Integer = 0
p = cmd.ExecuteNonQuery
Return p
End Function
Function D_Genera_Codigo() As String
Dim cmd As New SqlCommand("Genera_Codigo", cn)
cmd.CommandType = CommandType.StoredProcedure
Dim paramResultado As SqlParameter = New SqlParameter("@cod_cli",
SqlDbType.Char, 5)
paramResultado.Direction = ParameterDirection.Output
cmd.Parameters.Add(paramResultado)
cn.Open()
cmd.ExecuteReader()
cn.Close()
Return paramResultado.Value
End Function
End Class

Ahora vamos a generar el proyecto

Ahora a la solución que creamos anteriormente, ahora agregaremos otro


proyecto

Ahora a este proyecto le llamaremos Capa de Negocio


Al final debe quedar de la siguiente manera

Ahora al proyecto capa de negocio hay que agregar una referencia, para ello
seleccionamos Capa_Negocio y le damos clic derecho

Ahora seleccionamos la DLL generada en la capa de datos


Ahora en la capa de negocio programaremos lo siguiente.

Imports System.Data.SqlClient

Public Class Capa_Negocio


'Ahora referenciamos a la capa de datos
Dim objdatos As New Capa_Datos.Capa_Datos

Function N_Listado_Clientes() As DataTable


Return objdatos.D_Listado_Clientes()
End Function

Function N_Grabar_Cliente(ByVal cod As String, ByVal nom As String, ByVal


tel As Integer, ByVal ruc As String, ByVal dir As String) As Integer
Return objdatos.D_Grabar_Cliente(cod, nom, tel, ruc, dir)
End Function

Function N_Actualizar_Cliente(ByVal cod As String, ByVal nom As String,


ByVal tel As Integer, ByVal ruc As String, ByVal dir As String) As Integer
Return objdatos.D_Actualizar_Cliente(cod, nom, tel, ruc, dir) : End Function

Function N_Eliminar_Cliente(ByVal cod As String) As Integer


Return objdatos.D_Eliminar_Cliente(cod)
End Function

Function N_Genera_Codigo() As String


Return objdatos.D_Genera_Codigo()
End Function
End Class

Ahora a la solución agregaremos un proyecto y lo llamaremos Capa de


Presentación.
Ahora en la capa de presentación agregaremos la referencia

Seleccionamos

Ahora tenemos que configurar para que se ejecute desde la capa de


presentación
Ahora agregaremos un

Ahora vamos a editar el ToolStrip, para ello seleccionamos el ToolStrip y le


damos clic derecho
Ahora agregaremos 5 botones

En sus propiedades a cada botón escogeremos

Name btnnuevo
ToolTipText Nuevo
Image Seleccionamos una
imagen

Al final nos debe quedar de la siguiente manera

Ahora vamos a importar a la capa de negocio

Public Class Form1


Dim objnegocio As New Capa_Negocio.Capa_Negocio

Ahora programaremos para que cuando cargue el formulario me liste los


Clientes
Private Sub Form1_Load(…) Handles MyBase.Load
listado()
End Sub

Sub listado()
Dim dt As New DataTable
dt = objnegocio.N_Listado_Clientes
DataGridView1.DataSource = dt
End Sub

Ahora programaremos en el botón Nuevo

Private Sub btnnuevo_Click(…) Handles btnnuevo.Click


Dim ctrl As New Control
'recorremos todos los controles que estan dentro
'del GroupBox1
For Each ctrl In GroupBox1.Controls
'Preguntamos si es TextBox
If TypeOf ctrl Is TextBox Then
ctrl.Text = ""
End If
Next
Dim codigo As String : codigo = objnegocio.N_Genera_Codigo
lblcod.Text = codigo : txtnom.Focus()
End Sub

Ahora programaremos en el botón Grabar

Private Sub btnGrabar_Click(…) Handles btnGrabar.Click


If (MsgBox("Desea Grabar", 4 + 32, "Mensaje Sistema") = 6) Then
Dim cod, nom, ruc, dir As String : Dim tel As Integer
cod = lblcod.Text : nom = txtnom.Text : ruc = txtruc.Text
dir = txtdir.Text : tel = CInt(txttel.Text) : Dim p As Integer
p = objnegocio.N_Grabar_Cliente(cod, nom, tel, ruc, dir)
If (p > 0) Then
MsgBox("Se Grabo Correctamente", 32, "Mensaje del Sistema")
listado()
Else
MsgBox("Error al Grabar", 4, "Mensaje del Sistema")
End If
End If
End Sub

Ahora programaremos para que cuando seleccionemos el DataGridView1


pasen los datos a las cajas de textos.
Private Sub DataGridView1_CellClick(…) Handles DataGridView1.CellClick
Try
Dim f As Integer
'capturamos la fila seleccionada
f = DataGridView1.CurrentCell.RowIndex
lblcod.Text = DataGridView1(0, f).Value : txtnom.Text =
DataGridView1(1, f).Value
txttel.Text = DataGridView1(2, f).Value : txtruc.Text =
DataGridView1(3, f).Value
txtdir.Text = DataGridView1(4, f).Value
Catch ex As Exception : End Try
End Sub

Ahora programaremos en el botón Modificar

Private Sub btnmodificar_Click(…) Handles btnmodificar.Click


If (MsgBox("Desea Modificar", 4 + 32, "Mensaje") = 6) Then
Dim cod, nom, ruc, dir As String : Dim tel As Integer
cod = lblcod.Text : nom = txtnom.Text
ruc = txtruc.Text : dir = txtdir.Text : tel = CInt(txttel.Text) : Dim p As
Integer
p = objnegocio.N_Actualizar_Cliente(cod, nom, tel, ruc, dir)
If (p > 0) Then
MsgBox("Se Modifico Correctamente", 32, "Mensaje Sistema")
listado()
Else
MsgBox("Error al Modificar", 4, "Mensaje Sistema")
End If
End If
End Sub

Ahora programaremos en el botón Eliminar

Private Sub btneliminar_Click(…) Handles btneliminar.Click


If (MsgBox("Desea Eliminar", 4 + 32, "Mensaje") = 6) Then
Dim cod As String
cod = lblcod.Text
Dim p As Integer
p = objnegocio.N_Eliminar_Cliente(cod)
If (p > 0) Then
MsgBox("Se Elimino Correctamente", 32, "Mensaje")
listado()
Else
MsgBox("Error al Elimino", 4, "Mensaje")
End If
End If
End Sub
Y por ultimo programaremos en botón Salir

Private Sub btnSalir_Click(…) Handles btnSalir.Click


Me.Close()
End Sub

Finalmente le damos F5

Ejercicio Práctico Nro. 2

Lo primero que vamos a realizar es crear los procedimientos almacenados


en SQL.

use BDfactura
----Facturas Realizadas

create procedure Lista_Facturas


as
select fac_numero, convert(char(10),fac_fecha,103) Fecha
from fac_cabe
go

--Detalle de las Facturas Seleccionadas


set quoted_identifier off
go

create procedure Lista_Detalle


@fac varchar(255)
as
exec("select fac_numero,a.art_codigo,art_nombre,art_precio,art_cantidad,
(art_precio*art_cantidad) Total
from articulos as a,fac_deta fd where a.art_codigo=fd.art_codigo
and fac_numero in ("+@fac+")")
go

--probamos el procedimiento
Lista_Detalle "'F0001','F0002','F0003'"

Ahora en el visual Studio vamos a crear una nueva solución en blanco la


cual le ponemos el nombre de Consulta_Solucion.
Dentro de la solución, ahora agregaremos un proyecto de biblioteca de
clases, la cual llamaremos Capa de Datos

Ahora programaremos lo siguiente.

Imports System.Data.SqlClient

Public Class Capa_Dato


Dim cn As New SqlConnection("Server=(local);Integrated
Security=yes;Database=bdfactura")

Function D_Facturas_Clientes() As DataTable


Dim da As New SqlDataAdapter("Lista_Facturas", cn)
Dim dt As New DataTable : da.Fill(dt) : Return dt
End Function
Function D_Detalle_Facturas(ByVal fac As String) As DataTable
Dim cmd As New SqlCommand("Lista_Detalle", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@fac", SqlDbType.VarChar).Value = fac
Dim da As New SqlDataAdapter(cmd) : Dim dt As New DataTable :
da.Fill(dt)
Return dt
End Function
End Class

Y una vez generado la capa de datos, ahora a la solución agregaremos un


proyecto y lo llamaremos capa_negocio

Ahora al proyecto capa de negocio agregaremos una referencia que es la


Capa_Datos

Ahora programaremos lo siguiente


Public Class Capa_Negocio
Dim objdatos As New Capa_Datos.Capa_Dato

Function N_Facturas_Clientes() As DataTable


Return objdatos.D_Facturas_Clientes()
End Function

Function N_Detalle_Facturas(ByVal fac As String) As DataTable


Return objdatos.D_Detalle_Facturas(fac)
End Function
End Class

Una vez generado la capa de negocio, ahora agregaremos un proyecto a la


solución, la llamaremos Capa de presentación

Ahora realizaremos el siguiente diseño

A continuación a la capa de presentación le agregaremos una referencia que


es la Capa_Negocio
Lo primero que debemos hacer es realizar la referencia de la capa de
negocio

Public Class Form1


Dim objnegocio As New Capa_Negocio.Capa_Negocio

Ahora programaremos para que cuando cargue el formulario nos liste las
facturas realizadas
Private Sub Form1_Load(…) Handles MyBase.Load
Dim dt As New DataTable
dt = objnegocio.N_Facturas_Clientes()
CheckedListBox1.MultiColumn = True
For a As Integer = 0 To dt.Rows.Count - 1
CheckedListBox1.Items.Add(dt.Rows(a)(0))
Next
End Sub

Ahora programaremos en el botón Ver Facturas


Private Sub btnver_Click(…) Handles btnver.Click
Dim cod, codigo, fac As String
Dim tamaño As Integer
fac = "" : cod = ""

For a As Integer = 0 To CheckedListBox1.Items.Count - 1


If (CheckedListBox1.GetItemChecked(a) = True) Then
fac += "'" & CheckedListBox1.Items.Item(a).ToString.Trim & "',"
End If
Next

tamaño = fac.Length 'Tamaño de la cadena


If (tamaño > 0) Then
'Le quitamos uno por la coma que sobra
codigo = Mid(fac, 1, tamaño - 1)
Dim dt As New DataTable
dt = objnegocio.N_Detalle_Facturas(codigo)
DataGridView1.DataSource = dt
End If
End Sub

Finalmente presionamos F5

Ejercicio Práctico Nro. 3

Lo primero que vamos a realizar es crear los procedimientos almacenados


en SQL.
use bdfactura

create procedure Lista_Ranking


@cant int
as
if @cant=0 --Si es Cero nos mostrara todos los Clientes con
--sus respectivas cantidades de Facturas
select c.cli_codigo,cli_nombre,count(fac_numero) Total_ventas from clientes
as c, fac_cabe as fc where c.cli_codigo=fc.cli_codigo group by
c.cli_codigo,cli_nombre
order by Total_ventas desc
else
--Nos mostrar solo las cantidades de clientes que se le envia como
parametro
select top (@cant) with ties c.cli_codigo,cli_nombre, count(fac_numero)
Total_ventas from clientes as c, fac_cabe as fc where
c.cli_codigo=fc.cli_codigo
group by c.cli_codigo,cli_nombre order by Total_ventas desc
go

-----Mostrar las Facturas por Cliente


create procedure Mostrar_Facturas
@cod varchar(5)
as
select fac_numero,convert(char(10),fac_fecha,103) Fecha,fac_total
from fac_cabe as fc,clientes as c where c.cli_codigo=fc.cli_codigo and
c.cli_codigo=@cod
go

Ahora en el visual Studio vamos a crear una nueva solución en blanco


llamada Consulta_Solucion Dentro de la solución, ahora agregaremos un
proyecto de biblioteca de clases, la cual llamaremos Capa de Datos
Ahora a la capa de datos vamos a crear una clase la cual contendrá mi
conexión a la BD
Y lo llamaremos Clsconexion Ahora programaremos lo siguiente

Imports System.Data
Public Class Clsconexion
Public Function conexion_SQL() As String
Dim cn As String
cn = "Server=(local);Integrated Security=yes;Database=bdfactura"
Return cn
End Function
End Class

Ahora agregaremos una clase más a la biblioteca Capa_Datos y la


llamaremos D_datos
Y ahora programaremos lo siguiente.

Imports System.Data.SqlClient

Public Class D_Datos


Dim cone As New Clsconexion
'cone.conexion_SQL llamamos a la Cadena de conexion que hicimos „en la
clase Clsconexion
Dim cn As New SqlConnection(cone.conexion_SQL)

Function D_Muestra_Ranking(ByVal cant As Integer) As DataTable


Dim cmd As New SqlCommand("Lista_Ranking", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@cant", SqlDbType.Int).Value = cant
Dim da As New SqlDataAdapter(cmd) : Dim dt As New DataTable
da.Fill(dt) : Return dt
End Function

Function D_Facturas_Cliente(ByVal codcli As String) As DataTable


Dim cmd As New SqlCommand("Mostrar_Facturas", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@cod", SqlDbType.VarChar).Value = codcli
Dim da As New SqlDataAdapter(cmd) : Dim dt As New DataTable
da.Fill(dt) : Return dt
End Function
End Class

Ahora en la solución creada vamos agregar otra biblioteca de clases la


llamaremos capa_Negocio
Ahora en la capa de negocio agregaremos una referencia que vine de la capa
de Datos

Ahora programaremos lo siguiente

Public Class Capa_Negocio


Dim objdato As New Capa_Datos.D_Datos

Function N_Muestra_Ranking(ByVal cant As Integer) As DataTable


Return objdato.D_Muestra_Ranking(cant)
End Function

Function N_Facturas_Cliente(ByVal codcli As String) As DataTable


Return objdato.D_Facturas_Cliente(codcli)
End Function
End Class

Luego de haber generado la capa de negocio, ahora a la solución


agregaremos un proyecto y la llamaremos capa Presentación
A continuación realizaremos el siguiente diseño

Ahora en la capa de presentación agregaremos la referencia de la


capa_Negocio

Lo primero que debemos hacer en el formulario es hacer la referencia de la


capa_Negocio

Public Class Form1


Dim objnegocio As New Capa_Negocio.Capa_Negocio
Ahora vamos a programar para darle valores máximos y mínimos del
NumericUpDown1

Private Sub Form1_Load(…) Handles MyBase.Load


'Vamos a darle El maximo y minimo valor al NumericUpDown1
NumericUpDown1.Maximum = 10
NumericUpDown1.Minimum = 1
End Sub

Ahora programaremos en el botón Filtrar

Private Sub btnfiltrar_Click(…) Handles btnfiltrar.Click


Dim cant As Integer
If (rbtodos.Checked = True) Then
cant = 0
Else
cant = NumericUpDown1.Value
End If

Dim dt As New DataTable


dt = objnegocio.N_Muestra_Ranking(cant)
DataGridView1.DataSource = dt
End Sub

Ahora programaremos en el DatagridView1 para que cuando le demos Clic


nos muestre las facturas en el DatagridView2

Private Sub DataGridView1_CellClick(…) Handles


DataGridView1.CellClick

Dim p As Integer
p = DataGridView1.CurrentCell.RowIndex
Dim cod As String = DataGridView1(0, p).Value
Dim dt As New DataTable
dt = objnegocio.N_Facturas_Cliente(cod)
DataGridView2.DataSource = dt
End Sub

Ahora presionamos F5
Ejercicio Práctico Nro. 4

Lo primero que vamos a realizar es crear los procedimientos almacenados


en SQL
use bdfactura
go
----------Listado_Cliente----------------
-----------------------------------------
--Creamos Ahora el Procedimiento
create Procedure Listado_Cliente
as
select cli_codigo,cli_nombre from clientes where cli_codigo in(select distinct
cli_codigo from fac_cabe)
go
----------Facturas_Varios_Cliente----------------
-----------------------------------------
--Habilita el uso de las comillas
set quoted_identifier off
go

--Creamos Ahora el Procedimiento


create Procedure Facturas_Varios_Cliente
@codigos varchar(255)
as
exec("select fac_numero,c.cli_codigo,cli_nombre "+
"from fac_cabe as fc,clientes as c where fc.cli_codigo=c.cli_codigo and "+
"c.cli_codigo in(" +@codigos +") "+
"order by c.cli_codigo asc")
go

--Probamos el Proc Almacenado


Facturas_Varios_Cliente "'C0001','C0002','C0003'"
Ahora en el visual Studio vamos a crear una nueva solución en blanco
llamada Consulta_Solucion.

Dentro de la solución, ahora agregaremos una biblioteca de clases, la cual


llamaremos Capa de Datos

Ahora a la capa de datos vamos a crear una clase la cual contendrá mi


conexión a la BD con el nombre de Clsconexion

Ahora programaremos lo siguiente

Imports System.Data

Public Class Clsconexion


Public Function conexion_SQL() As String
Dim cn As String
cn = "Server=(local);Integrated Security=yes;Database=bdfactura"
Return cn
End Function
End Class

Ahora agregaremos una clase más a la biblioteca y la llamaremos D_datos


Y ahora programaremos lo siguiente

Imports System.Data.SqlClient
Public Class D_Datos
Dim cone As New Clsconexion
'cone.conexion_SQL llamamos a la Cadena de conexion que hicimos „en la clase
Clsconexion
Dim cn As New SqlConnection(cone.conexion_SQL)

Function D_Lista_Cliente() As DataTable


Dim da As New SqlDataAdapter("Listado_Cliente", cn)
Dim dt As New DataTable
da.Fill(dt)
Return dt
End Function

Function D_Fact_Cli_Varios(ByVal codcli As String) As DataTable


Dim cmd As New SqlCommand("Facturas_Varios_Cliente", cn)
cmd.CommandType = CommandType.StoredProcedure
cmd.Parameters.Add("@codigos", SqlDbType.VarChar).Value = codcli
Dim da As New SqlDataAdapter(cmd)
Dim dt As New DataTable
da.Fill(dt)
Return dt
End Function
End Class
Una vez generada la capa de datos, Ahora en la solución creada vamos
agregar otra biblioteca de Clases y la llamaremos capa_Negocio
Ahora en la capa de negocio agregaremos una referencia que vine de la capa
de Datos

Ahora programaremos lo siguiente

Public Class Capa_Negocio


Dim objdato As New Capa_Datos.D_Datos

Function N_Lista_Cliente() As DataTable


Return objdato.D_Lista_Cliente()
End Function

Function N_Fact_Cli_Varios(ByVal codcli As String) As DataTable


Return objdato.D_Fact_Cli_Varios(codcli)
End Function
End Class

Luego de haber generado la capa de negocio, ahora a la solución


agregaremos un proyecto y la llamaremos capa Presentación

A continuación realizaremos el siguiente diseño


Ahora en la capa de presentación agregaremos la referencia de la
capa_Negocio
Ahora realizaremos una referencia a la capa de Negocio

Public Class Form1


Dim objnegocio As New Capa_Negocio.Capa_Negocio

Ahora programaremos para Listar los clientes a penas cargue el formulario

Private Sub Form1_Load(…) Handles MyBase.Load


Dim dt As New DataTable
formato()
Dim lstitem As ListViewItem
dt = objnegocio.N_Lista_Cliente()
For a As Integer = 0 To dt.Rows.Count - 1
lstitem = ListView1.Items.Add(dt.Rows(a)(0))
lstitem.SubItems.Add(dt.Rows(a)(1))
Next
End Sub

Sub formato() 'Formato del ListView1


With ListView1
.CheckBoxes = True 'Mostramos CheckBoxes en el ListView1
.View = View.Details 'Vista Detalle
.GridLines = True 'Muestre Lineas de separacion entre filas y columnas
.Columns.Add("Codigo del Cliente", 120, HorizontalAlignment.Center)
.Columns.Add("Nombre del Cliente", 250, HorizontalAlignment.Left)
End With
End Sub

Ahora programaremos en el Botón Ver Facturas


Private Sub Btnver_Click(…) Handles Btnver.Click
Dim cod, codigo As String
Dim tamaño As Integer
cod = ""
Try

For a As Integer = 0 To ListView1.Items.Count - 1


If (ListView1.CheckedItems(a).Checked = True) Then
cod = cod & "'" & ListView1.CheckedItems(a).Text & "',"
End If
Next
Catch ex As Exception
End Try

tamaño = cod.Length 'Tamaño de la cadena


'Le quitamos uno por la coma que sobra
codigo = Mid(cod, 1, tamaño - 1)
Dim dt As New DataTable : dt = objnegocio.N_Fact_Cli_Varios(codigo)
DataGridView1.DataSource = dt
'A la columna 2 le damos un ancho de 200
DataGridView1.Columns(2).Width = 200
End Sub

Finalmente presionamos F5
Ejercicios Propuestos
Aplicación 1:

Realizar el siguiente programa siguiente las siguientes consideraciones:


Cuando inicie el programa, se deberá demostrar en el Combobox1 (CboAño)
los años que fueron emitidas todas las ordenes, a la vez agregara los
elementos al Lisbox1 (A-C,E-G,H-KI,L-O,P-S,T-Z), el cual se deberá demostrar
por columnas, y por ultimo creara la estructura del Listview1 con los campos
(ProductID,CompanyName,UnitPrice,Quantity,Total).

Cuando seleccione ambos parámetros un año y un rango de letras y haga


clic en el botón Buscar Clientes por …, se deberá demostrar en el Listbox2
los clientes que le fueron emitidas sus órdenes.
Cuando seleccione un cliente del Listbox2, se deberá demostrar en el
Listbox3 las ordenes pares que le fueron emitidas al cliente seleccionado,
mostrara los siguientes campos concatenados
(OrderID,OrderID,ShippedDate,Dias_Envio (Diferencia en días de ambos
campos fechas)).

Y cuando seleccione un elemento del Listbox3, deberá de capturar la orden


emitida, y deberá demostrar en el Listview1, su detalle de venta de esa
orden.
Aplicación 2:

Se pide a usted que cree una aplicaron que permita realizar una consulta de
datos bajo las siguientes consideraciones:

Cuando seleccione cualquier Radiobuttons, deberá demostrar todos los


Customers que se encuentran mediante el rango de letras seleccionado.

Antes de presionar el botón Búsqueda de Ordenes, deberá de tener como


parámetro el código del Customers seleccionado, y las fechas ingresadas. Y
deberá demostrar como resultado en el ListView1, todas las Ordenes
emitidas por los parámetros dados, mostrando los siguientes campos bajo
las siguientes consideraciones:

El campo OrderID.
El campo RequiredDate, que es la fecha que se requería el producto.
Creara un campo TotalVenta, que es la suma del producto de UnitPrice *
Quantity.

Creara un campo DiasEnvio, que es la diferencia de ShippedDate –


OrderDate.

Creara un campo EstadoEnvio, que viene a mostrar un mensaje bajo el


siguiente criterio:

Si los días de envió es mayor o igual a 10, entonces “Fuera de fecha”.

Si los días de envió es menor de 10, entonces “Entrega inmediata”.

Y por ultimo al seleccionar una fila del ListView1, deberá de capturar el


número de orden, que le servirá como parámetro para mostrar todos los
productos vendidos por esa orden seleccionada en el ListView2, mostrando
los campos de la imagen.
Semana 16 CREACIÓN DE REPORTES

Crystal Reports se conecta a bases de datos mediante


controladores de bases de datos. Cada controlador se escribe para
controlar un tipo de base de datos específico o la tecnología de acceso
a bases de datos.

Modelos de extracción e inserción:

Con el fin de ofrecer el acceso a datos más flexible para los


programadores, los controladores de base de datos de Crystal Reports
se han diseñado para proporcionar un modelo de extracción e
inserción de acceso a datos.

Modelo de extracción

En un modelo de extracción, el controlador se conectará a la base


de datos y extraerá datos cuando se necesiten. Con este modelo,
Crystal Reports controla tanto la conexión a la base de datos como el
comando SQL que se ejecuta para obtener los datos y no necesita
ninguna codificación del programador. Si no se escribe ningún código
especial en tiempo de ejecución, se utiliza el modelo de extracción.
Modelo de inserción

En comparación, el modelo de inserción necesita que el


programador escriba código para conectarse a la base de datos,
ejecutando un comando SQL para crear un conjunto de registros o de
datos que se ajusten a los campos del informe y enviando ese objeto al
informe. Este método le permite crear recursos compartidos de
conexión en la aplicación y filtrar los datos antes de que Crystal
Reports los reciba.

Los controladores de bases de datos se utilizan durante el tiempo


de creación y de procesamiento.

Durante el tiempo de creación, el controlador de la base de datos


se utiliza para identificar el esquema de los datos. Con los
controladores OLEDB, ODBC y Access/Excel, este proceso implica la
conexión a una base de datos y la selección de las tablas, vistas o
procedimientos almacenados para especificar el esquema. Con los
controladores ADO.NET y de definición de campos, este proceso
implica la selección de un esquema con la forma de un archivo XML
(*.xml) o de un archivo de definición de datos (*.ttx).

Durante el tiempo de procesamiento, el informe utilizará el mismo


controlador de base de datos utilizado para crear el informe. No
obstante, si los datos se insertan en el informe, el informe seleccionará
el controlador adecuado para controlar el conjunto de registros o el
conjunto de datos.

Controladores de bases de datos con Crystal Reports para Visual Studio


.NET.

Controlador de Base de datos a las que se Método de acceso a datos


base de datos tiene acceso
OLEDB Cualquier base de datos Admite tanto la extracción
que tenga un proveedor de datos de la base de datos
OLEDB. como la inserción de datos
en el informe de un conjunto
de registros ADO.

ODBC Cualquier base de datos Admite tanto la extracción


que tenga un proveedor de datos de la base de datos
ODBC. como la inserción de datos
en el informe de un conjunto
de registros RDO.

Access/Excel Bases de datos de Admite tanto la extracción


Microsoft Access y libros de datos de la base de datos
de Microsoft Excel. como la inserción de datos
en el informe de un conjunto
de registros DAO.
ADO.NET Cualquier base de datos Admite la inserción de datos
con un proveedor en el informe desde un
gestionado. conjunto de datos ADO.NET.

Este controlador
no extraerá datos por
sí mismo.

Definición de Ninguna. El controlador se incluye


campo principalmente para la
compatibilidad con
Este controlador versiones anteriores y sólo
especial se utiliza se utiliza durante el proceso
de creación de informes.
para crear informes
basados únicamente En tiempo de
en un esquema sin ejecución, debe
datos reales. enviarse un conjunto
de registros o un
conjunto de datos a un
informe creado con el
controlador.

Objeto de datos Ninguna. Este controlador se incluye


Crystal (CDO) principalmente para la
compatibilidad con
Este controlador versiones anteriores.
especial obtiene
acceso a datos que Este controlador
no residen en una sólo admite la
base de datos inserción de datos en
tradicional. un informe desde un
conjunto de registros
CDO; no extraerá datos
por sí mismo. Utilice la
biblioteca de objetos
de datos Crystal para
llenar un conjunto de
registros CDO.

Nota Este controlador no


está disponible durante el
período de creación del
informe. Seleccione uno de
los controladores
disponibles para crearlo.

REPORTES EN .NET CON CRYSTAL REPORTS

Visual Studio .NET incluye Crystal Reports como un mecanismo "oficial" de


creación de reportes. Crystal Reports es un producto muy desarrollado y
complejo para la creación de reportes, y cuenta con una infinidad de
opciones. En este artículo, nos vamos a concentrar en crear reportes
relativamente sencillos, pero mostrando los detalles específicos de la
versión .NET, tanto en aplicaciones WinForms como en aplicaciones
WebForms (ASP.NET). Este artículo considera que usted ya posee alguna
familiaridad con Visual Studio .NET y también con ADO.NET.

Crear un reporte:

Independientemente de cómo se hará la presentación, el reporte se define en


un archivo ".RPT", que forma parte de su proyecto. Ese archivo especifica el
modo en que se hará la presentación del reporte, pero no incluye los datos
propiamente dichos. Los datos se definirán en el tiempo de ejecución.
Crystal Reports se basa en un concepto muy común de la definición de
reportes: los reportes se componen de "secciones", y cada sección es un
espacio horizontal en la página. Existen diversos tipos de secciones, por
ejemplo:

Encabezado del reporte, aparece en la primera página.


Encabezado de página, aparece en la parte superior de todas las páginas.
Detalle: lo más importante. En el tiempo de ejecución, se genera una de
estas secciones para cada línea (registro) en la base de datos.
Pie de página, aparece en la parte inferior de todas las páginas.
Pie de reporte, aparece al final del reporte.
En un principio, todos los reportes presentan estas cinco secciones. Otras
secciones son opcionales, como por ejemplo:
Encabezado de grupo, aparece antes de un grupo.
Pie de grupo, aparece al final del grupo.
Se podrá omitir una o más secciones, en caso de que no sean necesarias.
Acceder a la base de datos.

Antes de crear el reporte, hay que decidir cuál será el mecanismo utilizado
para acceder a la base de datos. Crystal Reports puede obtener datos de una
infinidad de fuentes, pero una buena cantidad de ellas, como DAO, ADO y
OLE/DB, no está "administrada", o sea, es código .NET "puro". En una
aplicación .NET, probablemente sea deseable realizar el acceso a través de
ADO.NET. Para ello, lo más fácil es definir un Conjunto de datos tipificado,
aun antes de crear el reporte.

Ejercicio Práctico Nro. 1

Primero vamos a crear nuestro procedimiento almacenado en el SQL


Use northwind
go

Create procedure Lista_Clientes


as
select CustomerID,CompanyName,ContactName,ContactTitle
from customers
go
Ahora si ejecutamos nuestro procedimiento almacenado nos listara todos
los clientes

Ahora lo que haremos es aprender a mostrar esos clientes en un reporte,


para ello lo primero que realizaremos es crear un proyecto
Ahora en nuestro proyecto agregamos un CrystalReportViewer a nuestro
formulario

Al final nos deberá quedar de la siguiente manera

Ahora en el proyecto le damos clic derecho y agregamos lo siguiente

A Continuación vamos aceptar la licencia del CrystalReports


Ahora seleccionamos

Ahora lo que vamos a realizar es establecer la conexión a la BD


A continuación seleccionamos el proveedor de la BD, en este caso es el SQL
Server

Ahora configuramos para seleccionar

Y por ultimo le damos Finalizar


Ahora seleccionamos los procedimientos almacenados que puedan existir
en la BD

Dentro de los procedimientos almacenados, seleccionamos el procedimiento


almacenado que hemos creado y le damos siguiente.

Como nos damos cuenta nos salen los campos que va a visualizar nuestro
procedimiento almacenado, ahora vamos a seleccionar los campos a
vizualizar
Una vez agregado los campos, le damos siguiente

Como no vamos agruparlo, le damos finalizar.

Y nos quedara de la siguiente manera


Ahora si queremos cambiar el formato de las etiquetas, le damos Clic
derecho

Le damos el respectivo formato y finalmente Aceptar

Nos quedara de la siguiente manera


Ahora vamos agregar un titulo general a nuestro Reporte, para ello

Y finalmente nos quedara de la siguiente manera

Si queremos ver cómo va quedando nuestro reporte, le damos en


Ahora en muestro formulario programaremos en el evento Load, para que
nos muestre nuestro reporte, y a la vez vamos a deshabilitar para que no
aparezca el DisplayGroupTree

Ahora programaremos lo siguiente

Private Sub Form1_Load(…) Handles MyBase.Load


'vamos a instanciar el nombre de nuestro Reporte Creado
Dim rpt As New Rpt_Clientes
'Pasamos nuestro reporte creado al CrptReporte
CrptReporte.ReportSource = rpt
'Desabilitamos la vizualizacion en grupos
CrptReporte.DisplayGroupTree = False
End Sub

Finalmente presionamos F5 y nos deberá mostrar


Ejercicio Práctico Nro. 2

Primero vamos a crear nuestro procedimiento almacenado en el SQL

use northwind
go
-----------------Si existe lo Eliminamos--------------
set dateformat dmy --formato dia,mes,año
go
-----------------Creamos el Procedimiento-------------
create procedure Listado_Ordenes
@fe1 datetime,
@fe2 datetime
as
select OrderID,c.CustomerID,CompanyName,convert(char(10),
OrderDate,103) as Fecha
from orders as o,Customers as c
where OrderDate between @fe1 and @fe2
and c.CustomerID=o.CustomerID
order by Fecha desc
go
Listado_Ordenes '01-07-1996','30-07-1996'

Ahora si ejecutamos nuestro procedimiento


Ahora lo que haremos es aprender a mostrar esos clientes en un reporte,
para ello lo primero que realizaremos es crear un proyecto

Ahora en nuestro proyecto agregamos un CrystalReportViewer a nuestro


formulario

Vamos agregar 2 MaskedTextBox y vamos a darle una mascara

Ahora seleccionamos el tipo Fecha

Y por ultimo agregamos un CrystalReportViewer donde se va a visualizar mi


reporte, al final nos quedara de la siguiente manera
Ahora en el proyecto le damos clic derecho y agregamos un Crystal Report

A Continuación vamos aceptar la licencia del CrystalReports

Ahora seleccionamos

Ahora lo que vamos a realizar es establecer la conexión a la BD

A continuación seleccionamos el proveedor de la BD, en este caso es el SQL


Server

Ahora configuramos para seleccionar al servidor y la base de datos.

Y por ultimo le damos Finalizar

Ahora seleccionamos los procedimientos almacenados que puedan existir


en la BD

Dentro de los procedimientos almacenados, seleccionamos el procedimiento


almacenado que hemos creado
Nos saldrá un cuadro de dialogo, el cual nos indica que nuestro
procedimiento almacenado tiene 2 parámetros de entrada, finalmente le
damos ok

Y nos quedara de la siguiente manera, le damos siguiente


Como nos damos cuenta nos salen los campos que va a visualizar nuestro
procedimiento almacenado, ahora vamos a seleccionar los campos a
visualizar (todos)

Como no vamos agruparlo, le damos finalizar.


Y nos quedara de la siguiente manera

Ahora si queremos cambiar el formato, clic derecho

Le damos el respectivo formato y finalmente Aceptar


Si queremos ver cómo va quedando nuestro reporte le damos en

Ahora en muestro formulario programaremos en el evento Load, para que


nos muestre nuestro reporte, y a la vez vamos a deshabilitar para que no
aparezca el DisplayGroupTree

Ahora programaremos lo siguiente

Private Sub Form1_Load(…) Handles MyBase.Load


'Estilo para la ubicacion de nuestro CrptReporte
CrptReporte.Dock = DockStyle.Bottom
'Desabilitamos la vizualizacion en grupos
CrptReporte.DisplayGroupTree = False
End Sub

Ahora
Private Sub BtnFiltrar_Click(…) Handles BtnFiltrar.Click
Dim fecha1, fecha2 As Date
fecha1 = CDate(mktxtini.Text)
fecha2 = CDate(mktxtfin.Text)

'vamos a instanciar el nombre de nuestro Reporte Creado


Dim rpt As New Rpt_Ordenes
'los parametros que recibe
rpt.SetParameterValue("@fe1", fecha1)
rpt.SetParameterValue("@fe2", fecha2)
'Pasamos nuestro reporte creado al CrptReporte
CrptReporte.ReportSource = rpt
End Sub

Finalmente presionamos F5 y nos deberá mostrar

Ejercicio Práctico Nro. 3

Lo primero que vamos a realizar es crear los procedimientos almacenados


en SQL

use bdfactura
go
----------Listado_Cliente----------------
-----------------------------------------
--Creamos Ahora el Procedimiento
create Procedure Listado_Cliente
as
select cli_codigo,cli_nombre from clientes
where cli_codigo in(select distinct cli_codigo from fac_cabe)
go
----------Facturas_Varios_Cliente----------------
-----------------------------------------
--Habilita el uso de las comillas
set quoted_identifier off

--Creamos Ahora el Procedimiento


create Procedure Facturas_Varios_Cliente
@codigos varchar(255)
as
exec("select fac_numero,c.cli_codigo,cli_nombre,convert(char(10),
fac_fecha,103) Fecha, fac_igv,fac_total from fac_cabe as fc,clientes as c
where fc.cli_codigo=c.cli_codigo and
c.cli_codigo in(" +@codigos +") order by c.cli_codigo asc")
go

--Probamos el Proc Almacenado


Facturas_Varios_Cliente "'C0001','C0002','C0003'"

Ahora en el visual Studio vamos a crear una nueva solución en blanco

Dentro de la solución, ahora agregaremos una biblioteca de clases, la cual


llamaremos Capa de Datos

Ahora a la capa de datos vamos a crear una clase la cual contendrá mi


conexión a la BD

Y lo llamaremos Clsconexion

Ahora programaremos lo siguiente

Imports System.Data
Public Class Clsconexion
Public Function conexion_SQL() As String
Dim cn As String
cn = "Server=(local);Integrated Security=yes;Database=bdfactura"
Return cn
End Function
End Class

Ahora agregaremos una clase más al proyecto Capa_Datos y lo llamaremos


D_datos

Y ahora programaremos lo siguiente


Imports System.Data.SqlClient
Public Class D_Datos
Dim cone As New Clsconexion
'cone.conexion_SQL llamamos a la Cadena de conexion que hicimos „en la clase Clsconexion
Dim cn As New SqlConnection(cone.conexion_SQL)

Function D_Lista_Cliente() As DataTable


Dim da As New SqlDataAdapter("Listado_Cliente", cn)
Dim dt As New DataTable
da.Fill(dt)
Return dt
End Function
End Class

Una vez generada la capa de datos, Ahora en la solución creada vamos


agregar una Nueva
Biblioteca de calses y la llamaremos capa_Negocio

Ahora en la capa de negocio agregaremos una referencia que vine de la capa


de Datos

Ahora programaremos lo siguiente

Public Class Capa_Negocio


Dim objdato As New Capa_Datos.D_Datos

Function N_Lista_Cliente() As DataTable


Return objdato.D_Lista_Cliente()
End Function
End Class

Luego de haber generado la capa de negocio, ahora a la solución


agregaremos un proyecto de windows y la llamaremos capa Presentación

A continuación realizaremos el siguiente diseño


Ahora en la capa de presentación agregaremos la referencia de la
capa_Negocio

Ahora en nuestro proyecto Capa_Presentacion, vamos agregar un reporte

al cual llamaremos Rpt_Facturas_Clientes

A Continuación vamos aceptar la licencia del CrystalReports y su Reports


Wizard

Ahora debes realizar la conexión a la BD

A continuación seleccionamos el proveedor de la BD, en este caso es el SQL


Server

Ahora configuramos para seleccionar el servidor y la base de datos.


Y por ultimo le damos Finalizar

Ahora seleccionamos los procedimientos almacenados que puedan existir


en la BD

Dentro de los procedimientos almacenados, seleccionamos el procedimiento


almacenado que hemos creado

Nos saldrá un cuadro de dialogo, el cual nos indica que nuestro


procedimiento almacenado tiene 1 parámetros de entrada, si queremos que
por defecto tenga un valor le mandamos un código (Se le puso apostrofe por
que nuestro procedimiento se le mandaba de esa manera) y finalmente le
damos ok

En tablas seleccionadas debe mostrar los siguiente

le damos siguiente

Como nos damos cuenta nos salen los campos que va a visualizar nuestro
procedimiento almacenado, ahora vamos a seleccionar los campos a
visualizar (agregar todos).

Una vez agregado los campos, le damos siguiente

Y ahora lo vamos agrupar por el código del Cliente

Y nos quedara de la siguiente manera


A continuación vamos a darle formato a nuestro Reporte

Si queremos ver cómo va quedando nuestro reporte le damos en

Y nos pedirá los parámetros, le damos por ejemplo

Y nos quedara de la siguiente manera


Ahora vamos a programar en nuestro formulario, para ello realizaremos una
referencia a la capa de Negocio

Public Class Form1


Dim objnegocio As New Capa_Negocio.Capa_Negocio

Ahora programaremos para Listar los clientes a penas cargue el formulario

Private Sub Form1_Load(…) Handles MyBase.Load


CrystalReportViewer1.Dock = DockStyle.Bottom

Dim dt As New DataTable


formato()
Dim lstitem As ListViewItem
dt = objnegocio.N_Lista_Cliente()
For a As Integer = 0 To dt.Rows.Count - 1
lstitem = ListView1.Items.Add(dt.Rows(a)(0))
lstitem.SubItems.Add(dt.Rows(a)(1))
Next
End Sub

Sub formato() 'Formato del ListView1


With ListView1
.CheckBoxes = True 'Mostramos CheckBoxes en el ListView1
.View = View.Details 'Vista Detalle
.GridLines = True 'Muestre Lineas de separacion entre filas y columnas
.Columns.Add("Codigo del Cliente", 120, HorizontalAlignment.Center)
.Columns.Add("Nombre del Cliente", 250, HorizontalAlignment.Left)
End With : End Sub
Ahora programaremos en el Botón Ver Facturas

Private Sub btnbuscar_Click(…) Handles btnbuscar.Click

Dim cod, codigo As String


Dim tamaño As Integer
cod = ""
Try

For a As Integer = 0 To ListView1.Items.Count - 1


If (ListView1.CheckedItems(a).Checked = True) Then
cod = cod & "'" & ListView1.CheckedItems(a).Text & "',"
End If
Next
Catch ex As Exception
End Try
tamaño = cod.Length 'Tamaño de la cadena
'Le quitamos uno por la coma que sobra
codigo = Mid(cod, 1, tamaño - 1)
Dim rpt As New Rpt_Facturas_Clientes
rpt.SetParameterValue("@codigos", codigo)
CrystalReportViewer1.ReportSource = rpt
End Sub

Finalmente presionamos F5 y vemos el resultado.