SQL Server Visual Net

Índice General
Semana 1…………………………………………………… Manipulación de datos en SQL 2008
Semana 2……………………... Procedimientos Almacenados I
Semana 3……………………… Procedimientos Almacenados II Parámetros de entrada y salida
Semana 4……………………… Procedimientos almacenados III Vistas
Semana 5………………………………………… Practica I
Semana 6………………………………………… Acceso a datos con ADO NET
Semana 7- 8……………………………………… Ado – Net con Procedimientos Almacenados
Semana 9………………………………………… Practica II
Semana 10……………………………………….. Examen Parcial
Semana 11…………………………………......... Clases y creación de librerías
Semana 12……………………………………….. LIBRERÍA DE CLASES CON BD
Semana 13 – 14………………………………….. Aplicaciones con 3 Capas
Semana 15……………………………………….. Practica III
Semana 16……………………………………….. CREACIÓN DE REPORTES
Semana 17……………………………………….. CREACIÓN DE SUB REPORTES
Semana 18 ………………………………………. PRESENTACION DE TRABAJO FINAL
Semana 19……………………………………….. Examen Final
Semana 20……………………………………….. Examen Sustitutorio
Ing. Alberto Moreno C.

Semana 1 Manipulación de datos en SQL 2005
La sentencia Select
La sentencia Select es una sentencia SQL, que pertenece al conjunto del

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

[WHERE <condicion>]
[GROUP BY <atributos>]
[HAVING <condición>]
[ORDER BY <atributos>]
Donde las mayúsculas representan palabras reservadas, y lo encerrado

entre corchetes es opcional, puede ser omitido. Una vez vista la anterior
forma de representación, vamos a detenernos en la sintaxis de la sentencia
Select. Se compone de tres partes:
SELECT <atributos>: permite hacer una proyección de las tablas, es

decir, seleccionar los campos que deseamos recuperar de la base de
datos, separados por comas. Si se especifica el símbolo *, se
obtendrán todos los campos de la tabla.
FROM <tablas>: permite especificar la tabla de la cual se desean

obtener los datos. Si se especifica más de una tabla, éstas irán
separadas por comas.
WHERE <condición>: permite establecer una condición de

recuperación de las filas de la/s tabla/s. Sólo se obtendrán aquellas
consultas que verifiquen dicha condición, que será opcional. En el
caso de que se omita esta parte, se recuperarán todas las filas.
GROUP BY <atributos>: permite establecer una selección de campos

cuando se utilizan funciones escalares o de conteo (ya se verá más
adelante lo que significa.
HAVING <condición>: establece una condición para los atributos

obtenidos como resultado de la aplicación de funciones escalares.
ORDER BY <atributos>: permite obtener el resultado de la consulta

ordenado por los atributos especificados.
En el caso de que se especifiquen varias tablas, en la cláusula FROM, será

conveniente denotar los campos de la cláusula SELECT precedidos por el
nombre de la tabla donde se encuentra y un punto, para que, en el caso de
que dicho campo exista en más de una tabla, se sepa en cada momento a
cuál de ellos nos estamos refiriendo, evitando en este caso el problema de
ambigüedad.
Si por ejemplo, deseamos obtener todos los valores de los atributos title y
price de la tabla titles, deberíamos escribir el siguiente Código fuente.
SELECT title, price FROM titles
De esta manera, obtenemos todas las filas, ya que no hemos dado ninguna
condición, de la tabla titles (especificada en la cláusula FROM), de las cuales
sólo visualizaremos los valores de los atributos title y price (especificados
en la cláusula SELECT). Si por el contrario, deseamos obtener todos los
atributos de dicha tabla, deberíamos escribir el siguiente Código fuente.
SELECT * FROM titles
Puesto que hemos especificado el literal * dentro de la cláusula SELECT, la

anterior sentencia nos devuelve todos los atributos de todas las filas de la
tabla titles, es decir, nos devuelve toda la información almacenada en ella.
La cláusula Where
La forma de usar el Transact SQL para realizar consultas realizando una

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

operadores de
Transact SQL cuyo resultado devuelva un valor lógico, aunque también se
pueden utilizar operadores de cadena. Estos operadores serán vistos en
detalle en el siguiente capítulo, pero básicamente son los siguientes:
>: Compara si una expresión es mayor que otra
<: Compara si una expresión es menor que otra
>=: compara si una expresión es mayor o igual que otra
<=: compara si una expresión es menor o igual que otra

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

búsqueda
BETWEEN: compara todas las cadenas que están comprendidas en un rango
de valores
IN: compara todas las cadenas que están contenidas en una lista Por
ejemplo, si queremos obtener los títulos cuyos derechos de autor sean
mayores del 10 %, digitaremos el siguiente Código.
SELECT * FROM titleauthor WHERE

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

supere los 2$, ejecutaremos el Código siguiente.
SELECT * FROM titles WHERE price <= 2
Si queremos obtener el nombre de los autores cuya primera letra este

comprendida entre la C y la H, y que a continuación tenga el literal 'urry',
ejecutamos el Código siguiente.
SELECT au_fname FROM authors WHERE au_fname LIKE '[C-

H]urry'
O si queremos obtener la ciudad de todos los autores, que se corresponda

con San Francisco o con Salt Lake City, ejecutaremos el Código siguiente.
SELECT city FROM authors WHERE city in ('San Francisco','Salt Lake City')
Si se desea conocer todos los títulos cuyo precio oscila entre 1 y 2 dólares,
ejecutaremos el Código siguiente.
SELECT title FROM titles WHERE price

BETWEEN 1 AND 2
La cláusula Group By
La cláusula GROUP BY agrupa, como su propio nombre indica, filas que

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

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

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

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

'Ringer'
La cláusula Order By
La cláusula ORDER BY determina el orden de visualización de las filas

obtenidas en la sentencia SELECT. A continuación de dicha palabra
reservada, se debe especificar el atributo o los atributos por los cuales se
ordenará el resultado obtenido en la consulta.
Por ejemplo, si queremos mostrar el nombre y apellido de todos los autores

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

Funciones escalares para Select
Entendemos por funciones escalares, todas aquellas que permiten realizar

operaciones de conteo de filas, suma de atributos, obtención de medias, etc.
Dichas funciones se especifican a continuación de la palabra reservada
SELECT. Las funciones que soporta la sentencia SELECT en el Transact SQL
son las siguientes:
SUM: Realiza una suma acumulativa de un atributo para todas las filas
accedidas mediante una consulta SQL.
Por ejemplo, supongamos que tenemos una tabla de pedidos, con los
atributos cod_cliente, cod_material y precio. Si queremos obtener la suma
del precio de todos los pedidos almacenados, bastará con realizar una
función de tipo SUM, como la que vemos en el Código siguiente.
SELECT sum(precio) FROM pedido
La anterior consulta obtiene la suma del precio para todas las filas de la
tabla pedido, ya que no hemos especificado ninguna condición en la
cláusula WHERE.
Si ahora queremos obtener la suma total de todos los pedidos realizados por
el cliente cuyo código es "R12CE", debemos realizar la misma consulta, pero
especificando una condición para obtener únicamente las filas cuyo
cod_cliente es "R12CE":
SELECT sum(precio) FROM pedido WHERE cod_cliente =

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

atributo que seleccionemos, podríamos haber escogido cualquier otro. En
general, se suele escribir el siguiente Código fuente.
SELECT count(*) FROM cliente

Si ahora queremos saber el número de clientes que viven en Madrid,
deberemos realizar un conteo de todas las filas con la condición de que el
atributo población sea Madrid.
SELECT count(*) FROM cliente WHERE poblacion = "Madrid"
Si queremos saber cuántos títulos tenemos en nuestra base de datos,

digitaremos el siguiente Código fuente.
SELECT count(*) FROM titles
Y si queremos saber cuántos títulos tenemos, cuyo precio es mayor de 20 $,

deberemos realizar lo mismo, pero especificando esta condición en la
cláusula
WHERE. Al resultado de la búsqueda le llamaremos caros.
SELECT count(*) caros FROM titles WHERE price > 20
AVG: Realiza una media aritmética de los atributos para todas las filas
accedidas mediante la consulta SQL.
Si por ejemplo tenemos una tabla de materiales, con los atributos
cod_material, descripción, precio y cantidad_pedida, y queremos saber la
cantidad media pedida de todos los materiales, deberemos realizar una
media aritmética, teniendo en cuenta todas las filas de la tabla:
SELECT avg(cantidad_pedida) FROM material
La anterior sentencia, internamente, realiza primero una suma de todos los

valores, y a continuación la divide por el número total de filas accedidas, es
decir, realiza la media aritmética.
Volviendo a nuestra cultural base de datos pubs, si queremos saber la media
del precio de los títulos que tenemos disponibles, deberemos ejecutar el
Código siguiente.
SELECT avg(price) media FROM titles
MAX: Obtiene el máximo valor del atributo especificado, de entre

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

las filas seleccionadas mediante la sentencia SQL. Si queremos saber
cuál es el libro más barato de nuestra base de datos, deberemos
ejecutar el Código siguiente.
SELECT min(price) barato FROM titles
La sentencia Insert
La otra gran sentencia de manipulación de datos es INSERT. Si SELECT nos

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

