Í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:

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

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

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.

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.

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

SELECT * FROM titles

SELECT title, price FROM titles

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.

De la misma forma, si queremos obtener todos los títulos cuyo precio no supere los 2$, ejecutaremos el Código siguiente.

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.

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.

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

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

SELECT title FROM titles WHERE price

BETWEEN 1 AND 2

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

SELECT au_fname FROM authors WHERE au_fname LIKE '[C-H]urry'

SELECT * FROM titles WHERE price <= 2

SELECT * FROM titleauthor WHERE royaltyper > 10

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.

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.

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

SELECT au_lname FROM authors GROUP BY au_lname HAVING au_lname = 'Ringer'

SELECT au_lname FROM authors GROUP 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.

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":

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.

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

SELECT count(DNI) FROM cliente

SELECT sum(precio) FROM pedido WHERE cod_cliente = "R12CE"

SELECT sum(precio) FROM pedido

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.

Si queremos saber cuántos títulos tenemos en nuestra base de datos, digitaremos el siguiente Código fuente.

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.

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:

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.

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.

SELECT avg(price) media FROM titles

SELECT avg(cantidad_pedida) FROM material

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

SELECT count(*) FROM titles

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

Para nuestro ejemplo, si queremos saber cuál es el libro más caro, ejecutaremos el Código siguiente.

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.

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:

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.

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.

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

INSERT INTO tabla (atributos) VALUES (valores)

SELECT min(price) barato FROM titles

SELECT max(price) caro FROM titles

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.

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.

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:

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.

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.

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

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

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

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

'Perez', 1)

Podemos comprobarlo ejecutando el Código.

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:

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.

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)

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.

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:

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

DELETE FROM authors WHERE au_id = '409-99-9876'

DELETE authors

DELETE FROM tabla WHERE condición

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

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.

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:

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.

CASE expresion1 WHEN expresion2 THEN resultado1 WHEN expresion3 THEN resultado2 ...

[ELSE resultado3]

IF (SELECT count(*) FROM titles) > 10 BEGIN SELECT title FROM titles END ELSE BEGIN SELECT count(*) FROM titles END

IF expresion_logica sentencia1 [ELSE sentencia2]

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.

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

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.

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

SELECT * FROM OFICINAS

SELECT state = CASE state WHEN 'CA' THEN 'California' WHEN 'OR' THEN 'Oregon' ELSE 'Otro' END

FROM authors

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.

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

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

CREATE VIEW OFICINASESTE AS SELECT *FROM OFICINAS WHERE REGION = 'Este'

CREATE VIEW REPESTE AS SELECT * FROM REPVENTAS WHERE OFICINA_REP IN (11, 12, 13)

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.

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.

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)

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

CREATE VIEW CLIEBILL AS SELECT NUM_CLIE, EMPRESA, LIMITE_CREDITO

FROM CLIENTES WHERE REP_CLIE = 105

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

CREATE VIEW INFOREP AS SELECT NUM_EMPL, NOMBRE, OFICINA_REP FROM REPVENTAS

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

Ahora crearemos nuestra cadena de conexión

Crearemos un Procedimiento en el SQL cual se encargara de mostrar el Listado de todos los Clientes

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

Imports System.Data.SqlClient

Public Class Form1

Ahora en el Visual Studio creamos un procedimiento el cual se encargara de mostrar el listado de los clientes

Ahora realizaremos el llamado a nuestro procedimiento para que cuando cargue el formulario me liste los Clientes

A continuación crearemos un Procedimiento Limpiar, el cual se encargara de Limpiar todas las cajas de texto

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

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

Private Sub Form1_Load(…) Handles MyBase.Load Listado()

End Sub

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

End Sub

----------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 programaremos el Botón Nuevo

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)

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

----------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 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

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 crearemos un procedimiento almacenado en el SQL, el cual se encargara de la actualización de los datos del cliente

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

----------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

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 eliminar a un cliente

Ahora programaremos en el botón Eliminar

Ahora compilaremos nuestro formulario presionando F5

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

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

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

A continuación crearemos nuestra cadena de conexión

Imports System.Data.SqlClient

Imports System.IO 'MemoryStream

Ahora programaremos para que cuando cargue el formulario me liste los empleados

Crearemos nuestro procedimiento para Mostrar la foto

Ahora programaremos en el ListBox, para que cuando seleccionemos uno de los empleados nos visualice las fotos y las facturas vendidas por dicho empleado

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

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

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

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

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

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

A continuación crearemos nuestra cadena de conexión

A continuación programaremos para que cuando cargue el formulario me llene el 1er DatagridView con todas las facturas realizadas

Ahora programaremos en el botón

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

