alter procedure pa_tabla

@numero int
as
if @numero>=0 and @numero<=12
begin
declare @resultado int
declare @i int
set @i=1
while (@i<=12)
begin
set @resultado=@numero*@i
print str(@i) +' '+ str(@numero)+ ' '+str( @resultado)
set @i=@i+1
end
end
else select 'Debe ingresar un número entre 0 y 12';
exec pa_tabla 13
create table tbraiz(
nro integer,
raiz float
)
alter procedure raiz
as
begin
declare @resultado float
declare @i int
set @i=1
while (@i<=30)
begin
set @resultado=sqrt(@i)
print concat(str(@i), space(4) ,@resultado)
 insert into tbraiz(nro,raiz)
values(@i,@resultado)
set @i=@i+1
end
end
exec raiz

select * from tbraiz

create table ejemplo(
codigo int,
fecha datetime
)

create procedure sp1

as
DECLARE @x INT
SET @x = 1
WHILE (@x <= 10)
BEGIN
INSERT INTO ejemplo(codigo,fecha)
VALUES (@x,getdate())
SET @x = @x + 1
END

exec sp1

select * from ejemplo

create procedure sp2

as
DECLARE @x INT
SET @x = 1
WHILE (@x <= 10)
BEGIN
INSERT INTO ejemplo(codigo,fecha)
VALUES (@x,dateadd(month,@i,fecha)
SET @x = @x + 1
END
sin
cos
tan
Trabajamos con la tabla "libros" de una librería.
Eliminamos la tabla "libros", si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla especificando que el campos "código" genere valores secuenciales comenzando
en 1 e incrementándose en 1 automáticamente:

create table libros(

codigo int identity,

titulo varchar(40) not null,

autor varchar(30),

editorial varchar(15),

precio float

);

Ingresamos algunos registros, recordando que si un campo tiene el atributo "identity" debemos
omitirlo en la inserción:

insert into libros (titulo,autor,editorial,precio)

values('El aleph','Borges','Emece',23);

Veamos cómo se almacenó:

select *from libros;

Este primer registro ingresado guarda el valor 1 en el campo correspondiente al código.

Continuemos ingresando registros:

insert into libros (titulo,autor,editorial,precio)

values('Uno','Richard Bach','Planeta',18);

insert into libros (titulo,autor,editorial,precio)

values('Aprenda PHP','Mario Molina','Siglo XXI',45.60);

insert into libros (titulo,autor,editorial,precio)

values('Alicia en el pais de maravillas','Lewis Carroll','Paidos',15.50);

Veamos cómo se almacenaron:

select *from libros;

el código (dato que no ingresamos) se cargó automáticamente siguiendo la secuencia de
autoincremento.

Intentemos ingresar un valor para el campo "codigo":

insert into libros (codigo,titulo,autor,editorial,precio)

values(5,'Martin Fierro','Jose Hernandez','Paidos',25);

generará un mensaje de error.

Un campo "identity" tampoco puede ser actualizado. Intentemos cambiar el valor de código de un
registro:

update libros set codigo=9

where titulo='Uno';

aparece un mensaje de error.

Vamos a ver la estructura de la tabla ejecutando el siguiente procedimiento almacenado:

sp_columns libros;

Note que en el campo "codigo", en la columna "TYPE_NAME" aparece "int identity" y en la

columna IS_NULLABLE" aparece "NO", porque un campo "identity" automáticamente se convierte
en "not null". En el campo "titulo", en la columna "IS_NULLABLE" aparece "NO" porque
explícitamente indicamos que el campo fuera "not null".

Eliminemos el último registro:

delete from libros

where autor='Lewis Carroll';

Ingresamos un quinto registro y luego vemos que en el campo código se guardó el valor secuencial
sin considerar que el valor "4" ya no existe:

insert into libros (titulo, autor, editorial, precio)

values('Martin Fierro','Jose Hernandez','Paidos',25);

select *from libros;

Trabajamos con la tabla "libros" que almacena los datos de los libros de una librería.
Eliminamos la tabla, si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,

titulo varchar(30),

autor varchar(20),

editorial varchar(15),

precio float

);

Agregamos algunos registros:

insert into libros (titulo,autor,editorial,precio)

values ('El aleph','Borges','Emece',25.60);

insert into libros (titulo,autor,editorial,precio)

values ('Uno','Richard Bach','Planeta',18);

Seleccionamos todos los registros:

select *from libros;

Truncamos la tabla:

truncate table libros;

Ingresamos nuevamente algunos registros:

insert into libros (titulo,autor,editorial,precio)

values ('El aleph','Borges','Emece',25.60);

insert into libros (titulo,autor,editorial,precio)

values ('Uno','Richard Bach','Planeta',18);

Si seleccionamos todos los registros vemos que la secuencia se reinició en 1:

select *from libros;

Eliminemos todos los registros con "delete":

delete from libros;

Ingresamos nuevamente algunos registros:

insert into libros (titulo,autor,editorial,precio)

values ('El aleph','Borges','Emece',25.60);

insert into libros (titulo,autor,editorial,precio)

values ('Uno','Richard Bach','Planeta',18);

Seleccionamos todos los registros y vemos que la secuencia continuó:

select *from libros;

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

Eliminamos la tabla, si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla definiendo un valor por defecto para el campo "autor" y otro para el campo
"cantidad":

create table libros(

codigo int identity,

titulo varchar(40),

autor varchar(30) not null default 'Desconocido',

editorial varchar(20),

precio decimal(5,2),

cantidad tinyint default 0

);

Ingresamos un registro omitiendo los valores para el campo "autor" y "cantidad":

insert into libros (titulo,editorial,precio)

values('Java en 10 minutos','Paidos',50.40);

SQL Server ingresará el registro con el siguiente valor de la secuencia en "codigo", con el título,
editorial y precio ingresados, en "autor" colocará "Desconocido" y en cantidad "0":

select *from libros;

Si ingresamos un registro sin valor para el campo "precio", que admite valores nulos, se ingresará
"null" en ese campo:

insert into libros (titulo,editorial)

values('Aprenda PHP','Siglo XXI');

select *from libros;

Visualicemos la estructura de la tabla:

sp_columns libros;

La columna "COLUMN_DEF", muestra el valor por defecto de cada campo.

Podemos emplear "default" para dar el valor por defecto a algunos campos:

insert into libros (titulo,autor,precio,cantidad)

values ('El gato con botas',default,default,100);

select *from libros;

Como todos los campos de "libros" tienen valores predeterminados, podemos tipear:

insert into libros default values;

select *from libros;

La sentencia anterior almacenará un registro con los valores predetermiandos para cada uno de
sus campos.

Que un campo tenga valor por defecto no significa que no admita valores nulos, puede o no
admitirlos. Podemos ingresar el valor "null" en el campo "cantidad":

insert into libros (titulo,autor,cantidad)

values ('Alicia en el pais de las maravillas','Lewis Carroll',null);

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

Eliminamos la tabla si existe:

if object_id ('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

 codigo int identity,

titulo varchar(40) not null,

autor varchar(20) default 'Desconocido',

editorial varchar(20),

precio decimal(6,2),

primary key (codigo)

);

Ingresamos algunos registros:

insert into libros (titulo,autor,editorial,precio)

values('El aleph','Borges','Emece',25.33);

insert into libros

values('Java en 10 minutos','Mario Molina','Siglo XXI',50.65);

insert into libros (titulo,autor,editorial,precio)

values('Alicia en el pais de las maravillas','Lewis Carroll','Emece',19.95);

insert into libros (titulo,autor,editorial,precio)

values('Alicia en el pais de las maravillas','Lewis Carroll','Planeta',15);

Recuperamos los registros ordenados por el título:

select *from libros

order by titulo;

Ordenamos los registros por el campo "precio", referenciando el campo por su posición en la lista
de selección:

select titulo,autor,precio

from libros order by 3;

Los ordenamos por "editorial", de mayor a menor empleando "desc":

select *from libros

order by editorial desc;

Ordenamos por dos campos:

select *from libros

order by titulo,editorial;
Ordenamos en distintos sentidos:

select *from libros

order by titulo asc, editorial desc;

Podemos ordenar por un campo que no se lista en la selección:

select titulo, autor

from libros

order by precio;

Está permitido ordenar por valores calculados:

select titulo, autor, editorial,

precio+(precio*0.1) as 'precio con descuento'

from libros

order by 4;

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

Eliminamos la tabla si existe:

if object_id ('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,

titulo varchar(40) not null,

autor varchar(20) default 'Desconocido',

editorial varchar(20),

precio decimal(6,2),

);

Ingresamos algunos registros:

insert into libros