lista de atributos separados por comas que determinan los atributos para los
cuales se darán valores, y que se darán para estos atributos, separados por
comas. Por ejemplo, si queremos añadir un nuevo autor a nuestra base de
datos, deberemos ejecutar el Código siguiente.
INSERT INTO authors (au_id, au_lname, au_fname) VALUES ('409-99-9876', 'Pepe',

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

entre comillas, mientras que si es numérico no. Pues bien, si ejecutamos la
anterior sentencia, tenemos el siguiente error:
Server: Msg 515, Level 16, State 2, Line 1

Cannot insert the value NULL into column 'contract', table
'pubs.dbo.authors'; column does not allow nulls. INSERT fails. The
statement has been terminated.
La razón es que no hemos dado valor al atributo contract, que ha sido
definido como no nulo.
Por lo tanto, rectificamos el Código anterior, para dar un valor al campo
contract.
INSERT INTO authors (au_id, au_fname, au_lname, contract) VALUES ('409-99-9876', 'Pepe',
'Perez', 1)
El valor que hemos dado al atributo contract es un 1, ya que está definido

como tipo binario, es decir, sólo admite dos valores, 0 para especificar que
no está contratado, y 1 para el caso contrario.
Al ejecutar esta sentencia, obtenemos como resultado
(1 row(s) affected)
Lo que nos indica que la fila se ha insertado con éxito. Podemos

comprobarlo ejecutando un SELECT sobre dicha fila.
SELECT * FROM authors WHERE au_id = '409-99-9876'
La sentencia Update
El objetivo de la sentencia UPDATE es actualizar los valores de una o varias

filas de una tabla, sin necesidad de borrarla e insertarla de nuevo. La sintaxis
es la siguiente:
UPDATE tabla SET atributo1 = valor1, atributo2 = valor2,... WHERE Condición
Donde tabla especifica la tabla donde se encuentran las filas que queremos
actualizar, condición especifica la condición que se debe cumplir para
actualizar las filas, y lo que viene a continuación de SET especifica la
asignación de los nuevos valores a los atributos. Por lo tanto se actualizarán
todas las filas que cumplan la condición especificada. Si queremos cambiar
el nombre al autor que hemos insertado en el anterior apartado, deberemos
escribir el Código siguiente.
UPDATE authors SET au_fname = 'Pepito' WHERE au_id = '409-

99-9876'
Lo que hacemos con la anterior sentencia es buscar el autor insertado, por

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

poder borrar filas en una tabla se deben cumplir las condiciones de
seguridad determinadas por el administrador, y deben de cumplirse también
las reglas de integridad referencial. La sintaxis es la siguiente:
DELETE FROM tabla WHERE condición
Donde tabla especifica la tabla sobre la cual queremos borrar las filas, y
condición especifica la condición que se debe cumplir para que se borren
las filas. Si omitimos la condición, se borrarán todas las filas de la tabla, es
decir, la sentencia que aparece en el Código siguiente borra todas las filas
de la tabla authors.
DELETE authors
Por ejemplo, si queremos borrar la fila que hemos creado en la tabla autores,
deberemos ejecutar el siguiente Código fuente. Obteniendo el siguiente
resultado:
(1 row(s) affected)
DELETE FROM authors WHERE au_id = '409-99-

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

la sentencia que muestra el Código siguiente. cuyo resultado es: (0 row(s)
affected), lo que quiere decir que la fila no se encuentra en la tabla, es decir,
ha sido borrada.
Sentencias condicionales
Las sentencias condicionales son aquellas que permiten discriminar entre

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

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

BEGIN
SELECT title FROM titles
END
ELSE
BEGIN
SELECT count(*) FROM titles
END
En definitiva, la sentencia SELECT title FROM titles sólo se ejecuta cuando

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

sentencia CASE. La sintaxis es la siguiente:
CASE expresion1
WHEN expresion2 THEN resultado1
WHEN expresion3 THEN resultado2
...
[ELSE resultado3]
La anterior sentencia compara la expresión 1, con el resto de expresiones

especificadas a continuación de la palabra reservada WHEN. Si alguna de
estas expresiones se cumple, se devolverá el resultado correspondiente
especificado a continuación de la palabra reservada THEN. Si llegados al
final, no ha verificado ninguna de las expresiones, se devolverá el resultado
especificado a continuación del ELSE.
Por ejemplo, si queremos saber el nombre de los estados de los autores, en

lugar de las iníciales, podemos ejecutar el siguiente Código fuente.
SELECT state = CASE state
WHEN 'CA' THEN 'California'
WHEN 'OR' THEN 'Oregon'
ELSE 'Otro'
END
FROM authors
En este caso se comprueba el valor del atributo state, y si este es igual a CA,
se devolverá California, si es OR se devolverá Oregon, y en otro caso se
devolverá el literal 'Otro'.
SELECCIÓN DE TODAS LAS COLUMNAS
A veces es conveniente visualizar el contenido de todas las

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

selección, entonces cada fila de resultados será única (ya que la clave
primaria tiene un valor diferente en cada fila). El DINSTINCT hace que el valor
de las filas no se repita
Listar los años de las facturas, pero los años no se deben de repetir
select distinct year(OrderDate) as Año from orders
El resultado será
RESUMEN
La sentencia SELECT se utiliza para expresar una consulta SQL.
Toda sentencia SELECT produce una tabla de resultados que contienen una
o más columnas y cero o más filas.
La cláusula FROM especifica la(s) tabla(s) que contiene(n) los datos a
recuperar por una consulta.
La cláusula SELECT especifica la(s) columna(s) de datos a incluir en

los resultados de la consulta, que pueden ser columnas de datos de la base
de datos o columnas calculadas.
La cláusula WHERE selecciona las filas a incluir en los resultados

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

comparación de valores, mediante comparación de un valor con un rango o
un grupo de valores, por correspondencia con un patrón de cadena o por
comprobación de valores NULL.
Las condiciones de búsqueda simples pueden combinarse mediante

AND, OR y NOT para formar condiciones de búsqueda más complejas.
La cláusula ORDER BY especifica que los resultados de la consulta

deben ser ordenados en sentido ascendente o descendente, basándose en
los valores de una o más columnas.
Las consultas resumen utilizan funciones de columna SQL para

condensar una columna de valores en un único valor que resuma la
columna.
Las funciones de columna pueden calcular el promedio, suma, el

valor mínimo y máximo de una columna, contar el número de valores de
datos de una columna o contar el número de filas de los resultados de la
consulta.
Una consulta resumen sin una cláusula GROUP BY genera una única
fila de resultados, resumiendo todas las filas de una tablas o de un conjunto
compuestos de tablas.
Una consulta resumen con una cláusula GROUP BY genera múltiples

filas de resultados.
Modelo de Base de Datos para el desarrollo de las Practicas
Ejercicios Prácticos
Usar la BD Ventas
Se desea saber cuántas veces a facturado cada Empleado, mostrar los

campos Cod_Emp,nombre,[Facturas Emitidas].
Mostrara todas las Facturas pares emitida en los meses impares por
empleado más antiguo, mostrar los campos Num_Fact,Sub_Total,Igv,Total,
[meses en letras].
Mostrar los 2 Productos más vendidos de todas las facturas.
Mostrar los clientes cuyo total de facturación sea mayor 1200, los campos a
mostrar son Cod_cli,nom_cli,[Total Facturado].
Mostrar todas las facturas emitidas y su cantidad de productos vendidos de

todos los empleados cuya antiguedad de trabajo sea mayor a 14 años. Los
campos a mostrar son Num_fact,Sub_total,igv,total,[Cantida de productos].
Mostrar los productos cuya segunda letra inicie con 'a' y su stock sea mayor
a 300.
Mostrar los 3 productos más vendidos de todas las facturas en entre el mes
enero y marzo en letras.
Mostrar las facturas impares emitidas al cliente 'C0003'.
Mostrar las facturas pares emitidas por el empleado menos antiguo.
Mostrar el Empleado que no ha emitido ningún tipo de facturación.
Mostrar las 2 facturas con mayor y menor total, los campos a mostrar son
num_fact,Sub_total,igv,total.
Mostrar la antiguedad laboral de cada empleado, los campos a mostrar son

Cod_Emp, Nombre, Fecha_ing,[Antiguedad Laboral].
Usando el Charindex(expresion1,expresion2[,posicion inicial]) devuelve la

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

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

forma descendente y num_fact en forma ascendente.
Mostrar todas las facturas excepto la factura '000002'.
Mostrar las facturas que se encuentran en el rango '000004' hasta el numero

'000010' mostrar en el resultado solo los campos
Num_fact,Sub_Total,igv,total.
Mostrar solo las siguientes facturas '000002','000007','000009','000012', en el

cual incluya en el resultado los campos Num_Fact,Cod_Cli,Cod_Emp,Total.
Mostrar todas las Facturas Excepto las siguientes facturas '000005','000003'.
Mostrar los Clientes cuyo nombre inicien con la letra 'C' o la letra 'A'.
Mostrar los Clientes cuyo nombres termine con letra 'A' y 'O'
LIKE=> Determina si una cadena de caracteres dada coincide o no con un

determinado modelo. Un modelo puede incluir caracteres normales y
carácter comodín. % carácter comodín.
Sintaxis: match_expression [ NOT ] LIKE pattern [ ESCAPE

escape_character ]
Usando Like mostrar los nombres de los empleados cuyo nombre inicie con
la letra 'M'.
Usando Like mostrar los nombres de los empleados cuya segunda letra de
su nombre inicie con la letra 'A'.
Usando Like, mostrar los Empleados cuyo nombre termine con la letra Z.
Usando Like mostrar los Empleados cuyo apellido paterno inicie con la letra
'S' Sabiendo que el nombre tiene este formato Julio, Saavedra Rondon.
Usando Like mostrar todos los empleados excepto los empleados cuyo
apellido paterno inicie con la letra „A‟.
Usando Like mostrar todos los Empleados cuyo nombre no inicie con la letra
C ó la letra M.
Mostrar todos los productos que fueron ingresados el año 1994.
Mostrar todas las facturas que fueron registrados en Enero de 1997.
Mostrar el número de factura, el día Facturado en letras, y el Mes facturado

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

-------- ------------------------------ ------------------------------
000001 Martes Enero
000002 Viernes Enero
Mostrar el número de Factura, y la fecha completa en cadena de caracteres.

El resultado será así:
Num_Fact Fecha
-------- ----------------------------------------------
000001 Lima Martes 2 de Enero de 1996
000002 Lima Viernes 5 de Enero de 1996
Mostrar el código del empleado, la edad del empleado y la fecha de

nacimiento de la tabla empleado.
Mostrar los productos cuya primera letra inicie con 'A', el stock sea mayor a
100 y la fecha de ingreso sea el año 1994.
Mostrar el detalle de los productos vendidos de la Factura Nro.'000001', los

campos a mostrar son Num_Fact,Descrip,precio,cant,total=(precio * cant).
Mostrar el nombre y precio más alto de la tabla producto.

Mostrar el promedio, él máximo y el mínimo del campo precio de la tabla
producto.
Mostrar cuantos años se han emitido las facturas a la fecha, mostrar el
campo Num_fact, Fecha, [Total de años].
Mostrar el total de productos vendidos de la Factura Nro.'000001'.
Mostrar la cantidad de facturas emitidas por cada cliente, mostrar los

campos cod_cli,[Cantidad de facturas].
Mostrar los clientes que hayan tenido más de 10 facturas emitidas, los
campos a mostrar son Nom_Cli,[Cantidad de Facturas].
Mostrar todos los productos vendidos por un año de venta. Campos a

mostrar cod_prod,descrip,[cantidad de productos].
Subconsultas:
Una subconsulta es una consulta SELECT que devuelve un valor único y
está anidada en una instrucción SELECT, INSERT, UPDATE o DELETE, o
dentro de otra subconsulta. Una subconsulta se puede utilizar en cualquier
parte en la que se permita una expresión.
Usando subconsultas, mostrar todas las columnas del producto más caro.
Mostrar los 3 productos más caros, los campos a mostrar son cod_prod,
descrip, precio.
Mostrar las facturas del Empleado más antiguo, los campos a mostrar son
Num_Fact,Sub_total,igv,total.
Mostrar los clientes que no han sido facturado.
Mostrar los productos que no se han vendido.
Mostrar la Actividad de la factura por medio del campo FgEli que es de tipo
bit(0,1), si es 0 "Emitida",si es 1 "Cancelado", los campos a mostrar son
num_fact,Sub_total,igv,total, [Estado de Factura].
Usando el Charindex(expresion1,expresion2[,posicion inicial]) devuelve la
posición inicial de la expresión especificada en una cadena de caracteres.
Mostrar todos los clientes cuyo apellido inicie con la letra 'A'
Cod_Cli nom_cli
--------- ------------------------------
C0010 Williams, Anderson Lorin
Semana 2 Procedimientos Almacenados I
Vimos que SQL Server ofrece dos alternativas para asegurar la integridad de
datos, la integridad:
DECLARATIVA, mediante el uso de restricciones (constraints), valores
predeterminados (defaults) y reglas (rules) y
PROCEDIMENTAL, mediante la implementación de procedimientos

almacenados y desencadenadores (triggers).
Nos detendremos ahora en procedimientos almacenados

Un procedimiento almacenado es un conjunto de instrucciones a las que se
les da un nombre, que se almacena en el servidor. Permiten encapsular
tareas repetitivas.
SQL Server permite los siguientes tipos de procedimientos almacenados:

del sistema: están almacenados en la base de datos "master" y llevan
el prefijo "sp_"; permiten recuperar información de las tablas del
sistema y pueden ejecutarse en cualquier base de datos.
locales: los crea el usuario.
temporales: pueden ser locales, cuyos nombres comienzan con un

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

(DLL, Dynamic-Link Libraries), se ejecutan fuera del entorno de SQL
Server. Generalmente llevan el prefijo "xp_". No los estudiaremos.
Al crear un procedimiento almacenado, las instrucciones que contiene se

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

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

usuarios realizan operaciones enviando una única instrucción, lo cual
disminuye el número de solicitudes entre el cliente y el servidor.
Creación, modificación y eliminación de Store Procedure
Los procedimientos almacenados se crean en la base de datos seleccionada,

excepto los procedimientos almacenados temporales, que se crean en la
base de datos "tempdb".
En primer lugar se deben tipear y probar las instrucciones que se incluyen

en el procedimiento almacenado, luego, si se obtiene el resultado esperado,
se crea el procedimiento.
Los procedimientos almacenados pueden hacer referencia a tablas, vistas, a

funciones definidas por el usuario, a otros procedimientos almacenados y a
tablas temporales.
Un procedimiento almacenado pueden incluir cualquier cantidad y tipo de

instrucciones, excepto:
Create default, create procedure, create rule, create trigger y create view.
Se pueden crear otros objetos (por ejemplo índices, tablas), en tal caso
deben especificar el nombre del propietario; se pueden realizar inserciones,
actualizaciones, eliminaciones, etc.
Si un procedimiento almacenado crea una tabla temporal, dicha tabla sólo

existe dentro del procedimiento y desaparece al finalizar el mismo. Lo mismo
sucede con las variables.
Hemos empleado varias veces procedimientos almacenados del sistema

("sp_help", "sp_helpconstraint", etc.), ahora aprenderemos a crear nuestros
propios procedimientos almacenados.
Para crear un procedimiento almacenado empleamos la instrucción "create

procedure".
La sintaxis básica parcial es:

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

as
select *from libros
where cantidad <=10;
Entonces, creamos un procedimiento almacenado colocando "create

procedure" (o "create proc", que es la forma abreviada), luego el nombre del
procedimiento y seguido de "as" las sentencias que definen el
procedimiento.
"create procedure" debe ser la primera sentencia de un lote.
Para ejecutar el procedimiento almacenado creado anteriormente tipeamos:

exec pa_libros_limite_stock;
Entonces, para ejecutar un procedimiento almacenado colocamos "execute"
(o "exec") seguido del nombre del procedimiento.
Cuando realizamos un ejercicio nuevo, siempre realizamos las mismas

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

as
if object_id('libros')is not null
drop table libros;
create table libros(
codigo int identity,
titulo varchar(40),
autor varchar(30),
editorial varchar(20),
precio decimal(5,2),
primary key(codigo)
);
insert into libros values('Uno','Richard Bach','Planeta',15);
insert into libros values('Ilusiones','Richard Bach','Planeta',18);
insert into libros values('El aleph','Borges','Emece',25);
insert into libros values('Aprenda PHP','Mario Molina','Nuevo siglo',45);
insert into libros values('Matemática estas ahi','Paenza','Nuevo siglo',12);
insert into libros values('Java en 10 minutos','Mario Molina','Paidos',35);
Y luego lo ejecutamos cada vez que comenzamos un nuevo ejercicio y así
evitamos tipear tantas sentencias:
exec pa_crear_libros;
Los procedimientos almacenados se eliminan con "drop procedure".
Sintaxis:
drop procedure NOMBREPROCEDIMIENTO;
Eliminamos el procedimiento almacenado llamado "pa_libros_autor":
drop procedure pa_libros_autor;
Si el procedimiento que queremos eliminar no existe, aparece un mensaje de

error, para evitarlo, podemos emplear esta sintaxis:
if object_id('NOMBREPROCEDIMIENTO') is not null

drop procedure NOMBREPROCEDIMIENTO;
Eliminamos, si existe, el procedimiento "pa_libros_autor", si no existe,

mostramos un mensaje:
if object_id('pa_libros_autor') is not null

drop procedure pa_libros_autor
else
select 'No existe el procedimiento "pa_libros_autor"';
"drop procedure" puede abreviarse con "drop proc".
Se recomienda ejecutar el procedimiento almacenado del sistema

"sp_depends" para ver si algún objeto depende del procedimiento que
deseamos eliminar.
Podemos eliminar una tabla de la cual dependa un procedimiento, SQL

Server lo permite, pero luego, al ejecutar el procedimiento, aparecerá un
mensaje de error porque la tabla referenciada no existe.
Aplicaciones prácticas
 Problema:
Trabajamos con la tabla "libros" de una base de datos llamada librería.
--Eliminamos la tabla si existe y la creamos nuevamente:

if object_id('libros') is not null
drop table libros;
Create table libros(
titulo varchar(40),
autor varchar(30),
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%';
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(

titulo varchar(40),
autor varchar(30),
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),
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(

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;
Usar la base de datos Neptuno
1. Crear un SP que muestre cuales son los productos que tienen el mayor precio de la
tabla productos. Los campos a mostrar son:
Ejemplo: Exec usp_ProductoMayor
2. Crear un SP que muestre todos los Pedidos de un cliente ingresado. Los datos a
mostrar son:
Ejemplo: Exec usp_PedidosporCliente 'ALFKI'
3. crear un SP que muestre la cantidad de pedidos vendidos por un empleado ingresado.

Ejemplo: Exec usp_PedidosporEmpleado 1
4. Crear un SP que muestre todos los Productos cuyo pais de proveedor sea ingresado, y
la unidad de precio sea mayor al dato ingresado.Mostrara el siguiente resultado.
Ejemplo: Exec usp_ProductosporPaisyPrecioUnidad 'Estados Unidos',20
5. Crear un SP que permita mostrar todos los datos de una tabla ingresada.
Set Quoted_Identifier off --los literales deben delimitarse con comillas dobles.
Set Quoted_Identifier on --los literales deben delimitarse con comillas simples.
Ejemplo: Exec usp_MostrarTablas 'Empleados'
6. Crear un SP que que permita mostrar todos los productos cuya segunda palabra del
nombre del producto inicia por una letra ingresada,el precio unidad sea mayor al dato
ingresado, y las unidades en existencia sea mayor al dato ingresado.
Ejemplo: Exec usp_Productospor3Parametros 'd',40,50
7. Crear un SP que muestre cuantos productos existen cuyo precio unidad este entre 15 y
50. Utilice un parametro de salida OUTPUT para obtener el resultado.
Ejemplo de ejecucion del procedimiento almacenado con parametro de salida:
Declare @precio int
Exec usp_CantidadProductos @precio Output
print 'Existen '+ convert(varchar(2),@precio)+' Productos'
8. Crear un SP que permita la insercion de un registro en la tabla alumnos.
Nombre de Campo Tipo de Dato Longitud

Alu_cod Char 5
Alu_dir Varchar 50
Alu_edad Int
Alu_fecing Smalldatetime
9. Crear un SP que permita la insercion de un registro en la tabla alumnos y a la vez genere

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

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

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

modo que diferentes usuarios la vean desde diferentes perspectivas.
Las vistas permiten restringir acceso a los datos, permitiendo que
diferentes usuarios sólo vean ciertas filas o ciertas columnas de una tabla.
Las vistas simplifican el acceso a la base de datos mediante la
presentación de la estructura de los datos almacenados del modo que sea
más natural a cada usuario.
¿Qué es una vista?
Una vista es una “tabla virtual” en la base de datos cuyos contenidos

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

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

DBMS debe traducir las consultas con respecto a la vista en consultas con
respecto a las tablas fuente subyacente.
Restricciones de actualización. Cuando un usuario trata de actualizar
filas de una vista, el DBMS debe traducir la petición a una actualización
sobre las filas de las tablas fuente subyacente.
Creación De Una Vista (Create View)
La sentencia CREATE VIEW se utiliza para crear una vista. La

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

utilizan diferentes tipos de vistas para propósitos diferentes.
1. Vistas horizontales
Un uso común de las vistas es restringir el acceso de un usuario a

las filas seleccionadas de una tabla. Por ejemplo, puede ser deseable que un
director de ventas solamente vea filas de REPVENTAS correspondientes a
los vendedores de la región propia del director. Para lograr esto, se pueden
definir dos vistas, del modo siguiente:
Crea una vista que muestre a los vendedores de la región Este.
CREATE VIEW REPESTE AS SELECT * FROM REPVENTAS WHERE OFICINA_REP IN

(11, 12, 13)
Define una vista que contiene únicamente las oficinas de la región

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

'Este'
2. Vistas verticales
Otro uso habitual de las vistas es restringir el acceso de un usuario a

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

vendedor.
CREATE VIEW INFOREP AS SELECT NUM_EMPL, NOMBRE, OFICINA_REP FROM

REPVENTAS
Define una vista de la Tabla OFICINAS para el personal de

procesamiento de pedidos que incluye la ciudad, el número de oficina y
región.
CREATE VIEW INFOOFICINA AS SELECT OFICINA, CIUDAD, REGION FROM OFICINAS
3. Vistas con subconjuntos fila/columna
Es bastante habitual definir una vista que divida una tabla fuente
tanto por la dimensión horizontal como por la vertical, como en este
ejemplo:
Define una vista que contiene el número de cliente, el nombre de

empresa y el límite de crédito de todos los clientes asignados a Bill Adams
(empleado número 105)
CREATE VIEW CLIEBILL AS SELECT NUM_CLIE, EMPRESA, LIMITE_CREDITO

FROM CLIENTES WHERE REP_CLIE = 105
Los datos visibles a través de esta vista son un subconjunto

fila/columna de la Tabla CLIENTES. Sólo las columnas explícitamente
designadas en la lista de selección de la vista y las filas que satisfacen la
condición de búsqueda son visibles a través de la vista.
ELIMINACION DE UNA VISTA
Debido a que las vistas se comportan como tablas, y una vista no

puede tener el mismo nombre que una tabla, muchos productos DBMS
utilizan la sentencia DROP TABLE para eliminar vistas. Otras
implementaciones SQL proporcionan la sentencia DROP VIEW:
RESUMEN
Una vista es una tabla virtual definida mediante una consulta. La

vista `parece contener filas y columnas de datos, al igual que una tabla
“real”, pero los datos visibles a través de la vista son, de hecho, los
resultados de la consulta.
Una vista puede ser un subconjunto simple fila/columna de una única

tabla, puede sumarizar una tabla (una vista agrupada) o puede extraer sus
datos de dos o más tablas (una vista compuesta).
Una vista puede ser referenciada como una tabla real en una
sentencia SELECT, INSERT, DELETE o UPDATE. Sin embargo, las vistas más
complejas no pueden ser actualizadas; son vistas de sólo lectura.
Las vistas suelen utilizarse para simplificar la estructura aparente de

una base de datos, para simplificar consultas y para proteger ciertas filas y/o
columnas frente a acceso no autorizado.
Usar la base de datos Neptuno
1. Crear una vista que permita visualizar los 2 empleados con mayor cantidad de Pedidos.
(usar tablas Empleados y Pedidos)
2. Crear una vista que permita visualizar todos productos por Proveedor.(Usar tablas
Proveedores y Productos)
3. Crear una vista que permita visualizar los datos del empleado mas joven. (Usar tabla
Empleados)
4. Crear una vista que permita visualizar todos los empleados con mas años de trabajo y
los empleados con menor años trabajo. (Usar tabla Empleados)
5.
6. Crear una vista que permita visualizar los productos y su categoria, cuya unidad de
precio sea mayor al promedio de precios de unidad. ( Usar tablas Categorias y
Productos)
Semana 6 Acceso a datos con ADO NET
ADO .NET es la nueva versión del modelo de objetos ADO (ActiveX Data
Object), es decir la estrategia que ofrece Microsoft para el acceso a datos.
ADO .NET ha sido ampliado para cubrir todas las necesidades que ADO no
ofrecía, y está diseñado para trabajar con conjuntos de datos
desconectados, lo que permite reducir el tráfico de red. ADO .NET utiliza
XML con formato universal de transmisión de los datos.
Estructura del modelo de objetos
Ámbitos con nombre de ADO .NET
La instalación por defecto de la plataforma .NET aporta cinco ámbitos con

nombre namespaces relacionados con ADO.NET, a los cuales habría que
añadir uno o más por cada proveedor adicional que pudiéramos instalar
después. Estos cinco ámbitos son:
System.Data: Aloja las clases independientes del origen de datos, así como
las interfaces que deben implementar las clases dependientes.
System.Data.Common: Contiene clases que facilitan la implementación de

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

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

correspondiente al acceso de datos y es la responsable de establecer la
comunicación con las fuentes de datos.
En este conjunto de nombres de espacio, encontraremos casi siempre las

clases Connection, Command, DataAdapter y DataReader como las clases
más generales, las cuales nos permiten establecer la conexión con la fuente
de datos.
Proveedor de acceso a datos de .NET Framework
Dentro del entorno .NET Framework, encontramos un nutrido conjunto de

proveedores de acceso a datos.
Estos son los siguientes:
ODBC .NET Data Provider

OLE DB .NET Data Provider
Oracle Client .NET Data Provider
SQL Server .NET Data Provider
Estos proveedores de acceso a datos incluidos en Microsoft .NET

Framework, los podemos encontrar en los nombres de espacio:
System.Data.Odbc
System.Data.OleDb
System.Data.OracleClient
System.Data.SqlClient
El objeto Connection
Este objeto es el encargado de establecer una conexión física con una base
de datos determinada.
Para establecer la conexión con una determinada fuente de datos, no sólo

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

Dentro del objeto Connection tenemos
Provider: Se utiliza para indicar el nombre del proveedor de datos. El

proveedor de datos es el programa desde donde vas a obtener la
información que vas a manejar en tu aplicación y puede ser SQL,
Access, MySQL, Oracle, etc.
DataSource: Se utiliza para indicar el nombre del servidor donde se

encuentra la base de datos a conectare. El servidor es la computadora
donde se ha instalado por ejemplo el SQL Server. En los objetos
SQLConnection se puede utilizar también el parámetro Server.
Initial Catalog: Se utiliza para indicar el nombre de la bases de datos a

la cual nos queremos conectar. En los objetos SQLConnection se
puede utilizar también el parámetro DataBase.
User ID: Se utiliza para indicar el nombre del usuario que se conecta a
la base de datos.
Pwd: Se utiliza para indicar la clave del usuario que esta conectándose
a la base de datos.
Integrated Security: Permite indicar si la conexión a la base de datos

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

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

conjuntamente con el objeto DataAdapter que es el encargado de ejecutar la
instrucción indicada.
El objeto DataAdapter
Este objeto es quizás el objeto más complejo y a la vez complicado de todos

los que forman parte de un proveedor de acceso a datos en .NET.
Cuando deseamos establecer una comunicación entre una fuente de datos y

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

datos a un DataSet.
DeleteCommand es el objeto encardago de realizar las acciones de borrado

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

de datos.
UpdateCommand es el objeto encardago de realizar las acciones de

actualización de datos.
Los objetos DeleteCommand, InsertCommand y UpdateCommand son los

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

conexión en un modo de solo lectura. Se trata de un objeto de acceso a
datos muy rápido.
Este objeto puede usar a su vez el objeto Command o el método

ExecuteReader.
La clase DataSet
Puede que sea la capa más externa e importante del modelo ADO.NET, pero
es la que contiene quizás, el modelo de colecciones y trabajo que más le
puede resultar familiar al programador de Visual Basic 6, sobre todo a los
anteriormente comentados RecordSets.
El DataSet contiene en sí, un conjunto de datos que han sido volcados desde
el proveedor de datos.
De esa forma, podemos trabajar con. De hecho, por marcar una similitud con
el RecordSet, el DataSet está preparado para trabajar con fuentes de datos
desconectadas.
La clase DataView
Este objeto nos permite crear múltiples vistas de nuestros datos, además de
permitirnos presentar los datos.
Es la clase que nos permite representar los datos de la clase DataTable,

permitiéndonos editar, ordenar y filtrar, buscar y navegar por un conjunto de
datos determinado.
La clase DataTable
Este objeto nos permite representar una determinada tabla en memoria, de

modo que podamos interactuar con ella.
A la hora de trabajar con este objeto, debemos tener en cuenta el nombre

con el cuál definamos una determinada tabla, ya que los objetos declarados
en el DataTable es sensitivo a mayúsculas y minúsculas.
Lo que sí está claro es que el modelo de datos de ADO.NET que hemos visto,
quedaría resumido en cuanto a la conectividad de la manera en la que se
representa en la figura.
Semana 7- 8 Ado – Net con Procedimientos Almacenados
Ejercicio Práctico Nro. 1
Lo primero que vamos a hacer es abrir el Visual Studio 2005.
Ahora vamos a crear un Proyecto, para ellos nos vamos a Archivo y luego
seleccionamos Nuevo Proyecto
Ahora seleccionamos Visual Basic y seleccionamos Aplicación para
Windows (se le asigna el nombre de Mantenimiento_Clientes)
Ahora crearemos el siguiente diseño.
Ahora importamos el Proveedor de la Base de Datos, en este caso será el

SQL
Imports System.Data.SqlClient
Public Class Form1
Ahora crearemos nuestra cadena de conexión

Public Class Form1
Dim cn As New SqlConnection("Server=(local);Integrated
Security=yes;Database=BDFactura")
Crearemos un Procedimiento en el SQL cual se encargara de mostrar el

Listado de todos los Clientes
----------Listado_Cliente----------------
-----------------------------------------
--Creamos Ahora el Procedimiento
create Procedure Listado_Cliente
as
select cli_codigo,cli_nombre,cli_telefono,cli_ruc,cli_direccion from Clientes
Ahora en el Visual Studio creamos un procedimiento el cual se encargara de

mostrar el listado de los clientes
Sub Listado()
Dim da As New SqlDataAdapter("Listado_Cliente", cn)
Dim dt As New DataTable
da.Fill(dt)
DataGridView1.DataSource = dt
End Sub
Ahora realizaremos el llamado a nuestro procedimiento para que cuando

cargue el formulario me liste los Clientes
Private Sub Form1_Load(…) Handles MyBase.Load

Listado()
End Sub
A continuación crearemos un Procedimiento Limpiar, el cual se encargara de

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

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

SqlParameter("@cod_cli", SqlDbType.Char, 5)
paramResultado.Direction = ParameterDirection.Output
cmd.Parameters.Add(paramResultado)
cn.Open()
cmd.ExecuteReader()
cn.Close()
lblcod.Text = paramResultado.Value
End Sub
Ahora crearemos un procedimiento almacenado en el SQL, el cual me

registre al Cliente
----------Grabar_Cliente------------
------------------------------------
create procedure Grabar_Cliente
@cod varchar(5),
@nom varchar(25),
@tel int,
@ruc varchar(11),
@dir varchar(30)
as
insert into clientes values(@cod,@nom,@tel,@ruc,@dir)
Nota:
MsgBox("Desea Grabar", 4 + 32, "Mensaje")
4 Botones Yes o No
32 Icono de Informacion
6 Si le dimos Yes
7 Si le dimos No
Ahora programaremos en el Botón Grabar
Private Sub btngrabar_Click(…) Handles btngrabar.Click
If (MsgBox("Desea Grabar", 4 + 32, "Mensaje") = 6) Then

Dim cod, nom, ruc, dir As String
Dim tel As Integer : cod = lblcod.Text : nom = txtnom.Text
ruc = txtruc.Text : dir = txtdir.Text : tel = txttel.Text
Dim cmd As New SqlCommand("Grabar_Cliente", cn)

cmd.Parameters.Add("@cod",SqlDbType.VarChar,5).Value = cod
cmd.Parameters.Add("@nom",SqlDbType.VarChar,25).Value = nom
cmd.Parameters.Add("@tel",SqlDbType.Int).Value = tel
cmd.Parameters.Add("@ruc",SqlDbType.VarChar,11).Value = ruc
cmd.Parameters.Add("@dir",SqlDbType.VarChar, 30).Value = dir
Dim rpta As Integer '1 Grabo 0 No Grabo

'Abrimos la conecion
cn.Open() : rpta = cmd.ExecuteNonQuery() : cn.Close()
If (rpta = 1) Then
MsgBox("Se Grabo Correctamente", 32, "Mensaje")
Listado()
Else
MsgBox("Error al Grabar", 16, "Mensaje")
End If
End If
End Sub
Ahora pasaremos los datos del DatagridView a las cajas del Textos para
realizar las modificaciones
Private Sub DataGridView1_CurrentCellChanged(…) Handles
DataGridView1.CurrentCellChanged
Try
Dim posi As Integer
'Fila Seleccionada
posi = DataGridView1.CurrentCell.RowIndex
lblcod.Text = DataGridView1(0, posi).Value txtnom.Text =
DataGridView1(1, posi).Value
txttel.Text = DataGridView1(2, posi).Value
txtruc.Text = DataGridView1(3, posi).Value
txtdir.Text = DataGridView1(4, posi).Value
Catch ex As Exception
End Try
End Sub
Ahora crearemos un procedimiento almacenado en el SQL, el cual se

encargara de la actualización de los datos del cliente
----------Actualizar_Cliente-------
create procedure Actualizar_Cliente
@cod varchar(5),@nom varchar(25),
@tel int,@ruc varchar(11),
@dir varchar(30)
as
update clientes set cli_nombre=@nom,cli_telefono=@tel,
cli_ruc=@ruc,cli_direccion=@dir where cli_codigo=@cod
Ahora programaremos en el botón Modificar
Private Sub btnactualiz_Click(…) Handles btnactualiz.Click

If (MsgBox("Desea Actualizar", 4 + 32, "Mensaje") = 6) Then
Dim cod, nom, ruc, dir As String
Dim tel As Integer : cod = lblcod.Text:nom = txtnom.Text:ruc = txtruc.Text
dir = txtdir.Text :tel = txttel.Text
Dim cmd As New SqlCommand("Actualizar_Cliente", cn)
cmd.Parameters.Add("@cod", SqlDbType.VarChar, 5).Value = cod
cmd.Parameters.Add("@nom", SqlDbType.VarChar, 25).Value = nom
cmd.Parameters.Add("@tel", SqlDbType.Int).Value = tel
cmd.Parameters.Add("@ruc", SqlDbType.VarChar, 11).Value = ruc
cmd.Parameters.Add("@dir", SqlDbType.VarChar, 30).Value = dir
Dim rpta As Integer
cn.Open()
rpta = cmd.ExecuteNonQuery()
cn.Close()
If (rpta = 1) Then
MsgBox("Se Actualizo Correctamente", 32, "Mensaje")
Listado()
Else
MsgBox("Error al Actualizar", 16, "Mensaje")
End If : End If : End Sub
Ahora crearemos un procedimiento almacenado en el SQL, el cual se
encargara de eliminar a un cliente
----------Eliminar_Cliente------
create procedure Eliminar_Cliente
@cod varchar(5)
as
delete from clientes where cli_codigo=@cod
Ahora programaremos en el botón Eliminar
Private Sub btneliminar_Click(…) Handles btneliminar.Click

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

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

SQL
use northwind
go
----------Listado_Cliente----------------
-----------------------------------------
create Procedure Listado_Empleado
as
select EmployeeID,LastName + ' , '+ FirstName as Nombre_apellido
from Employees
go
----------Facturas vendidas----------------
-----------------------------------------
create Procedure Facturas_Empleado
@codven int
as
select OrderID,convert(char(10),OrderDate,103) Fecha,ShipCountry
from Orders
where EmployeeID=@codven
go
----------Facturas vendidas----------------
-----------------------------------------
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 seleccionamos Visual Basic y seleccionamos Aplicación para

Windows Se le dara erl nombre de Consultas
Ahora realizaremos el siguiente diseño:
Lo primero que realizaremos es importar estas 2 librerías
Imports System.IO 'MemoryStream
A continuación crearemos nuestra cadena de conexión

Imports System.IO 'MemoryStream
Public Class Consulta
Dim cn As New SqlConnection("Server=(local);Integrated Security=yes;database=northwind")
Ahora programaremos para que cuando cargue el formulario me liste los

empleados
Private Sub Consulta_Load(…) Handles MyBase.Load

Dim da As New SqlDataAdapter("Listado_Empleado", cn)
da.Fill(dt)
ListBox1.DataSource = dt
ListBox1.DisplayMember = "Nombre_apellido"
ListBox1.ValueMember = "EmployeeID"
'StretchImage ajusta la imagen al tamaño del PictureBox1
PictureBox1.SizeMode = PictureBoxSizeMode.StretchImage
End Sub
Crearemos nuestro procedimiento para Mostrar la foto
Sub Mostrar_imagen(ByVal cod As Integer)

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

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.Image = bmp
End Sub
Ahora programaremos en el ListBox, para que cuando seleccionemos uno

de los empleados nos visualice las fotos y las facturas vendidas por dicho
empleado
Private Sub ListBox1_SelectedIndexChanged(…) Handles
ListBox1.SelectedIndexChanged
Try
Dim cod As Integer = CInt(ListBox1.SelectedValue)
Dim cmd As New SqlCommand("Facturas_Empleado", cn)
cmd.Parameters.Add("@codven", SqlDbType.Int).Value = cod

da.Fill(dt)
Mostrar_imagen(cod)
End Try
End Sub
Presionamos finalmente F5
Lo primero que vamos hacer es crear los procedimientos almacenados en el

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

set quoted_identifier off
go
create procedure Lista_Detalle

@fac varchar(255)
as
exec("select fac_numero,a.art_codigo,art_nombre,art_precio,art_cantidad,
(art_precio*art_cantidad) Total
from articulos as a,fac_deta fd
where a.art_codigo=fd.art_codigo
and fac_numero in ("+@fac+")")
go
--probamos el procedimiento
Lista_Detalle "'F0001','F0002','F0003'"
Ahora lo que vamos a hacer es abrir el Visual Studio 2005
Ahora 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

Security=yes;database=BDfactura")
A continuación programaremos para que cuando cargue el formulario me

llene el 1er DatagridView con todas las facturas realizadas
Private Sub DatagridViewCheckBox_Load(…) Handles MyBase.Load
Dim da As New SqlDataAdapter("Lista_Facturas", cn)
da.Fill(dt)
End Sub
Ahora programaremos en el botón

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

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

seleccionamos uno o más proveedores con el botón Mostrar nos listara
todos los productos que tienen los proveedores seleccionados
3. Mostrar en un ListBox las regiones, cuando seleccionamos una región nos

mostrara los territorios de dicha región, cuando seleccionamos la región nos
mostrara los empleados que viven en dicha región, seleccionamos un
empleado y nos mostrara las ventas realizadas por dicho empleado.
4. Mostrar un listado de categorías, cuando seleccionamos la categoría nos
visualizara la foto respectiva, y a la vez nos mostrara los productos que se
encuentran en dicha categoría.
También nos permitirá hacer un filtrado de las facturas que son mayores al
monto ingresado.
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
Lo primero que vamos a hacer es abrir el Visual Studio 2005.

Este será el modelo a desarrollar

Lo primero que vamos a realizar es crear nuestros procedimientos
almacenados en el SQL
Nuestro primer procedimiento almacenado me listara el código y nombre del

cliente pero solo de los clientes que tengan facturas
----------Listado_Cliente----------------
-----------------------------------------
as
select cli_codigo,cli_nombre from clientes where cli_codigo
in(select distinct cli_codigo from ac_cabe)
go
Ahora crearemos un procedimiento almacenado el cual me listara las

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

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

create procedure Detalle_Factura
@fac varchar(5)
as
select fac_numero,a.art_codigo,art_nombre,art_precio,art_cantidad,
(art_precio* art_cantidad) as Total from Articulos as a, Fac_deta as fd
where a.art_codigo = fd.art_codigo
and fd.fac_numero=@fac
go
Ahora crearemos nuestro diseño en el Visual Studio Net el siguiente diseño

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

En esta clase crearemos una función el cual me devuelva mi cadena de
conexión, y así poder usarla en todas las demás clases
Public Class clsconexion
Function cn() As String
Dim cadena As String
cadena = "Server=(local);Integrated Security=SSPI;"
cadena += "Database=bdfactura"
Return cadena
End Function
End Class
Ahora crearemos otra clase el cual llamaremos a todos nuestros

procedimientos almacenados, además llamaremos a nuestra clase
clsconexion ya que en ella está mi conexión
Y ahora programaremos lo siguiente
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
da.Fill(dt)
Return dt
End Function
'Esta funcion nos mostrara la facturas del cliente

Function Facturas_Clientes(ByVal cod As String) As DataTable
Dim cmd As New SqlCommand("Facturas_Cliente", cn)
cmd.Parameters.Add("@cod", SqlDbType.VarChar).Value = cod
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.Parameters.Add("@fac", SqlDbType.VarChar).Value = fac
da.Fill(dt)
Return dt
End Function
End Class
Ahora en el formulario vamos a importar
Ahora llamaremos a nuestra clase clsfunciones
Public Class Form1
Dim funcion As New clsfunciones

clientes.

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

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

If (Tvclientes.SelectedNode.Level = 1) Then
'Capturamos el nro de la Factura seleccionada
Dim fac As String = Tvclientes.SelectedNode.Text
dt = funcion.Detalle_Factura(fac)
dgfacturas.DataSource = dt
lblsuma.Text = dt.Compute("sum(Total)", "")
End If
End Try
End Sub
Finalmente presionamos F5 y nos debe quedar de la siguiente manera

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

aplicacion de Windows
Este será el modelo a desarrollar

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

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
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
nuestro proyecto, para ello seleccionamos el Proyecto y luego Clic Agregar y
finalmente seleccionamos Clase

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

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

'Esta funcion me Listara a los clientes q tengan Facturas
Function Lista_Cliente() As 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.Parameters.Add("@codigos", SqlDbType.VarChar).Value = cod
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
Public Class Form1
Dim clase As New clsfunciones

clientes

formato()
Dim lstitem As ListViewItem
dt = clase.Lista_Cliente
For a As Integer = 0 To dt.Rows.Count - 1
lstitem = ListView1.Items.Add(dt.Rows(a)(0))
lstitem.SubItems.Add(dt.Rows(a)(1))
Next
End Sub
'Procedimiento que le da formato al ListView1
Sub formato()
With ListView1
.CheckBoxes = True 'Mostramos CheckBoxes en el ListView1
.View = View.Details 'Vista Detalle
.GridLines = True 'Lineas de separacion filas y columnas
.Columns.Add("Codigo del Cliente", 120, HorizontalAlignment.Center)
.Columns.Add("Nombre del Cliente", 300, HorizontalAlignment.Left)
End With
End Sub
Ahora vamos a programar en el botón para que nos muestre las facturas de
los clientes seleccionado
Private Sub BtnBuscar_Click(…) Handles BtnBuscar.Click
Dim cod, codigo As String
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
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)

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

almacenados que vamos a utilizar.
use BDfactura
--LISTADO de las Facturas
as
select fac_numero, convert(char(10),fac_fecha,103) Fecha from fac_cabe
go

@fac varchar(255)
as
(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,

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

nuestro proyecto.

conexión, y así poder usarla en todas las demás clases
Return cadena
End Function
End Class
Ahora crearemos otra clase el cual llamaremos clsfunciones, ahí estarán

todos nuestros procedimientos almacenados, además llamaremos a nuestra
clase clsconexion.
Function Listado_facturas() As DataTable
da.Fill(dt)
Return dt
End Function
Function Detalle_Facturas(ByVal fac As String) As DataTable


da.Fill(dt)
Return dt
End Function
End Class
Ahora en el formulario vamos a llamar a nuestra clase
Public Class Link_datagridview

Dim funciones As New clsfunciones
Ahora programaremos para que cuando cargue el formulario me liste las

facturas
Private Sub Link_datagridview_Load(…) Handles MyBase.Load

dt = funciones.Listado_facturas
End Sub
Ahora programaremos en el datagridView1

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

dt = funciones.Detalle_Facturas(fac)
End If
End Sub
Almacenamiento de imágenes mediante carpeta.

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

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

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

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

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
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.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.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.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.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()
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.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
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----------------
as
select cli_codigo,cli_nombre from Clientes
go
----------Facturas_Cliente----------------
create Procedure Facturas_Cliente
@cod varchar(5)
as
select fac_numero from fac_cabe where cli_codigo=@cod
go
----------Detalle de la Factura-----------
create procedure Detalle_Factura
@fac varchar(5)
as
(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.
Public Class clsclase

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)
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)
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)
Dim da As New SqlDataAdapter(cmd) : Dim dt As New DataTable :
da.Fill(dt)
Return dt
End Function
End Class
Una vez terminado de crear todas las funciones vamos a generar la DLL
Si nos damos cuenta, nuestro proyecto ha generado una DLL,

A continuación vamos agregar un Proyecto Windows en nuestra solución
Al cual le llamaremos Mi_Proyecto
A continuación agregaremos a nuestro proyecto la DLL que hemos creado,

para ello vamos agregar una referencia
Ahora buscamos nuestra DLL y le damos OK
Ahora importamos a nuestro Proyecto
Imports System.Data
Public Class Form1
Ahora instanciaremos el nombre de nuestra librería
Imports System.Data
Public Class Form1
Dim milibreria As New Libreria_Clases.clsclase
Ahora programaremos para que cuando cargue mi formulario me liste los

clientes
Dim dr As SqlDataReader
dr = milibreria.Lista_Cliente
While (dr.Read)
Cbocliente.Items.Add(dr(0) & " " & dr(1))
End While
Cbocliente.SelectedIndex = 0
End Sub
Ahora programaremos en el combo
Private Sub Cbocliente_SelectedIndexChanged(…) Handles
Cbocliente.SelectedIndexChanged
Try
Dim cod As String
'Extraemos los 5 Primeros caracteres
cod = Mid(Cbocliente.Text, 1, 5)
'Ahora LLenaremos las Facturas del Cliente
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)
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
dt = milibreria.Detalle_Factura(fac)
dgfacturas.DataSource = dt
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
Lo primero que vamos a realizar es crear los procedimientos almacenados

en SQL.
use BDFACTURA
go
----------Listado_Cliente----------------
-----------------------------------------
as
select cli_codigo,cli_nombre,cli_telefono,cli_ruc,cli_direccion
from Clientes
go
----------Genera_Codigo----------------
-----------------------------------------
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
Exec Genera_Codigo @codigo Output
print @codigo
go
----------Grabar_Cliente----------------
-----------------------------------------
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----------------
-----------------------------------------
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----------------
-----------------------------------------
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
Public Class Capa_Datos

Dim cn As New SqlConnection("Server=(local);Integrated Security=yes;
Database=bdfactura")
Function D_Listado_Clientes() As 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.Parameters.Add("@nom", SqlDbType.VarChar).Value = nom
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.Parameters.Add("@nom", SqlDbType.VarChar).Value = nom
cmd.Parameters.Add("@ruc", SqlDbType.VarChar).Value = ruc
cmd.Parameters.Add("@dir", SqlDbType.VarChar).Value = dir
cn.Open()
Return p
End Function
Function D_Eliminar_Cliente(ByVal cod As String) As Integer

Dim cmd As New SqlCommand("Eliminar_Cliente", cn)
cn.Open()
Return p
End Function
Function D_Genera_Codigo() As String
Dim cmd As New SqlCommand("Genera_Codigo", cn)
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.
Public Class Capa_Negocio

'Ahora referenciamos a la capa de datos
Dim objdatos As New Capa_Datos.Capa_Datos
Function N_Listado_Clientes() As DataTable

Return objdatos.D_Listado_Clientes()
End Function
Function N_Grabar_Cliente(ByVal cod As String, ByVal nom As String, ByVal

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

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

Return objdatos.D_Eliminar_Cliente(cod)
End Function
Function N_Genera_Codigo() As String

Return objdatos.D_Genera_Codigo()
End Function
End Class
Ahora a la solución agregaremos un proyecto y lo llamaremos Capa de

Presentación.
Ahora en la capa de presentación agregaremos la referencia
Seleccionamos
Ahora tenemos que configurar para que se ejecute desde la capa de

presentación
Ahora agregaremos un
Ahora vamos a editar el ToolStrip, para ello seleccionamos el ToolStrip y le

damos clic derecho
Ahora agregaremos 5 botones
En sus propiedades a cada botón escogeremos
Name btnnuevo
ToolTipText Nuevo
Image Seleccionamos una
imagen
Al final nos debe quedar de la siguiente manera
Ahora vamos a importar a la capa de negocio
Public Class Form1

Dim objnegocio As New Capa_Negocio.Capa_Negocio

Clientes
listado()
End Sub
Sub listado()
dt = objnegocio.N_Listado_Clientes
End Sub
Ahora programaremos en el botón Nuevo
Private Sub btnnuevo_Click(…) Handles btnnuevo.Click

Dim ctrl As New Control
'recorremos todos los controles que estan dentro
'del GroupBox1
For Each ctrl In GroupBox1.Controls
'Preguntamos si es TextBox
If TypeOf ctrl Is TextBox Then
ctrl.Text = ""
End If
Next
Dim codigo As String : codigo = objnegocio.N_Genera_Codigo
lblcod.Text = codigo : txtnom.Focus()
End Sub
Ahora programaremos en el botón Grabar
Private Sub btnGrabar_Click(…) Handles btnGrabar.Click

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

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

If (MsgBox("Desea Modificar", 4 + 32, "Mensaje") = 6) Then
Dim cod, nom, ruc, dir As String : Dim tel As Integer
cod = lblcod.Text : nom = txtnom.Text
ruc = txtruc.Text : dir = txtdir.Text : tel = CInt(txttel.Text) : Dim p As
Integer
p = objnegocio.N_Actualizar_Cliente(cod, nom, tel, ruc, dir)
If (p > 0) Then
MsgBox("Se Modifico Correctamente", 32, "Mensaje Sistema")
listado()
Else
MsgBox("Error al Modificar", 4, "Mensaje Sistema")
End If
End If
End Sub
Ahora programaremos en el botón Eliminar
Private Sub btneliminar_Click(…) Handles btneliminar.Click

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

Me.Close()
End Sub
Finalmente le damos F5

en SQL.
use BDfactura
----Facturas Realizadas

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

go

@fac varchar(255)
as
exec("select fac_numero,a.art_codigo,art_nombre,art_precio,art_cantidad,
(art_precio*art_cantidad) Total
from articulos as a,fac_deta fd where a.art_codigo=fd.art_codigo
and fac_numero in ("+@fac+")")
go
--probamos el procedimiento
Lista_Detalle "'F0001','F0002','F0003'"
Ahora en el visual Studio vamos a crear una nueva solución en blanco la

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

Security=yes;Database=bdfactura")
Function D_Facturas_Clientes() As DataTable

Dim dt As New DataTable : da.Fill(dt) : Return dt
End Function
Function D_Detalle_Facturas(ByVal fac As String) As DataTable
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

Dim objdatos As New Capa_Datos.Capa_Dato
Function N_Facturas_Clientes() As DataTable

Return objdatos.D_Facturas_Clientes()
End Function
Function N_Detalle_Facturas(ByVal fac As String) As DataTable

Return objdatos.D_Detalle_Facturas(fac)
End Function
End Class
Una vez generado la capa de negocio, ahora agregaremos un proyecto a la

solución, la llamaremos Capa de presentación
Ahora realizaremos el siguiente diseño
A continuación a la capa de presentación le agregaremos una referencia que

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

Ahora programaremos para que cuando cargue el formulario nos liste las
facturas realizadas
dt = objnegocio.N_Facturas_Clientes()
CheckedListBox1.MultiColumn = True
CheckedListBox1.Items.Add(dt.Rows(a)(0))
Next
End Sub
Ahora programaremos en el botón Ver Facturas

Private Sub btnver_Click(…) Handles btnver.Click
Dim cod, codigo, fac As String
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
codigo = Mid(fac, 1, tamaño - 1)
dt = objnegocio.N_Detalle_Facturas(codigo)
End If
End Sub

en SQL.
use bdfactura
create procedure Lista_Ranking

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

create procedure Mostrar_Facturas
@cod varchar(5)
as
select fac_numero,convert(char(10),fac_fecha,103) Fecha,fac_total
from fac_cabe as fc,clientes as c where c.cli_codigo=fc.cli_codigo and
c.cli_codigo=@cod
go
Ahora en el visual Studio vamos a crear una nueva solución en blanco

llamada Consulta_Solucion Dentro de la solución, ahora agregaremos un
proyecto de biblioteca de clases, la cual llamaremos Capa de Datos
Ahora a la capa de datos vamos a crear una clase la cual contendrá mi
conexión a la BD
Y lo llamaremos Clsconexion Ahora programaremos lo siguiente
Imports System.Data
Public Class Clsconexion
Public Function conexion_SQL() As String
Dim cn As String
cn = "Server=(local);Integrated Security=yes;Database=bdfactura"
Return cn
End Function
End Class
Ahora agregaremos una clase más a la biblioteca Capa_Datos y la

llamaremos D_datos
Y ahora programaremos lo siguiente.
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.Parameters.Add("@cant", SqlDbType.Int).Value = cant
End Function
Function D_Facturas_Cliente(ByVal codcli As String) As DataTable

Dim cmd As New SqlCommand("Mostrar_Facturas", cn)
cmd.Parameters.Add("@cod", SqlDbType.VarChar).Value = codcli
End Function
End Class
Ahora en la solución creada vamos agregar otra biblioteca de clases la

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

Dim objdato As New Capa_Datos.D_Datos
Function N_Muestra_Ranking(ByVal cant As Integer) As DataTable

Return objdato.D_Muestra_Ranking(cant)
End Function
Function N_Facturas_Cliente(ByVal codcli As String) As DataTable

Return objdato.D_Facturas_Cliente(codcli)
End Function
End Class
Luego de haber generado la capa de negocio, ahora a la solución

agregaremos un proyecto y la llamaremos capa Presentación
A continuación realizaremos el siguiente diseño
Ahora en la capa de presentación agregaremos la referencia de la

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

capa_Negocio
Public Class Form1

Ahora vamos a programar para darle valores máximos y mínimos del
NumericUpDown1

'Vamos a darle El maximo y minimo valor al NumericUpDown1
NumericUpDown1.Maximum = 10
NumericUpDown1.Minimum = 1
End Sub
Ahora programaremos en el botón Filtrar
Private Sub btnfiltrar_Click(…) Handles btnfiltrar.Click

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

dt = objnegocio.N_Muestra_Ranking(cant)
End Sub
Ahora programaremos en el DatagridView1 para que cuando le demos Clic

nos muestre las facturas en el DatagridView2
Private Sub DataGridView1_CellClick(…) Handles

DataGridView1.CellClick
Dim p As Integer
p = DataGridView1.CurrentCell.RowIndex
Dim cod As String = DataGridView1(0, p).Value
dt = objnegocio.N_Facturas_Cliente(cod)
End Sub
Ahora presionamos F5

en SQL
use bdfactura
go
----------Listado_Cliente----------------
-----------------------------------------
as
select cli_codigo,cli_nombre from clientes where cli_codigo in(select distinct
cli_codigo from fac_cabe)
go
-----------------------------------------
go

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'"
llamada Consulta_Solucion.
Dentro de la solución, ahora agregaremos una biblioteca de clases, la cual

llamaremos Capa de Datos

conexión a la BD con el nombre de Clsconexion
Imports System.Data

Dim cn As String
Return cn
End Function
End Class
Ahora agregaremos una clase más a la biblioteca y la llamaremos D_datos

'cone.conexion_SQL llamamos a la Cadena de conexion que hicimos „en la clase
Clsconexion
Function D_Lista_Cliente() As 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.Parameters.Add("@codigos", SqlDbType.VarChar).Value = codcli
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
de 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

agregaremos un proyecto y la llamaremos capa Presentación

capa_Negocio
Ahora realizaremos una referencia a la capa de Negocio
Public Class Form1

Ahora programaremos para Listar los clientes a penas cargue el formulario

formato()
dt = objnegocio.N_Lista_Cliente()
Next
End Sub
Sub formato() 'Formato del ListView1

With ListView1
.GridLines = True 'Muestre Lineas de separacion entre filas y columnas
End With
End Sub
Ahora programaremos en el Botón Ver Facturas

Private Sub Btnver_Click(…) Handles Btnver.Click
cod = ""
Try

End If
Next
End Try

Dim dt As New DataTable : dt = objnegocio.N_Fact_Cli_Varios(codigo)
'A la columna 2 le damos un ancho de 200
DataGridView1.Columns(2).Width = 200
End Sub
Aplicación 1:
Realizar el siguiente programa siguiente las siguientes consideraciones:

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

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

emitida, y deberá demostrar en el Listview1, su detalle de venta de esa
orden.
Aplicación 2:
Se pide a usted que cree una aplicaron que permita realizar una consulta de
datos bajo las siguientes consideraciones:
Cuando seleccione cualquier Radiobuttons, deberá demostrar todos los

Customers que se encuentran mediante el rango de letras seleccionado.
Antes de presionar el botón Búsqueda de Ordenes, deberá de tener como

parámetro el código del Customers seleccionado, y las fechas ingresadas. Y
deberá demostrar como resultado en el ListView1, todas las Ordenes
emitidas por los parámetros dados, mostrando los siguientes campos bajo
las siguientes consideraciones:
El campo OrderID.
El campo RequiredDate, que es la fecha que se requería el producto.
Creara un campo TotalVenta, que es la suma del producto de UnitPrice *
Quantity.
Creara un campo DiasEnvio, que es la diferencia de ShippedDate –

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

siguiente criterio:
Si los días de envió es mayor o igual a 10, entonces “Fuera de fecha”.
Si los días de envió es menor de 10, entonces “Entrega inmediata”.
Y por ultimo al seleccionar una fila del ListView1, deberá de capturar el

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

controladores de bases de datos. Cada controlador se escribe para
controlar un tipo de base de datos específico o la tecnología de acceso
a bases de datos.
Modelos de extracción e inserción:
Con el fin de ofrecer el acceso a datos más flexible para los

programadores, los controladores de base de datos de Crystal Reports
se han diseñado para proporcionar un modelo de extracción e
inserción de acceso a datos.
Modelo de extracción
En un modelo de extracción, el controlador se conectará a la base

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

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

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

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

controlador de base de datos utilizado para crear el informe. No
obstante, si los datos se insertan en el informe, el informe seleccionará
el controlador adecuado para controlar el conjunto de registros o el
conjunto de datos.
Controladores de bases de datos con Crystal Reports para Visual Studio

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

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

que tenga un proveedor de datos de la base de datos
ODBC. como la inserción de datos
de registros RDO.
Access/Excel Bases de datos de Admite tanto la extracción

Microsoft Access y libros de datos de la base de datos
de Microsoft Excel. como la inserción de datos
de registros DAO.
ADO.NET Cualquier base de datos Admite la inserción de datos
con un proveedor en el informe desde un
gestionado. conjunto de datos ADO.NET.
Este controlador
no extraerá datos por
sí mismo.
Definición de Ninguna. El controlador se incluye

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

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

está disponible durante el
período de creación del
informe. Seleccione uno de
los controladores
disponibles para crearlo.
REPORTES EN .NET CON CRYSTAL REPORTS
Visual Studio .NET incluye Crystal Reports como un mecanismo "oficial" de

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

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

Encabezado de página, aparece en la parte superior de todas las páginas.
Detalle: lo más importante. En el tiempo de ejecución, se genera una de
estas secciones para cada línea (registro) en la base de datos.
Pie de página, aparece en la parte inferior de todas las páginas.
Pie de reporte, aparece al final del reporte.
En un principio, todos los reportes presentan estas cinco secciones. Otras
secciones son opcionales, como por ejemplo:
Encabezado de grupo, aparece antes de un grupo.
Pie de grupo, aparece al final del grupo.
Se podrá omitir una o más secciones, en caso de que no sean necesarias.
Acceder a la base de datos.
Antes de crear el reporte, hay que decidir cuál será el mecanismo utilizado
para acceder a la base de datos. Crystal Reports puede obtener datos de una
infinidad de fuentes, pero una buena cantidad de ellas, como DAO, ADO y
OLE/DB, no está "administrada", o sea, es código .NET "puro". En una
aplicación .NET, probablemente sea deseable realizar el acceso a través de
ADO.NET. Para ello, lo más fácil es definir un Conjunto de datos tipificado,
aun antes de crear el reporte.
Primero vamos a crear nuestro procedimiento almacenado en el SQL

Use northwind
go
Create procedure Lista_Clientes

as
select CustomerID,CompanyName,ContactName,ContactTitle
from customers
go
Ahora si ejecutamos nuestro procedimiento almacenado nos listara todos
los clientes
Ahora lo que haremos es aprender a mostrar esos clientes en un reporte,

para ello lo primero que realizaremos es crear un proyecto
Ahora en nuestro proyecto agregamos un CrystalReportViewer a nuestro
formulario
Al final nos deberá quedar de la siguiente manera
Ahora en el proyecto le damos clic derecho y agregamos lo siguiente
A Continuación vamos aceptar la licencia del CrystalReports

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

A continuación seleccionamos el proveedor de la BD, en este caso es el SQL
Server
Ahora configuramos para seleccionar
Y por ultimo le damos Finalizar

Ahora seleccionamos los procedimientos almacenados que puedan existir
en la BD
Dentro de los procedimientos almacenados, seleccionamos el procedimiento

almacenado que hemos creado y le damos siguiente.
Como nos damos cuenta nos salen los campos que va a visualizar nuestro
procedimiento almacenado, ahora vamos a seleccionar los campos a
vizualizar
Una vez agregado los campos, le damos siguiente
Como no vamos agruparlo, le damos finalizar.
Y nos quedara de la siguiente manera

Ahora si queremos cambiar el formato de las etiquetas, le damos Clic
derecho
Le damos el respectivo formato y finalmente Aceptar
Nos quedara de la siguiente manera

Ahora vamos agregar un titulo general a nuestro Reporte, para ello
Y finalmente nos quedara de la siguiente manera
Si queremos ver cómo va quedando nuestro reporte, le damos en

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

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

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

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

formulario
Vamos agregar 2 MaskedTextBox y vamos a darle una mascara
Ahora seleccionamos el tipo Fecha
Y por ultimo agregamos un CrystalReportViewer donde se va a visualizar mi

reporte, al final nos quedara de la siguiente manera
Ahora en el proyecto le damos clic derecho y agregamos un Crystal Report
A Continuación vamos aceptar la licencia del CrystalReports
Ahora seleccionamos
Ahora lo que vamos a realizar es establecer la conexión a la BD

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

en la BD

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

visualizar (todos)
Como no vamos agruparlo, le damos finalizar.

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

'Estilo para la ubicacion de nuestro CrptReporte
CrptReporte.Dock = DockStyle.Bottom
'Desabilitamos la vizualizacion en grupos
CrptReporte.DisplayGroupTree = False
End Sub
Ahora
Private Sub BtnFiltrar_Click(…) Handles BtnFiltrar.Click
Dim fecha1, fecha2 As Date
fecha1 = CDate(mktxtini.Text)
fecha2 = CDate(mktxtfin.Text)
'vamos a instanciar el nombre de nuestro Reporte Creado

Dim rpt As New Rpt_Ordenes
'los parametros que recibe
rpt.SetParameterValue("@fe1", fecha1)
rpt.SetParameterValue("@fe2", fecha2)
'Pasamos nuestro reporte creado al CrptReporte
CrptReporte.ReportSource = rpt
End Sub
Finalmente presionamos F5 y nos deberá mostrar

en SQL
use bdfactura
go
----------Listado_Cliente----------------
-----------------------------------------
as
select cli_codigo,cli_nombre from clientes
where cli_codigo in(select distinct cli_codigo from fac_cabe)
go
-----------------------------------------

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'"
Dentro de la solución, ahora agregaremos una biblioteca de clases, la cual

llamaremos Capa de Datos

conexión a la BD
Y lo llamaremos Clsconexion
Imports System.Data
Dim cn As String
Return cn
End Function
End Class
Ahora agregaremos una clase más al proyecto Capa_Datos y lo llamaremos

D_datos

'cone.conexion_SQL llamamos a la Cadena de conexion que hicimos „en la clase Clsconexion
Function D_Lista_Cliente() As DataTable

da.Fill(dt)
Return dt
End Function
End Class
Una vez generada la capa de datos, Ahora en la solución creada vamos

agregar una Nueva
Biblioteca de calses y la llamaremos capa_Negocio

de Datos

Function N_Lista_Cliente() As DataTable

Return objdato.D_Lista_Cliente()
End Function
End Class

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

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

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


en la BD

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
visualizar (agregar todos).
Una vez agregado los campos, le damos siguiente
Y ahora lo vamos agrupar por el código del Cliente

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

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

Ahora programaremos para Listar los clientes a penas cargue el formulario

CrystalReportViewer1.Dock = DockStyle.Bottom

formato()
dt = objnegocio.N_Lista_Cliente()
Next
End Sub
Sub formato() 'Formato del ListView1

With ListView1
.GridLines = True 'Muestre Lineas de separacion entre filas y columnas
End With : End Sub
Ahora programaremos en el Botón Ver Facturas
Private Sub btnbuscar_Click(…) Handles btnbuscar.Click

cod = ""
Try

End If
Next
End Try
Dim rpt As New Rpt_Facturas_Clientes
rpt.SetParameterValue("@codigos", codigo)
CrystalReportViewer1.ReportSource = rpt
End Sub
Finalmente presionamos F5 y vemos el resultado.

SQL Server Visual Net

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

SQL Server Visual Net

Uploaded by

Copyright:

Available Formats

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

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

SELECT <atributos> FROM <tablas>

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

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

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

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

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

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

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

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

SELECT title, price FROM titles

SELECT * FROM titles

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

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

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

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

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

SELECT * FROM titleauthor WHERE

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

SELECT * FROM titles WHERE price <= 2

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

SELECT au_fname FROM authors WHERE au_fname LIKE '[C-

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

SELECT title FROM titles WHERE price

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

SELECT au_lname FROM authors GROUP BY

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

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

SELECT au_lname FROM authors GROUP BY au_lname HAVING au_lname =

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

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

SELECT au_lname, au_fname FROM authors ORDER BY au_lname

Entendemos por funciones escalares, todas aquellas que permiten realizar

SELECT sum(precio) FROM pedido

SELECT sum(precio) FROM pedido WHERE cod_cliente =

SELECT count(DNI) FROM cliente

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

SELECT count(*) FROM cliente

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

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