Dim cn As New SqlConnection("Server=(local);Integrated Security=yes;database=BDfactura")

Imports System.Data.SqlClient

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,

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

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

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

----------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

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

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)

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

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

Ahora llamaremos a nuestra clase 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

Imports System.Data.SqlClient Public Class Form1

Dim funcion As New clsfunciones

Imports System.Data.SqlClient

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

Finalmente presionamos F5 y nos debe quedar de la siguiente manera

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

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

Ahora llamaremos a nuestra clase clsfunciones

Ahora programaremos para que cuando cargue el formulario me liste los clientes

Ahora vamos a programar en el botón para que nos muestre las facturas de los clientes seleccionado

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

Imports System.Data.SqlClient Public Class Form1

Dim clase As New clsfunciones

Imports System.Data.SqlClient

A continuación presionamos F5

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

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

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 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 en el formulario vamos a llamar a nuestra clase

Ahora programaremos para que cuando cargue el formulario me liste las facturas

Ahora programaremos en el datagridView1

Private Sub Link_datagridview_Load(…) Handles MyBase.Load Dim dt As New DataTable dt = funciones.Listado_facturas DataGridView1.DataSource = dt

End Sub

Public Class Link_datagridview

Dim funciones As New clsfunciones

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

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), )

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

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

Ahora instanciaremos el nombre de nuestra librería

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

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

Imports System.Data

Public Class Form1

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

Ahora programaremos para que cuando cargue el formulario me liste los Clientes

Public Class Form1

Dim objnegocio As New Capa_Negocio.Capa_Negocio

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 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

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

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)

Private Sub btnSalir_Click(…) Handles btnSalir.Click Me.Close()

End Sub

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

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

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

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

Ahora programaremos para que cuando cargue el formulario nos liste las facturas realizadas

Ahora programaremos en el botón Ver Facturas

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

Public Class Form1

Dim objnegocio As New Capa_Negocio.Capa_Negocio

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

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

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

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

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 en la capa de negocio agregaremos una referencia que vine de la capa de Datos

Ahora programaremos lo siguiente

Luego de haber generado la capa de negocio, ahora a la solución agregaremos un proyecto y la llamaremos capa Presentación

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

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

Ahora programaremos en el botón Filtrar

Ahora programaremos en el DatagridView1 para que cuando le demos Clic nos muestre las facturas en el DatagridView2

Ahora presionamos F5

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

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

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

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

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

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

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

Ahora programaremos para Listar los clientes a penas cargue el formulario

Ahora programaremos en el Botón Ver Facturas

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

Public Class Form1

Dim objnegocio As New Capa_Negocio.Capa_Negocio

Finalmente presionamos F5

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

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

Base de datos a las que se tiene acceso

Método de acceso a datos

OLEDB Cualquier base de datos que tenga un proveedor OLEDB.

Admite tanto la extracción de datos de la base de datos como la inserción de datos en el informe de un conjunto de registros ADO.

ODBC Cualquier base de datos que tenga un proveedor ODBC.

Admite tanto la extracción de datos de la base de datos como la inserción de datos en el informe de un conjunto de registros RDO.

Access/Excel Bases de datos de Microsoft Access y libros de Microsoft Excel.

Admite tanto la extracción de datos de la base de datos como la inserción de datos en el informe de un conjunto de registros DAO.

ADO.NET Cualquier base de datos con un proveedor gestionado.

Admite la inserción de datos en el informe desde un conjunto de datos ADO.NET.

Este controlador

no extraerá datos por

sí mismo.

Definición de campo

Ninguna.

Este controlador

especial se utiliza

para crear informes

basados únicamente

en un esquema sin

El controlador se incluye principalmente para la compatibilidad con versiones anteriores y sólo se utiliza durante el proceso de creación de informes.

En tiempo de

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 Crystal (CDO)

Ninguna.

Este controlador

especial obtiene

acceso a datos que

no residen en una

base de datos

tradicional.

Este controlador se incluye principalmente para la compatibilidad con versiones anteriores.

Este controlador

sólo admite la

inserción de datos en

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

1

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

Finalmente presionamos F5 y nos deberá mostrar

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

Ejercicio Práctico Nro. 2 Primero vamos a crear nuestro procedimiento almacenado en el SQL

Ahora si ejecutamos nuestro procedimiento

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 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

Ahora

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

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

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

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

Ahora agregaremos una clase más al proyecto Capa_Datos y lo llamaremos D_datos Y 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

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

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

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

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

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

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

Public Class Form1

Dim objnegocio As New Capa_Negocio.Capa_Negocio

.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

Finalmente presionamos F5 y vemos el resultado.

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