values('El aleph','Borges','Emece',15.90);
insert into libros

values('Cervantes y el quijote','Borges','Paidos',null);

insert into libros

values('Alicia en el pais de las maravillas','Lewis Carroll',null,19.90);

insert into libros

values('Martin Fierro','Jose Hernandez','Emece',25.90);

insert into libros (titulo,autor,precio)

values('Antología poética','Borges',25.50);

insert into libros (titulo,autor,precio)

values('Java en 10 minutos','Mario Molina',45.80);

insert into libros (titulo,autor)

values('Martin Fierro','Jose Hernandez');

insert into libros (titulo,autor)

values('Aprenda PHP','Mario Molina');

Recuperamos los registros en los cuales esté almacenado el valor "null" en el campo "editorial":

select *from libros

where editorial is null;

Seleccionamos los libros que no contiene "null" en "editorial":

select *from libros

where editorial is not null;

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

Eliminamos la tabla si existe:

if object_id ('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,

 titulo varchar(40) not null,

autor varchar(20) default 'Desconocido',

editorial varchar(20),

precio decimal(6,2),

);

Ingresamos algunos registros:

insert into libros

values('El aleph','Borges','Emece',15.90);

insert into libros

values('Cervantes y el quijote','Borges','Paidos',null);

insert into libros

values('Alicia en el pais de las maravillas','Lewis Carroll',null,19.90);

insert into libros

values('Martin Fierro','Jose Hernandez','Emece',25.90);

insert into libros (titulo,autor,precio)

values('Antología poética','Borges',32);

insert into libros (titulo,autor,precio)

values('Java en 10 minutos','Mario Molina',45.80);

insert into libros (titulo,autor,precio)

values('Martin Fierro','Jose Hernandez',40);

insert into libros (titulo,autor,precio)

values('Aprenda PHP','Mario Molina',56.50);

Recuperamos los registros cuyo precio esté entre 20 y 40 empleando "between":

select *from libros

where precio between 20 and 40;

Note que si el campo tiene el valor "null", no aparece en la selección.

Para seleccionar los libros cuyo precio NO esté entre un intervalo de valores antecedemos "not" al
"between":

select *from libros

 where precio not between 20 and 35;

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

Eliminamos la tabla si existe:

if object_id ('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,

titulo varchar(40) not null,

autor varchar(20) default 'Desconocido',

editorial varchar(20),

precio decimal(6,2),

primary key(codigo)

);

Ingresamos algunos registros:

insert into libros

values('El aleph','Borges','Emece',15.90);

insert into libros

values('Antología poética','J. L. Borges','Planeta',null);

insert into libros

values('Alicia en el pais de las maravillas','Lewis Carroll',null,19.90);

insert into libros

values('Matematica estas ahi','Paenza','Siglo XXI',15);

insert into libros

values('Martin Fierro','Jose Hernandez',default,40);

insert into libros

values('Aprenda PHP','Mario Molina','Nuevo siglo',56.50);

Recuperamos todos los libros que contengan en el campo "autor" la cadena "Borges":

select *from libros

where autor like '%Borges%';

Seleccionamos los libros cuyos títulos comienzan con la letra "M":

select *from libros

where titulo like 'M%';

Seleccionamos todos los títulos que NO comienzan con "M":

select *from libros

where titulo not like 'M%';

Si queremos ver los libros de "Lewis Carroll" pero no recordamos si se escribe "Carroll" o "Carrolt",
podemos emplear el comodín "_" (guión bajo) y establecer la siguiente condición:

select *from libros

where autor like '%Carrol_';

Buscamos los libros cuya editorial comienza con las letras entre la "P" y la "S":

select titulo,autor,editorial

from libros

where editorial like '[P-S]%';

Seleccionamos los libros cuya editorial NO comienza con las letras "P" ni "N":

select titulo,autor,editorial

from libros

where editorial like '[^PN]%';

Recuperamos todos los libros cuyo precio se encuentra entre 10.00 y 19.99:

select titulo,precio from libros

where precio like '1_.%';

Recuperamos los libros que NO incluyen centavos en sus precios:

select titulo,precio from libros

where precio like '%.00';

Trabajamos con la tabla "libros" de una librería.
Eliminamos la tabla si existe:

if object_id ('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,

titulo varchar(40) not null,

autor varchar(20) default 'Desconocido',

editorial varchar(20),

precio decimal(6,2),

primary key(codigo)

);

Ingresamos algunos registros:

insert into libros

values('El aleph','Borges','Emece',15.90);

insert into libros

values('Antología poética','J. L. Borges','Planeta',null);

insert into libros

values('Alicia en el pais de las maravillas','Lewis Carroll',null,19.90);

insert into libros

values('Matematica estas ahi','Paenza','Siglo XXI',15);

insert into libros

values('Martin Fierro','Jose Hernandez',default,40);

insert into libros

values('Aprenda PHP','Mario Molina','Nuevo siglo',null);

insert into libros

values('Uno','Richard Bach','Planeta',20);

Averiguemos la cantidad de libros usando la función "count()":

select count(*)

from libros;

Note que incluye todos los libros aunque tengan valor nulo en algún campo.

Contamos los libros de editorial "Planeta":

select count(*)

from libros

where editorial='Planeta';

Contamos los registros que tienen precio (sin tener en cuenta los que tienen valor nulo), usando la
función "count(precio)":

select count(precio)

from libros;

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

Eliminamos la tabla, si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,

titulo varchar(40) not null,

autor varchar(30) default 'Desconocido',

editorial varchar(15),

precio decimal(5,2),

cantidad tinyint,

primary key(codigo)

);

Ingresamos algunos registros:

insert into libros

values('El aleph','Borges','Planeta',15,null);
insert into libros

values('Martin Fierro','Jose Hernandez','Emece',22.20,200);

insert into libros

values('Antologia poetica','J.L. Borges','Planeta',null,150);

insert into libros

values('Aprenda PHP','Mario Molina','Emece',18.20,null);

insert into libros

values('Cervantes y el quijote','Bioy Casares- J.L. Borges','Paidos',null,100);

insert into libros

values('Manual de PHP', 'J.C. Paez', 'Siglo XXI',31.80,120);

insert into libros

values('Harry Potter y la piedra filosofal','J.K. Rowling',default,45.00,90);

insert into libros

values('Harry Potter y la camara secreta','J.K. Rowling','Emece',46.00,100);

insert into libros (titulo,autor,cantidad)

values('Alicia en el pais de las maravillas','Lewis Carroll',220);

insert into libros (titulo,autor,cantidad)

values('PHP de la A a la Z',default,0);

Para conocer la cantidad total de libros, sumamos las cantidades de cada uno:

select sum(cantidad)

from libros;

Retorna 980; verifique la suma, sumando los valores de todos los registros del campo "cantidad".

Queremos saber cuántos libros tenemos de la editorial "Emece":

select sum(cantidad)

from libros

where editorial='Emece';

retorna 300.

Queremos saber cuál es el libro más costoso; usamos la función "max()":

select max(precio)
 from libros;

retorna 46.00.

Para conocer el precio mínimo de los libros de "Rowling" tipeamos:

select min(precio)

from libros

where autor like '%Rowling%';

retorna 45.00.

Queremos saber el promedio del precio de los libros referentes a "PHP":

select avg(precio)

from libros

where titulo like '%PHP%';

Devuelve 25.00. Note que hay 3 libros sobre "PHP", pero uno de ellos tiene precio nulo entonces
SQL Server no lo incluye para calcular el promedio.

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

Eliminamos la tabla, si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,

titulo varchar(40),

autor varchar(30),

editorial varchar(15),

precio decimal(5,2),

cantidad tinyint,

primary key(codigo)

);

Ingresamos algunos registros:

insert into libros

values('El aleph','Borges','Planeta',15,null);

insert into libros

values('Martin Fierro','Jose Hernandez','Emece',22.20,200);

insert into libros

values('Antologia poetica','J.L. Borges','Planeta',null,150);

insert into libros

values('Aprenda PHP','Mario Molina','Emece',18.20,null);

insert into libros

values('Cervantes y el quijote','Bioy Casares- J.L. Borges','Paidos',null,100);

insert into libros

values('Manual de PHP', 'J.C. Paez', 'Siglo XXI',31.80,120);

insert into libros

values('Harry Potter y la piedra filosofal','J.K. Rowling',default,45.00,90);

insert into libros

values('Harry Potter y la camara secreta','J.K. Rowling','Emece',null,100);

insert into libros

values('Alicia en el pais de las maravillas','Lewis Carroll','Paidos',22.50,200);

insert into libros

values('PHP de la A a la Z',null,null,null,0);

Queremos saber la cantidad de libros de cada editorial, utilizando la cláusula "group by":

select editorial, count(*)

from libros

group by editorial;

El resultado muestra los nombres de las editoriales y la cantidad de registros para cada valor del
campo. Note que los valores nulos se procesan como otro grupo.

Obtenemos la cantidad libros con precio no nulo de cada editorial:

select editorial, count(precio)

from libros
 group by editorial;

La salida muestra los nombres de las editoriales y la cantidad de registros de cada una, sin contar
los que tienen precio nulo.

Para conocer el total en dinero de los libros agrupados por editorial, tipeamos:

select editorial, sum(precio)

from libros

group by editorial;

Obtenemos el máximo y mínimo valor de los libros agrupados por editorial, en una sola sentencia:

select editorial,

max(precio) as mayor,

min(precio) as menor

from libros

group by editorial;

Calculamos el promedio del valor de los libros agrupados por editorial:

select editorial, avg(precio)

from libros

group by editorial;

Es posible limitar la consulta con "where". Vamos a contar y agrupar por editorial considerando
solamente los libros cuyo precio es menor a 30 pesos:

select editorial, count(*)

from libros

where precio<30

group by editorial;

Note que las editoriales que no tienen libros que cumplan la condición, no aparecen en la salida.
Para que aparezcan todos los valores de editorial, incluso los que devuelven cero o "null" en la
columna de agregado, debemos emplear la palabra clave "all" al lado de "group by":

select editorial, count(*)

from libros

where precio<30

group by all editorial;

Trabajamos con la tabla "libros" de una librería.
Eliminamos la tabla, si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,

titulo varchar(40),

autor varchar(30),

editorial varchar(15),

primary key(codigo)

);

Ingresamos algunos registros:

insert into libros

values('El aleph','Borges','Planeta');

insert into libros

values('Martin Fierro','Jose Hernandez','Emece');

insert into libros

values('Martin Fierro','Jose Hernandez','Planeta');

insert into libros

values('Antologia poetica','Borges','Planeta');

insert into libros

values('Aprenda PHP','Mario Molina','Emece');

insert into libros

values('Aprenda PHP','Lopez','Emece');

insert into libros

values('Manual de PHP', 'J. Paez', null);

insert into libros

values('Cervantes y el quijote',null,'Paidos');

insert into libros

values('Harry Potter y la piedra filosofal','J.K. Rowling','Emece');

insert into libros

values('Harry Potter y la camara secreta','J.K. Rowling','Emece');

insert into libros

values('Alicia en el pais de las maravillas','Lewis Carroll','Paidos');

insert into libros

values('Alicia en el pais de las maravillas','Lewis Carroll','Planeta');

insert into libros

values('PHP de la A a la Z',null,null);

insert into libros

values('Uno','Richard Bach','Planeta');

Para obtener la lista de autores sin repetición tipeamos:

select distinct autor from libros;

Note que aparece "null" como un valor para "autor"· Para obtener la lista de autores conocidos, es
decir, no incluyendo "null" en la lista:

select distinct autor from libros

where autor is not null;

Contamos los distintos autores:

select count(distinct autor)

from libros;

Queremos los nombres de las editoriales sin repetir:

select distinct editorial from libros;

Queremos saber la cantidad de editoriales distintas:

select count(distinct editorial) from libros;

La combinamos con "where" para obtener los distintos autores de la editorial "Planeta":

select distinct autor from libros

 where editorial='Planeta';

Contamos los distintos autores que tiene cada editorial empleando "group by":

select editorial,count(distinct autor)

from libros

group by editorial;

Mostramos los títulos y editoriales de los libros sin repetir títulos ni editoriales:

select distinct titulo,editorial

from libros

order by titulo;

Note que los registros no están duplicados, aparecen títulos iguales pero con editorial diferente,
cada registro es diferente.

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

Eliminamos la tabla, si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,

titulo varchar(40),

autor varchar(20),

editorial varchar(20)

);

Ingresamos algunos registros:

insert into libros values ('Uno','Richard Bach','Planeta');

insert into libros values ('El aleph','Borges','Emece');

insert into libros values ('Alicia en el pais...','Carroll','Planeta');

insert into libros values ('Aprenda PHP','Mario Molina','Siglo XXI');

insert into libros values ('Java en 10 minutos','Mario Molina','Siglo XXI');

insert into libros values ('Java desde cero','Mario Molina','Emece');

insert into libros values ('Ilusiones','Richard Bach','Planeta');

Obtenemos todos los datos de los primeros 2 libros de la tabla:

select top 2 *from libros;

Mostramos los títulos y autores de los 3 primeros libros ordenados por autor:

select top 3 titulo,autor

from libros

order by autor;

Realizamos la misma consulta anterior pero empleamos la cláusula "with ties", con lo cual
incluiremos en la selección, todos los registros que tengan el mismo autor que el último registro
retornado, aunque pasemos de 3:

select top 3 with ties titulo,autor

from libros

order by autor;

Note que retorna los 5 primeros registros porque incluye los dos siguientes que tienen el mismo
valor que el último en el campo "autor" (por el cual se ordena).

Clave primaria compuesta

if object_id('vehiculos') is not null

drop table vehiculos;

Creamos la tabla estableciendo dos campos como clave primaria:

create table vehiculos(

patente char(6) not null,

tipo char(1),--'a'=auto, 'm'=moto

horallegada datetime,

horasalida datetime,

primary key(patente,horallegada)

);

Ingresamos algunos registros:

insert into vehiculos values('AIC124','a','8:05','12:30');

insert into vehiculos values('CAA258','a','8:05',null);

insert into vehiculos values('DSE367','m','8:30','18:00');

insert into vehiculos values('FGT458','a','9:00',null);

insert into vehiculos values('AIC124','a','16:00',null);

insert into vehiculos values('LOI587','m','18:05','19:55');

Si intentamos ingresar un registro con clave primaria repetida:

insert into vehiculos values('LOI587','m','18:05',null);

aparece un mensaje de error y la inserción no se realiza.

Si ingresamos un registro repitiendo el valor de uno de los campos que forman parte de la clave, si
lo acepta:

insert into vehiculos values('LOI587','m','21:30',null);

Si intentamos actualizar un registro repitiendo la clave primaria:

update vehiculos set horallegada='8:05'

where patente='AIC124' and horallegada='16:00';

aparece un mensaje de error y la actualización no se realiza.

Recordemos que los campos que forman parte de la clave primaria no aceptan valores nulos,
aunque no se haya aclarado en la definición de la tabla:

insert into vehiculos values('HUO690','m',null,null);

Si mostramos la estructura de la tabla:

sp_columns vehiculos;

vemos que los campos que forman parte de la clave primaria (patente y horallegada) tienen "NO"
en la columna "IS_NULLABLE", es decir, no admiten valores nulos.

Restricción default

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

Eliminamos la tabla, si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,

titulo varchar(40),

autor varchar(30) default 'Desconocido',

editorial varchar(15),

precio decimal(6,2)

);

Ingresamos algunos registros sin valor para el campo "autor":

insert into libros (titulo,editorial) values('Martin Fierro','Emece');

insert into libros (titulo,editorial) values('Aprenda PHP','Emece');

Veamos que SQL Server creó automáticamente una restricción "default" para el campo "autor":

sp_helpconstraint libros;

aparece la siguiente información:

constraint_type constraint_name ... constraint_keys

--------------------------------------------------------------------------------

DEFAULT on column autor DF_libros_autor (n/a) ('Desconocido')

La restricción, a la cual no le dimos un nombre, recibe un nombre dado por SQL Server
"DF_libros_autor_67C95AEA", que consiste en "DF" (por default), seguido del nombre de la tabla,
el nombre del campo y unos números y letras aleatorios.

Vamos a eliminar la tabla y la crearemos nuevamente, sin la cláusula "default":

drop table libros;

create table libros(

codigo int identity,

titulo varchar(40),

autor varchar(30),

editorial varchar(15),

precio decimal(6,2)

);
Agregamos una restricción "default" empleando "alter table" para que almacene el valor
"Desconocido" en el campo "autor":

alter table libros

add constraint DF_libros_autor

default 'Desconocido'

for autor;

Veamos la restrición agregada anteriormente con el procedimiento almacenado

"sp_helpcontraint":

sp_helpconstraint libros;

aparece la siguiente información:

constraint_type constraint_name ... constraint_keys

---------------------------------------------------------------------------------

DEFAULT on column autor DF_libros_autor (n/a) ('Desconocido')

Agregamos algunos registros:

insert into libros (titulo,editorial) values('Martin Fierro','Emece');

insert into libros default values;

Veamos cómo se almacenaron los registros sin valor explícito para el campo con restricción
"default":

select *from libros;

Agregamos otra restricción "default" para el campo "precio" para que almacene el valor 0 en dicho
campo:

alter table libros

add constraint DF_libros_precio

default 0

for precio;

Veamos la restrición agregada anteriormente con el procedimiento almacenado

"sp_helpcontraint":

sp_helpconstraint libros;

Restricción check
Trabajamos con la tabla "libros" de una librería.
Eliminamos la tabla, si existe:

if object_id('libros') is not null

drop table libros;

La creamos e ingresamos algunos registros:

create table libros(

codigo int identity,

titulo varchar(40),

autor varchar(30),

editorial varchar(15),

preciomin decimal(5,2),

preciomay decimal(5,2)

);

insert into libros values ('Uno','Bach','Planeta',22,20);

insert into libros values ('El quijote','Cervantes','Emece',15,13);

insert into libros values ('Aprenda PHP','Mario Molina','Siglo XXI',48,53);

insert into libros values ('Java en 10 minutos','Garcia','Siglo XXI',35,40);

Agregamos una restricción "check" para asegurar que los valores de los campos correspondientes
a precios no puedan ser negativos:

alter table libros

add constraint CK_libros_precios_positivo

check (preciomin>=0 and preciomay>=0);

Si intentamos ingresar un valor inválido para algún campo correspondiente al precio, que vaya en
contra de la restricción, por ejemplo el valor "-15" aparecerá un mensaje de error indicando que
hay conflicto con la restricción creada anteriormente y la inserción no se realiza. Igualmente si
intentamos actualizar un precio, que vaya en contra de la restricción.

Si intentamos agregar una restricción que no permita que el precio mayorista supere el precio
minorista, aparece un mensaje de error y la sentencia no se ejecuta, porque hay registros que no
cumplen con la restricción que intentamos establecer. Podemos modificar los datos que no
cumplen la condición de la restricción o eliminar los registros:
update libros set preciomay=48

where titulo='Aprenda PHP';

delete from libros where titulo='Java en 10 minutos';

Ahora SQL Server si nos permite agregar la restricción "check" que impida que se ingresen valores
para "preciomay" superiores a "preciomin":

alter table libros

add constraint CK_libros_preciominmay

check (preciomay<=preciomin);

Veamos las restricciones de la tabla:

sp_helpconstraint libros;

Ingresamos un registro con valores por defecto:

insert into libros default values;

Note que los campos correspondientes a precios admiten valores 0 y 999.99 (por el tipo de dato y
la restricción), además del valor "null".

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

Eliminamos la tabla, si existe:

if object_id('libros') is not null

drop table libros;

La creamos estableciendo el campo código como clave primaria:

create table libros(

codigo int not null,

titulo varchar(40),

autor varchar(30),

editorial varchar(15),

precio decimal(6,2)

);

Definimos una restricción "primary key" para nuestra tabla "libros" para asegurarnos que cada
libro tendrá un código diferente y único:

alter table libros

add constraint PK_libros_codigo

primary key(codigo);

Definimos una restricción "check" para asegurarnos que el precio no será negativo:

alter table libros

add constraint CK_libros_precio

check (precio>=0);

Definimos una restricción "default" para el campo "autor" para que almacene "Desconocido":

alter table libros

add constraint DF_libros_autor

default 'Desconocido'

for autor;

Definimos una restricción "default" para el campo "precio" para que almacene 0:

alter table libros

add constraint DF_libros_precio

default 0

for precio;

Vemos las restricciones:

sp_helpconstraint libros;

Aparecen 4 restricciones, 1 "check", 2 "default" y 1 "primary key".

Eliminamos la restricción "DF_libros_autor":

alter table libros

drop DF_libros_autor;

Eliminamos la restricción "PK_libros_codigo":

alter table libros

drop PK_libros_codigo;

Vemos si se eliminaron:

sp_helpconstraint libros;

Aparecen 2 restricciones.
Crear y asociar reglas (create rule - sp_bindrule)

Una empresa tiene registrados datos de sus empleados en una tabla llamada "empleados".
Eliminamos la tabla si existe:

if object_id('empleados') is not null

drop table empleados;

La creamos con la siguiente estructura:

create table empleados (

documento varchar(8) not null,

nombre varchar(30),

seccion varchar(20),

fechaingreso datetime,

fechanacimiento datetime,

hijos tinyint,

sueldo decimal(6,2)

);

Recuerde que las reglas son objetos independientes de las tablas (no se eliminan al borrar la
tabla), así que debemos eliminarlas con las siguientes intrucciones (en el siguiente capítulo
explicaremos este tema):

if object_id ('RG_documento_patron') is not null

drop rule RG_documento_patron;

if object_id ('RG_empleados_seccion') is not null

drop rule RG_empleados_seccion;

if object_id ('RG_empleados_fechaingreso') is not null

drop rule RG_empleados_fechaingreso;

if object_id ('RG_hijos') is not null

drop rule RG_hijos;

if object_id ('RG_empleados_sueldo') is not null

drop rule RG_empleados_sueldo;

if object_id ('RG_empleados_sueldo2') is not null

drop rule RG_empleados_sueldo2;

Ingresamos algunos registros:

insert into empleados

values('22222222','Ana Acosta','Contaduria','1990-10-10','1972-10-10',2,700);

insert into empleados

values('23333333','Carlos Costa','Contaduria','1990-12-10','1972-05-04',0,750);

insert into empleados

values('24444444','Daniel Duarte','Sistemas','1995-05-05','1975-10-06',1,880);

insert into empleados

values('25555555','Fabiola Fuentes','Secretaria','1998-02-25','1978-02-08',3,550);

insert into empleados

values('26666666','Gaston Garcia','Secretaria','1999-05-08','1981-01-01',3,670);

insert into empleados

values('27777777','Ines Irala','Gerencia','2000-04-10','1985-12-12',0,6000);

Creamos una regla que establezca un patrón para el documento:

create rule RG_documento_patron

as @documento like '[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]';

Ejecutamos el procedimiento almacenado del sistema "sp_help" para ver si la regla creada
anteriormente fue creada:

sp_help;

Ejecutamos el procedimiento almacenado del sistema "sp_helpconstraint" para ver si está

asociada la regla a algún campo de "empleados":

sp_helpconstraint empleados;

No aparece porque aún no la asociamos.

Si ingresamos un registro con un documento que no cumpla la regla, SQL Server lo acepta porque
la regla aún no está asociada al campo:

insert into empleados

values('ab888888','Juan Juarez','Secretaria','2001-04-11','1986-11-12',0,600);

Asociamos la regla "RG_documento_patron" al campo "documento":

exec sp_bindrule RG_documento_patron, '[Link]';

Note que hay un documento que no cumple la regla, pero SQL Server no controla los datos
existentes, actúa en inserciones y actualizaciones, si intentamos ingresar un valor para
"documento" en el cual incluyamos caracteres, aparecerá un mensaje de error.

Volvemos a ejecutar "sp_helpconstraint":

sp_helpconstraint empleados;

Aparece la regla.

Creamos una regla para restringir los valores que se pueden ingresar en un campo "seccion":

create rule RG_empleados_seccion

as @seccion in ('Secretaria','Contaduria','Sistemas','Gerencia');

La asociamos al campo "seccion":

exec sp_bindrule RG_empleados_seccion, '[Link]';

Creamos una regla para restringir los valores que se pueden ingresar en el campo "fechaingreso",
para que no sea posterior a la fecha actual:

create rule RG_empleados_fechaingreso

as @fecha <= getdate();

Asociamos la regla anteriormente creada a los campos "fechaingreso" y "fechanacimiento":

exec sp_bindrule RG_empleados_fechaingreso, '[Link]';

exec sp_bindrule RG_empleados_fechaingreso, '[Link]';

Creamos una regla para restringir los valores que se pueden ingresar en el campo "hijos":

create rule RG_hijos

as @hijos between 0 and 20;

La asociamos al campo "hijos":

exec sp_bindrule RG_hijos, '[Link]';

Creamos una regla para restringir los valores que se pueden ingresar en un campo "sueldo":

create rule RG_empleados_sueldo

as @sueldo>0 and @sueldo<= 5000;

La asociamos al campo "sueldo":

exec sp_bindrule RG_empleados_sueldo, '[Link]';

Si intentamos ingresar (o actualizar) un registro con el valor "6000" para "sueldo", SQL Server
muestra un mensaje de error y la acción no se realiza.

Creamos otra regla para restringir los valores que se pueden ingresar en un campo "sueldo":

create rule RG_empleados_sueldo2

as @sueldo>0 and @sueldo<= 7000;

La asociamos al campo "sueldo":

exec sp_bindrule RG_empleados_sueldo2, '[Link]';

La nueva regla reeemplaza la asociación anterior. Ahora podemos ingresar el valor "6000" en el
campo "sueldo":

insert into empleados

values('29999999','Luis Lopez','Secretaria','2002-03-03','1990-09-09',0,6000);

La regla "RG_empleados_sueldo" no desaparece, solamente se deshizo la asociación, veámoslo:

sp_help;

La regla "RG_empleados_sueldo" aún existe en la base de datos.

Veamos las reglas asociadas:

sp_helpconstraint empleados;

La regla "RG_empleados_sueldo" ya no está asociada a ningún campo de la tabla "empleados" así

que no aparece; la regla "RG_empleados_sueldo2" si, junto con las otras 5 reglas asociadas.
Valores predeterminados (create default)

Una empresa registra los datos de sus empleados en una tabla llamada "empleados".
Eliminamos la tabla "empleados" si existe:

if object_id ('empleados') is not null

drop table empleados;

También debemos eliminar los valores predeterminados con las siguientes intrucciones (en el
siguiente capítulo explicaremos este tema):

if object_id ('VP_cero') is not null

drop default VP_cero;

if object_id ('VP_100') is not null

drop default VP_100;

if object_id ('VP_datodesconocido') is not null

drop default VP_datodesconocido;

if object_id ('VP_telefono') is not null

drop default VP_telefono;

Creamos la tabla:

create table empleados(

nombre varchar(30),

domicilio varchar(30),

barrio varchar(15),

telefono char(14),

sueldo decimal(6,2)

);

Ingresamos un registro sin valores para ver qué valores por defecto se almacenan:

insert into empleados default values;

select *from empleados;

Creamos un valor predeterminado con el valor "Desconocido":

create default VP_datodesconocido

as 'Desconocido';
Lo asociamos al campo "domicilio":

exec sp_bindefault VP_datodesconocido, '[Link]';

Lo asociamos al campo "barrio":

exec sp_bindefault VP_datodesconocido, '[Link]';

Ingresamos otro registro sin especificar valores y vemos los datos:

insert into empleados default values;

select *from empleados;

Creamos un valor predeterminado que inserta el valor "0":

create default VP_cero

as 0;

Lo asociamos al campo "sueldo":

exec sp_bindefault VP_cero, '[Link]';

Ingresamos un registro y verificamos los datos:

insert into empleados default values;

select *from empleados;

Creamos un valor predeterminado que inserta el valor "100":

create default VP_100

as 100;

Lo asociamos al campo "sueldo":

exec sp_bindefault VP_100, '[Link]';

Recuerde que si asociamos a un campo que ya tiene asociado un valor predeterminado otro valor
predeterminado, la nueva asociación reemplaza a la anterior. Verificamos:

insert into empleados default values;

select *from empleados;

Veamos los valores predeterminados asociadas a la tabla "empleados":

sp_helpconstraint empleados;

El valor predeterminado "VP_cero" no aparece porque no está asociado a ningún campo de

"empleados"; si aparecen "VP_100", "VP_datodesconocido" que está asociado a 2 campos
(domicilio y barrio).

Veamos si "VP_cero" existe, ejecutando el procedimiento almacenado del sistema "sp_help":

sp_help;

Aún existe en la base de datos.

Creamos un valor predeterminado que inserta ceros con el formato válido para un campo número
de teléfono:

create default VP_telefono

as '(0000)0-000000';

La asociamos al campo "telefono" de la tabla "empleados":

exec sp_bindefault VP_telefono,'[Link]';

Ingresamos un registro y verificamos los valores predeterminados almacenados:

insert into empleados default values;

select *from empleados;

Veamos los valores predeterminados asociadas a la tabla "empleados":

sp_helpconstraint empleados;

Aparecen 4 filas, una por cada asociación.

Creación de índices

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

Eliminamos la tabla si existe y la creamos:

if object_id('libros') is not null

drop table libros;

create table libros(

codigo int identity,

titulo varchar(40),

autor varchar(30),

editorial varchar(15)

);

Creamos un índice agrupado único para el campo "codigo" de la tabla "libros":

create unique clustered index I_libros_codigo

on libros(codigo);

Creamos un índice no agrupado para el campo "titulo":

create nonclustered index I_libros_titulo

on libros(titulo);

Veamos los indices de "libros":

sp_helpindex libros;

Aparecen 2 filas, uno por cada índice. Muestra el nombre del índice, si es agrupado (o no), primary
(o unique) y el campo por el cual se indexa.

Creamos una restricción "primary key" al campo "codigo" especificando que cree un índice NO
agrupado:

alter table libros

add constraint PK_libros_codigo

primary key nonclustered (codigo);

Verificamos que creó un índice automáticamente:

sp_helpindex libros;

El nuevo índice es agrupado, porque no se especificó.

Analicemos la información que nos muestra "sp_helpconstraint":

sp_helpconstraint libros;

En la columna "constraint_type" aparece "PRIMARY KEY" y entre paréntesis, el tipo de índice

creado.

Creamos un índice compuesto para el campo "autor" y "editorial":

create index I_libros_autoreditorial

on libros(autor,editorial);

Se creará uno no agrupado porque no especificamos el tipo, además, ya existe uno agrupado y
solamente puede haber uno por tabla.

Consultamos la tabla "sysindexes":

select name from sysindexes;

Veamos los índices de la base de datos activa creados por nosotros podemos tipear la siguiente
consulta:

select name from sysindexes

where name like 'I_%';

Combinaciones con update y delete

Una librería almacena la información de sus libros para la venta en dos tablas, "libros" y
"editoriales".
Eliminamos ambas tablas, si existen:

if object_id('libros') is not null

drop table libros;

if object_id('editoriales') is not null

drop table editoriales;

Creamos las tablas:

create table libros(

codigo int identity,

titulo varchar(40),

autor varchar(30) default 'Desconocido',

codigoeditorial tinyint not null,

precio decimal(5,2)

);

create table editoriales(

codigo tinyint identity,

nombre varchar(20),

primary key (codigo)

);

Ingresamos algunos registros en ambas tablas:

insert into editoriales values('Planeta');

insert into editoriales values('Emece');

insert into editoriales values('Siglo XXI');

insert into libros values('El aleph','Borges',2,20);

insert into libros values('Martin Fierro','Jose Hernandez',1,30);

insert into libros values('Aprenda PHP','Mario Molina',3,50);

insert into libros values('Java en 10 minutos',default,3,45);

Aumentamos en un 10% los precios de los libros de editorial "Planeta":

update libros set precio=precio+(precio*0.1)

from libros

join editoriales as e

on codigoeditorial=[Link]

where nombre='Planeta';

Veamos el resultado:

select titulo,autor,[Link],precio

from libros as l

join editoriales as e

on codigoeditorial=[Link];

Eliminamos todos los libros de editorial "Emece":

delete libros

from libros

join editoriales

on codigoeditorial = [Link]

where [Link]='Emece';

Veamos si se eliminaron:

select titulo,autor,[Link],precio

from libros as l

join editoriales as e

on codigoeditorial=[Link];

Restricciones al crear la tabla

Trabajamos con las tablas "libros", "autores" y "editoriales" de una librería:
Eliminamos las tablas si existen:

if object_id('libros') is not null

drop table libros;

if object_id('editoriales') is not null

drop table editoriales;

if object_id('autores') is not null

drop table autores;

Creamos la tabla "editoriales" con una restricción "primary key":

create table editoriales(

codigo tinyint not null,

nombre varchar(30),

constraint PK_editoriales primary key (codigo)

);

Creamos la tabla "autores" con una restricción "primary key", una "unique" y una "check":

create table autores(

codigo int not null

constraint CK_autores_codigo check (codigo>=0),

nombre varchar(30) not null,

constraint PK_autores_codigo

primary key (codigo),

constraint UQ_autores_nombre

unique (nombre),

);

Aplicamos varias restricciones cuando creamos la tabla "libros":

create table libros(

codigo int identity,

titulo varchar(40),

codigoautor int not null,

 codigoeditorial tinyint not null,

precio decimal(5,2)

constraint DF_libros_precio default (0),

constraint PK_libros_codigo

primary key clustered (codigo),

constraint UQ_libros_tituloautor

unique (titulo,codigoautor),

constraint FK_libros_editorial

foreign key (codigoeditorial)

references editoriales(codigo)

on update cascade,

constraint FK_libros_autores

foreign key (codigoautor)

references autores(codigo)

on update cascade,

constraint CK_libros_precio_positivo check (precio>=0)

);

Veamos las restricciones de "editoriales":

sp_helpconstraint editoriales;

Aparece la restricción "primary key" para el campo "codigo" y la restricción "foreign key" de
"libros" "FK_libros_editorial" que referencia esta tabla.

Veamos las restricciones de "autores":

sp_helpconstraint autores;

Aparecen 4 restricciones: una restricción "check" para el campo "codigo", una restricción "primary
key" para el campo "codigo", una restricción "unique" para el campo "nombre" y la restricción
"foreign key" de "libros" "FK_libros_autores" que referencia esta tabla.

Veamos las restricciones de "libros":

sp_helpconstraint libros;

Aparecen 6 restricciones: una restricción "check" sobre el campo "precio", una "default" sobre el
campo "precio", una restricción "foreign key" que establece el campo "codigoeditorial" como clave
externa que hace referencia al campo "codigo" de "editoriales" y permite actualizaciones en
cascada y no eliminaciones, una restricción "foreign key" que establece el campo "codigoautor"
como clave externa que hace referencia al campo "codigo" de "autores" y permite actualizaciones
en cascada y no eliminaciones, una restricción "primary key" con índice agrupado para el campo
"codigo" y una restricción "unique" con índice no agrupado para los campos "titulo" y
"codigoautor".

Recuerde que si definimos una restricción "foreign key" al crear una tabla, la tabla referenciada
debe existir, por ello creamos las tablas "editoriales" y "autores" antes que "libros".

También debemos ingresar registros en las tablas "autores" y "editoriales" antes que en "libros", a
menos que deshabilitemos la restricción "foreign key".

Agregar y eliminar campos ( alter table - add - drop)

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

Eliminamos la tabla, si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

titulo varchar(30),

editorial varchar(15),

edicion datetime,

precio decimal(6,2)

);

Agregamos un registro:

insert into libros (titulo,editorial,precio)

values ('El aleph','Emece',25.50);

Agregamos el campo "cantidad" a la tabla "libros", de tipo tinyint, que acepta valores nulos:

alter table libros

add cantidad tinyint;

Verificamos la estructura de la tabla empleando el procedimiento almacenado "sp_columns":

sp_columns libros;

aparece el nuevo campo.

Agregamos un campo "codigo" a la tabla "libros", de tipo int con el atributo "identity":

alter table libros

add codigo int identity;

Intentamos agregar un campo llamado "autor" de tipo varchar(30) que NO acepte valores nulos:

alter table libros

add autor varchar(30) not null;

No es posible, porque SQL Server no permite agregar campos "not null" a menos que se
especifique un valor por defecto:

alter table libros

add autor varchar(20) not null default 'Desconocido';

En el ejemplo anterior, se agregó una restricción "default" para el nuevo campo, que puede
verificarse ejecutando el procedimiento almacenado "sp_helpconstraint".

En el siguiente ejemplo eliminamos el campo "precio" de la tabla "libros":

alter table libros

drop column precio;

Verificamos la eliminación:

sp_columns libros;

el campo "precio" ya no existe.

Recuerde que no pueden eliminarse los campos con restricciones, intentémoslo:

alter table libros

drop column autor;

no lo permite.

Podemos eliminar varios campos en una sola sentencia:

alter table libros

drop column editorial,edicion;

Alterar campos (alter table - alter)

Trabajamos con la tabla "libros" de una librería.
Eliminamos la tabla, si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,

titulo varchar(30),

autor varchar(30),

editorial varchar(15),

precio decimal(6,2) not null default 0

);

Ingresamos algunos registros:

insert into libros

values('El aleph','Borges','Planeta',20);

insert into libros

values('Java en 10 minutos',null,'Siglo XXI',30);

insert into libros

values('Uno','Richard Bach','Planeta',15);

insert into libros

values('Martin Fierro','Jose Hernandez',null,30);

insert into libros

values('Aprenda PHP','Mario Molina','Emece',25);

Vamos a efectuar diferentes modificaciones a los campos de esta tabla. Luego de cada una
podemos ver la estructura de la tabla para controlar si los cambios se realizaron o no empleando
el procedimiento almacenado "sp_columns".

Modificamos el campo "titulo" para que acepte una cadena más larga y no admita valores nulos:

alter table libros

alter column titulo varchar(40) not null;

Si intentamos modificar el campo "autor" para que no admita valores nulos SQL Server no lo
permite porque hay registros con valor nulo en "autor".

Eliminamos tal registro y realizamos la modificación:

delete from libros where autor is null;

alter table libros

alter column autor varchar(30) not null;

Intentamos quitar el atributo "identity" del campo "codigo" y lo redefinimos como "smallint":

alter table libros

alter column codigo smallint;

No aparece mensaje de error pero no se realizó el cambio completo, controlémoslo:

sp_columns libros;

el campo "codigo" es "smallint pero aún es "identity".

Aprendimos que no se puede modificar el tipo de dato o atributos de un campo que tiene una
restricción si el cambio afecta a la restricción; pero si el cambio no afecta a la restricción, si se
realiza:

alter table libros

alter column precio decimal(6,2) null;

El campo "precio" fue alterado para que acepte valores nulos:

Crear tabla a partir de otra (select - into)

Tenemos la tabla "libros" de una librería y queremos crear una tabla llamada "editoriales" que
contenga los nombres de las editoriales.
Eliminamos las tablas "libros" y "editoriales" si existen:

if object_id('libros')is not null

drop table libros;

if object_id('editoriales')is not null

drop table editoriales;

Creamos la tabla "libros":

create table libros(

codigo int identity,

titulo varchar(40) not null,

 autor varchar(30),

editorial varchar(20),

precio decimal(5,2),

primary key(codigo)

);

Ingresamos algunos registros;

insert into libros values('Uno','Richard Bach','Planeta',15);

insert into libros values('El aleph','Borges','Emece',25);

insert into libros values('Matematica estas ahi','Paenza','Nuevo siglo',18);

insert into libros values('Aprenda PHP','Mario Molina','Nuevo siglo',45);

insert into libros values('Ilusiones','Richard Bach','Planeta',14);

insert into libros values('Java en 10 minutos','Mario Molina','Nuevo siglo',50);

Creamos una tabla llamada "editoriales" que contenga los nombres de las editoriales:

select distinct editorial as nombre

into editoriales

from libros;

Veamos la nueva tabla:

select *from editoriales;

Necesitamos una nueva tabla llamada "librosporeditorial" que contenga la cantidad de libros de
cada editorial. Primero eliminamos la tabla, si existe:

if object_id('cantidadporeditorial') is not null

drop table cantidadporeditorial;

Creamos la nueva tabla:

select editorial as nombre,count(*) as cantidad

into cantidadporeditorial

from libros

group by editorial;

Veamos los registros de la nueva tabla:

select *from cantidadporeditorial;

La tabla "cantidadporeditorial" se ha creado con el campo llamado "nombre" seleccionado del
campo "editorial" de "libros" y con el campo "cantidad" con el valor calculado con count(*) de la
tabla "libros".

Queremos una tabla llamada "ofertas4" que contenga los mismos campos que "libros" y guarde
los 4 libros más económicos. Primero eliminamos, si existe, la tabla "ofertas4":

if object_id('ofertas4') is not null

drop table ofertas4;

Creamos "ofertas4" e insertamos la consulta de "libros":

select top 4 *

into ofertas4

from libros

order by precio desc;

La consulta anterior retorna los 4 primeros libros de la tabla "libros", ordenados en forma
ascendente por precio y los almacena en la nueva tabla ("ofertas4"). Note que no se listan los
campos a extraer, se coloca un asterisco para indicar que se incluyen todos los campos.

Veamos los registros de la nueva tabla:

select *from ofertas4;

Agregamos una columna a la tabla "editoriales" que contiene la ciudad en la cual está la casa
central de cada editorial:

alter table editoriales add ciudad varchar(30);

Actualizamos dicho campo:

update editoriales set ciudad='Cordoba' where nombre='Planeta';

update editoriales set ciudad='Cordoba' where nombre='Emece';

update editoriales set ciudad='Buenos Aires' where nombre='Nuevo siglo';

Queremos una nueva tabla llamada "librosdecordoba" que contenga los títulos y autores de los
libros de editoriales de Cordoba. En primer lugar, la eliminamos, si existe:

if object_id('librosdecordoba') is not null

drop table librosdecordoba;

Consultamos las 2 tablas y guardamos el resultado en la nueva tabla que estamos creando:

select titulo,autor

into librosdecordoba
 from libros

join editoriales

on editorial=nombre

where ciudad='Cordoba';

Consultamos la nueva tabla:

select *from librosdecordoba;

Vistas (modificar datos de una tabla a través de vistas)

Una empresa almacena la información de sus empleados en dos tablas llamadas "empleados" y
"secciones".
Eliminamos las tablas, si existen:

if object_id('empleados') is not null

drop table empleados;

if object_id('secciones') is not null

drop table secciones;

Creamos las tablas:

create table secciones(

codigo tinyint identity,

nombre varchar(20),

sueldo decimal(5,2)

constraint CK_secciones_sueldo check (sueldo>=0),

constraint PK_secciones primary key (codigo)

);

create table empleados(

legajo int identity,

documento char(8)
 constraint CK_empleados_documento check (documento like '[0-9][0-9][0-9][0-9][0-9][0-9][0-9]
[0-9]'),

sexo char(1)

constraint CK_empleados_sexo check (sexo in ('f','m')),

apellido varchar(20),

nombre varchar(20),

domicilio varchar(30),

seccion tinyint not null,

cantidadhijos tinyint

constraint CK_empleados_hijos check (cantidadhijos>=0),

estadocivil char(10)

constraint CK_empleados_estadocivil check (estadocivil in

('casado','divorciado','soltero','viudo')),

fechaingreso datetime,

constraint PK_empleados primary key (legajo),

sueldo decimal(6,2),

constraint FK_empleados_seccion

foreign key (seccion)

references secciones(codigo)

on update cascade,

constraint UQ_empleados_documento

unique(documento)

);

Ingresamos algunos registros:

insert into secciones values('Administracion',300);

insert into secciones values('Contaduría',400);

insert into secciones values('Sistemas',500);

insert into empleados values('22222222','f','Lopez','Ana','Colon 123',1,2,'casado','1990-10-

10',600);
insert into empleados values('23333333','m','Lopez','Luis','Sucre 235',1,0,'soltero','1990-02-
10',650);

insert into empleados values('24444444', 'm', 'Garcia', 'Marcos', 'Sarmiento 1234', 2, 3,

'divorciado', '1998-07-12',800);

insert into empleados values('25555555','m','Gomez','Pablo','Bulnes 321',3,2,'casado','1998-10-

09',900);

insert into empleados values('26666666','f','Perez','Laura','Peru 1254',3,3,'casado','2000-05-

09',700);

Eliminamos la vista "vista_empleados" si existe:

if object_id('vista_empleados') is not null

drop view vista_empleados;

Creamos la vista "vista_empleados", que es resultado de una combinación en la cual se muestran

5 campos:

create view vista_empleados as

select (apellido+' '+[Link]) as nombre,sexo,

[Link] as seccion, cantidadhijos

from empleados as e

join secciones as s

on codigo=seccion;

Vemos la información contenida en la vista:

select *from vista_empleados;

Eliminamos la vista "vista_empleados2" si existe:

if object_id('vista_empleados2') is not null

drop view vista_empleados2;

Creamos otra vista de "empleados" denominada "vista_empleados2" que consulta solamente la

tabla "empleados" con "with check option":

create view vista_empleados2

as

select nombre, apellido,fechaingreso,seccion,estadocivil,sueldo

from empleados
 where sueldo>=600

with check option;

Consultamos la vista:

select *from vista_empleados2;

Ingresamos un registro en la vista "vista_empleados2":

insert into vista_empleados2 values('Pedro','Perez','2000-10-10',1,'casado',800);

No es posible insertar un registro en la vista "vista_empleados" porque el campo de la vista

"nombre" es un campo calculado.

Actualizamos la sección de un registro de la vista "vista_empleados":

update vista_empleados set seccion='Sistemas' where nombre='Lopez Ana';

Si intentamos actualizar el nombre de un empleado no lo permite porque es una columna

calculada.

Actualizamos el nombre de un registro de la vista "vista_empleados2":

update vista_empleados2 set nombre='Beatriz' where nombre='Ana';

Verifique que se actualizó la tabla:

select *from empleados;

Eliminamos un registro de la vista "vista_empleados2":

delete from vista_empleados2 where apellido='Lopez';

Si podemos eliminar registros de la vista "vista_empleados2" dicha vista solamente consulta una
tabla. No podemos eliminar registros de la vista "vista_empleados" porque hay varias tablas en su
definición.

Lenguaje de control de flujo (case)

Un profesor guarda las notas de sus alumnos de un curso en una tabla llamada "alumnos" que
consta de los siguientes campos:

- nombre (30 caracteres),

- nota (valor entero entre 0 y 10, puede ser nulo),

Eliminamos la tabla si existe y la creamos nuevamente:

if object_id('alumnos') is not null

 drop table alumnos;

create table alumnos(

nombre varchar(40),

nota tinyint,

constraint CK_alunos_nota check (nota>=0 and nota<=10)

);

Ingresamos algunos registros:

insert into alumnos values('Ana Acosta',8);

insert into alumnos values('Carlos Caseres',4);

insert into alumnos values('Federico Fuentes',2);

insert into alumnos values('Gaston Guzman',3);

insert into alumnos values('Hector Herrero',5);

insert into alumnos values('Luis Luna',10);

insert into alumnos values('Marcela Morales',7);

insert into alumnos values('Marcela Morales',null);

Queremos mostrar el nombre y nota de cada alumno y en una columna extra llamada "condicion"
empleamos un case que testee la nota y muestre un mensaje diferente si en dicho campo hay un
valor:

- 0, 1, 2 ó 3: 'libre';

- 4, 5 ó 6: 'regular';

- 7, 8, 9 ó 10: 'promocionado';

Esta es la sentencia:

select nombre,nota, condicion=

case nota

when 0 then 'libre'

when 1 then 'libre'

when 2 then 'libre'

when 3 then 'libre'

when 4 then 'regular'

 when 5 then 'regular'

when 6 then 'regular'

when 7 then 'promocionado'

when 8 then 'promocionado'

when 9 then 'promocionado'

when 10 then 'promocionado'

end

from alumnos;

Obtenemos la misma salida pero empleando el "case" con operadores de comparación:

select nombre, nota, condicion=

case

when nota<4 then 'libre'

when nota >=4 and nota<7 then 'regular'

when nota>=7 then 'promocionado'

else 'sin nota'

end

from alumnos;

Vamos a agregar el campo "condicion" a la tabla:

alter table alumnos

add condicion varchar(20);

Veamos la tabla:

select *from alumnos;

Recordemos que se puede emplear una expresión "case" en cualquier lugar en el que pueda
utilizar una expresión. Queremos actualizar el campo "condicion" para guardar la condición de
cada alumno según su nota:

update alumnos set condicion=

case

when nota<4 then 'libre'

when nota between 4 and 7 then 'regular'

when nota >7 then 'promocionado'

 end;

Veamos la tabla actualizada:

select *from alumnos;

Note que el alumno sin nota contiene "null" en "condición" porque no especificamos valor para
"else".

Mostramos la cantidad de alumnos libres, regulares y aprobados y en una columna extra

mostramos un mensaje, ordenamos por cantidad:

select condicion, count(*) as cantidad,resultado=

case condicion

when 'libre' then 'repitentes'

when 'regular' then 'rinden final'

when 'promocionado' then 'no rinden final'

else 'sin datos'

end

from alumnos

group by condicion

order by cantidad;

Lenguaje de control de flujo (if)

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

Eliminamos la tabla si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,

titulo varchar(40) not null,

autor varchar(30),
 editorial varchar(20),

precio decimal(5,2),

cantidad tinyint,

primary key (codigo)

);

Ingresamos los siguientes registros:

insert into libros values('Uno','Richard Bach','Planeta',15,100);

insert into libros values('El aleph','Borges','Emece',20,150);

insert into libros values('Aprenda PHP','Mario Molina','Nuevo siglo',50,200);

insert into libros values('Alicia en el pais de las maravillas','Lewis Carroll','Emece',15,0);

insert into libros values('Java en 10 minutos','Mario Molina','Emece',40,200);

Mostramos los títulos de los cuales no hay libros disponibles (cantidad=0); en caso que no haya,
mostramos un mensaje:

if exists (select *from libros where cantidad=0)

(select titulo from libros where cantidad=0)

else

select 'No hay libros sin stock';

Hacemos un descuento del 10% a todos los libros de editorial "Emece"; si no hay, mostramos un
mensaje:

if exists (select *from libros where editorial='Emece')

begin

update libros set precio=precio-(precio*0.1) where editorial='Emece'

select 'libros actualizados'

end

else

select 'no hay registros actualizados';

Veamos si se actualizaron:

select *from libros where editorial='Emece';

Eliminamos los libros de los cuales no hay stock (cantidad=0); si no hay, mostramos un mensaje:

if exists (select *from libros where cantidad=0)

 delete from libros where cantidad=0

else

select 'No hay registros eliminados';

Se eliminó un registro, se ejecutó la sentencia del "if" porque había registros que cumplían la
condición.

Ejecutamos nuevamente la sentencia anterior:

if exists (select *from libros where cantidad=0)

delete from libros where cantidad=0

else

select 'No hay registros eliminados';

Ahora se ejecutó la sentencia del "else" porque no había registros que cumplieran la condición.

Variables de usuario

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

Eliminamos la tabla si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

titulo varchar(30),

autor varchar(25),

editorial varchar(20),

precio decimal(5,2)

);

Ingresamos algunos registros:

insert into libros values('Uno','Bach Richard','Planeta',15);

insert into libros values('El aleph','Borges J. L.','Emece',25);

insert into libros values('Matematica estas ahi','Paenza Adrian','Siglo XXI',15);

insert into libros values('Aprenda PHP','Mario Molina','Siglo XXI',35);

insert into libros values('Java en 10 minutos','Mario Molina','Siglo XXI',35);

Declare una variable llamada "@valor" de tipo "int" y vea su contenido:

declare @valor int

select @valor;

Declare una variable llamada "@nombre" de tipo "varchar(20)", asígnele un valor y vea su
contenido:

declare @nombre varchar(20)

set @nombre='Juan'

select @nombre;

Queremos saber todos los datos de los libros con mayor precio de la tabla "libros". Declare una
variable de tipo decimal, busque el precio más alto de "libros" y almacénelo en una variable, luego
utilice dicha variable para mostrar todos los datos del libro:

declare @mayorprecio decimal(5,2)

select @mayorprecio=max(precio) from libros

select *from libros where precio=@mayorprecio;

Procedimientos almacenados (return)

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

Eliminamos la tabla si existe y la creamos nuevamente:

if object_id('libros') is not null

drop table libros;

create table libros(

codigo int identity,

titulo varchar(40),

autor varchar(30),

editorial varchar(20),

precio decimal(5,2),

primary key(codigo)

);
Ingresamos algunos registros:

insert into libros values ('Uno','Richard Bach','Planeta',15);

insert into libros values ('Ilusiones','Richard Bach','Planeta',12);

insert into libros values ('El aleph','Borges','Emece',25);

insert into libros values ('Aprenda PHP','Mario Molina','Nuevo siglo',50);

insert into libros values ('Matematica 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 el procedimiento llamado "pa_libros_autor", si existe:

if object_id('pa_libros_autor') is not null

drop procedure pa_libros_autor;

Creamos un procedimiento que muestre todos los libros de un autor determinado que se ingresa
como parámetro. Si no se ingresa un valor, o se ingresa "null", se muestra un mensaje y se sale del
procedimiento:

create procedure pa_libros_autor

@autor varchar(30)=null

as

if @autor is null

begin

select 'Debe indicar un autor'

return

end

select titulo from libros where autor = @autor;

Ejecutamos el procedimiento con parámetro:

exec pa_libros_autor 'Borges';

Ejecutamos el procedimiento sin parámetro:

exec pa_libros_autor;

Eliminamos el procedimiento "pa_libros_ingreso", si existe:

if object_id('pa_libros_ingreso') is not null

drop procedure pa_libros_ingreso;

Creamos un procedimiento almacenado que ingresa registros en la tabla "libros". Los parámetros
correspondientes al título y autor DEBEN ingresarse con un valor distinto de "null", los demás son
opcionales. El procedimiento retorna "1" si la inserción se realiza (si se ingresan valores para título
y autor) y "0", en caso que título o autor sean nulos:

create procedure pa_libros_ingreso

@titulo varchar(40)=null,

@autor varchar(30)=null,

@editorial varchar(20)=null,

@precio decimal(5,2)=null

as

if (@titulo is null) or (@autor is null)

return 0

else

begin

insert into libros values (@titulo,@autor,@editorial,@precio)

return 1

end;

Declaramos una variable en la cual almacenaremos el valor devuelto, ejecutamos el procedimiento

enviando los dos parámetros obligatorios y vemos el contenido de la variable:

declare @retorno int

exec @retorno=pa_libros_ingreso 'Alicia en el pais...','Lewis Carroll'

select 'Ingreso realizado=1' = @retorno;

El procedimiento retornó "1", lo cual indica que el registro fue ingresado.

Verifiquemos el ingreso consultando la tabla:

select *from libros;

Ejecutamos los mismos pasos, pero esta vez no enviamos valores al procedimiento:

declare @retorno int

exec @retorno=pa_libros_ingreso
select 'Ingreso realizado=1' = @retorno;

El procedimiento retornó "0", lo cual indica que el registro no fue ingresado.

Verifiquemos que el ingreso no se realizó consultando la tabla:

select *from libros;

Empleamos un "if" para controlar el valor de la variable de retorno. Enviando al procedimiento

valores para los parámetros obligatorios:

declare @retorno int

exec @retorno=pa_libros_ingreso 'El gato con botas','Anónimo'

if @retorno=1 select 'Registro ingresado'

else select 'Registro no ingresado porque faltan datos';

Verifiquemos el ingreso consultando la tabla:

select *from libros;

Empleamos nuevamente un "if" y no enviamos valores al procedimiento:

declare @retorno int

exec @retorno=pa_libros_ingreso

if @retorno=1 select 'Registro ingresado'

else select 'Registro no ingresado porque faltan datos';

Verifiquemos que el ingreso no se realizó:

select *from libros;

Procedimientos almacenados (parámetros de salida)

Eliminamos el procedimiento almacenado "pa_promedio", si existe:

if object_id('pa_promedio') is not null

drop proc pa_promedio;

Creamos un procedimiento almacenado al cual le enviamos 2 números decimales 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;

Lo ejecutamos enviando diferentes valores:

declare @variable decimal(4,2)

execute pa_promedio 5,6, @variable output

select @variable

execute pa_promedio 5.3,4.7, @variable output

select @variable

execute pa_promedio 9,10, @variable output

select @variable;

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

Eliminamos la tabla si existe y la creamos nuevamente:

if object_id('libros') is not null

drop table libros;

create table libros(

codigo int identity,

titulo varchar(40),

autor varchar(30),

editorial varchar(20),

precio decimal(5,2),

primary key(codigo)

);

Ingresamos algunos registros:

insert into libros values ('Uno','Richard Bach','Planeta',15);

insert into libros values ('Ilusiones','Richard Bach','Planeta',12);

insert into libros values ('El aleph','Borges','Emece',25);

insert into libros values ('Aprenda PHP','Mario Molina','Nuevo siglo',50);

insert into libros values ('Matematica 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 el procedimiento almacenado "pa_autor_sumaypromedio", si existe:

if object_id('pa_autor_sumaypromedio') is not null

drop proc pa_autor_sumaypromedio;

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 enviando distintos valores:

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

execute pa_autor_sumaypromedio 'Borges', @s output, @p output

select @s as total, @p as promedio

execute pa_autor_sumaypromedio 'Mario Molina', @s output, @p output

select @s as total, @p as promedio

Ejecutamos el procedimiento sin pasar el parámetro para autor. Recuerde que en estos casos
debemos colocar los nombres de las variables.

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

execute pa_autor_sumaypromedio @suma=@s output,@promedio= @p output

select @s as total, @p as promedio;

Procedimientos almacenados (parámetros de entrada)

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

Eliminamos la tabla si existe y la creamos nuevamente:

if object_id('libros') is not null

drop table libros;

create table libros(

codigo int identity,

titulo varchar(40),

autor varchar(30),

editorial varchar(20),

precio decimal(5,2),

primary key(codigo)

);

Ingresamos algunos registros:

insert into libros values ('Uno','Richard Bach','Planeta',15);

insert into libros values ('Ilusiones','Richard Bach','Planeta',12);

insert into libros values ('El aleph','Borges','Emece',25);

insert into libros values ('Aprenda PHP','Mario Molina','Nuevo siglo',50);

insert into libros values ('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%';

Procedimientos almacenados (encriptado)

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

Eliminamos la tabla si existe y la creamos nuevamente:

if object_id('libros') is not null

drop table libros;

create table libros(

codigo int identity,

titulo varchar(40),

autor varchar(30),

editorial varchar(20),

precio decimal(5,2),

primary key(codigo)

);

Eliminamos el procedimiento llamado "pa_libros_autor", si existe:

if object_id('pa_libros_autor') is not null

drop procedure pa_libros_autor;

Creamos el procedimiento almacenado "pa_libros_autor" con la opción de encriptado:

create procedure pa_libros_autor

@autor varchar(30)=null

with encryption

as

select *from libros

where autor=@autor;

Ejecutamos el procedimiento almacenado del sistema "sp_helptext" para ver su contenido:

sp_help pa_libros_autor;

no aparece.