SQL Server Tutorial

Orden
del
concept
o
Concepto
Objetivos y alcances del tutorial

de Microsoft Sql Server
Crear una tabla (create table sp_tables - sp_columns - drop

table)
Insertar y recuperar registros

de una tabla (insert into select)
Tipos de datos bsicos
Recuperar algunos campos

(select)
Recuperar algunos registros

(where)
Operadores relacionales
Borrar registros (delete)
Actualizar registros (update)
10
Comentarios
11
Valores null (is null)
12
Clave primaria
13
Campo con atributo Identity
14
Otras caractersticas del

atributo Identity
15
Truncate table
16
Otros tipos de datos en SQL

Server
17
Tipo de dato (texto)
18
Tipo de dato (numrico)
19
Tipo de dato (fecha y hora)
20
Ingresar algunos campos

(insert into)
21
Valores por defecto (default)
22
Columnas calculadas
(operadores aritmticos y de
concatenacin)
23
Alias
Detalle
Problem
Problema
del
a
concept
a
resuelto
o
resolver
24
Funciones
25
Funciones para el manejo de

cadenas
Orden
del
concept
o
Concepto
26
Funciones matemticas
27
Funciones para el uso de fechas

y horas
28
Ordenar registros (order by)
29
Operadores lgicos ( and - or not)
30
Otros operadores relacionales

(is null)
31

(between)
32

(in)
33
Bsqueda de patrones (like not like)
34
Contar registros (count)
35
Contar registros (count_big)
36
Funciones de agrupamiento
(count - sum - min - max avg)
37
Agrupar registros (group by)
38
Seleccionar grupos (having)
39
Modificador del group by (with

rollup)
40
Modificador del group by (with

cube)
41
Funcin grouping
42
Clusulas compute y compute

by
43
Registros duplicados (distinct)
44
Clusula top
45
Clave primaria compuesta
46
Integridad de los datos
Detalle
Problem
Problema
del
a
concept
a
resuelto
o
resolver
47
Restriccin default
48
Restriccin check
49
Deshabilitar restricciones (with

check - nocheck)
50
Restriccin primary key
Orden
del
concept
o
Concepto
51
Restriccin unique
52
Informacin de restricciones
(sp_helpconstraint)
53
Eliminar restricciones (alter

table - drop)
54
Crear y asociar reglas (create

rule - sp_bindrule)
55
Eliminar y dasasociar reglas

(sp_unbindrule - drop rule)
56
Informacin de reglas (sp_help

- sp_helpconstraint)
57
Valores predeterminados
(create default)
58
Desasociar y eliminar valores

predeterminados
59
Informacin de valores
predeterminados
60
Indices
61
Indices agrupados y no
agrupados (clustered y
nonclustered)
62
Creacin de ndices
63
Regenerar ndices
64
Eliminar ndices
65
Trabajar con varias tablas
66
Combinacin interna (inner

join)
67
Combinacin externa izquierda

(left join)
68
Combinacin externa derecha

(right join)
Detalle
Problem
Problema
del
a
concept
a
resuelto
o
resolver
69
Combinacin externa completa

(full join)
70
Combinaciones cruzadas (cross

join)
71
Autocombinacin
72
Combinaciones y funciones de
agrupamiento
73
Combinacin de ms de dos
tablas
74
Combinaciones con update y

delete
75
Clave fornea
Orden
del
Concepto
concepto
76
Restricciones (foreign key)
77
Restricciones foreign key en la

misma tabla
78
Restricciones foreign key

(acciones)
79

deshabilitar y eliminar (with
check - nocheck)
80

(informacin)
81
Restricciones al crear la tabla
82
Unin
83
Agregar y eliminar campos

( alter table - add - drop)
84
Alterar campos (alter table alter)
85
Agregar campos y restricciones

(alter table)
86
Campos calculados
87
Tipo de dato definido por el

usuario (crear - informacion)
88

usuario (asociacin de reglas)
89

usuario (valores
predeterminados)
90

usuario (eliminar)
Detalle
del
concepto
Problema
resuelto
Problema
a
resolver
91
Subconsultas
92
Subconsultas como expresin
93
Subconsultas con in
94
Subconsultas any - some - all
95
Subconsultas correlacionadas
96
Exists y No Exists
97
Subconsulta simil
autocombinacin
98
Subconsulta en lugar de una

tabla
99
Subconsulta (update - delete)
100
Subconsulta (insert)
Orden
del
concept
o
Concepto
101
Crear tabla a partir de otra

(select - into)
102
go
103
Vistas
104
Vistas (informacin)
105
vistas (encriptar)
106
Vistas (eliminar)
107
Vistas (with check option)
108
Vistas (modificar datos de una

tabla a travs de vistas)
109
Vistas modificar (alter view)
110
Lenguaje de control de flujo

(case)
111
Lenguaje de control de flujo (if)
112
Variables de usuario
113
Tipos de datos text, ntext y

image
114
Tipo de dato text - ntext e

image (punteros)
Detalle
Problem
Problema
del
a
concept
a
resuelto
o
resolver
115

image (leer)
116

image (escribir)
117

image (actualizar)
118

image (funciones)
119
Procedimientos almacenados
120
(crear - ejecutar)
121
(eliminar)
122
(parmetros de entrada)
123
(parmetros de salida)
124
(return)
125
(informacin)
Orden
del
concept
o
Concepto
101
Crear tabla a partir de otra

(select - into)
102
go
103
Vistas
104
Vistas (informacin)
105
vistas (encriptar)
106
Vistas (eliminar)
107
Vistas (with check option)
108
Vistas (modificar datos de una

tabla a travs de vistas)
109
Vistas modificar (alter view)
110
Lenguaje de control de flujo

(case)
111
Lenguaje de control de flujo (if)
Detalle
Problem
Problema
del
a
concept
a
resuelto
o
resolver
112
Variables de usuario
113
Tipos de datos text, ntext y

image
114

image (punteros)
115

image (leer)
116

image (escribir)
117

image (actualizar)
118

image (funciones)
119
120
(crear - ejecutar)
121
(eliminar)
122
(parmetros de entrada)
123
(parmetros de salida)
124
(return)
125
(informacin)
Orden
del
concepto
Concepto
151
Disparador (with encryption)
152
Disparador (condicionales)
Detalle
Problema
Problema
del
a
resuelto
concepto
resolver
El curso brinda un concepto terico corto, luego un problema resuelto

que invito a ejecutar, modificar y jugar con el mismo. Por ltimo, y lo ms
importante, una serie de ejercicios propuestos que nos permitir saber si
podemos aplicar el concepto.
La nica herramienta que necesitamos inicialmente es este sitio ya que
podr ejecutar todos los problemas como son la creacin de tablas,
insert, delete, update, definicin de ndices y restricciones, creacin y
ejecucin de procedimientos almacenados, vistas, subconsultas,
creacin de trigger etc.
La nica restriccin es que todos los visitantes de este sitio comparten la

misma base de datos llamada: wi520641_sqlserverya (este nombre un
poco singular se debe a que las empresas de hosting es la que lo define)
Siempre que lancemos un comando SQL en el sitio
www.sqlserverya.com.ar estaremos accediendo a la base de datos
wi520641_sqlserverya.
2 - Crear una tabla (create table - sp_tables - sp_columns - drop

table)
Una base de datos almacena su informacin en tablas.
Una tabla es una estructura de datos que organiza los datos en columnas
y filas; cada columna es un campo (o atributo) y cada fila, un registro. La
interseccin de una columna con una fila, contiene un dato especfico, un
solo valor.
Cada registro contiene un dato por cada columna de la tabla.
Cada campo (columna) debe tener un nombre. El nombre del campo
hace referencia a la informacin que almacenar.
Cada campo (columna) tambin debe definir el tipo de dato que
almacenar.
Las tablas forman parte de una base de datos.
Nosotros trabajaremos con la base de datos llamada
wi520641_sqlserverya (este nombre se debe a que las empresas de
hosting es la que lo define), que ya he creado en el servidor
sqlserverya.com.ar.
Para ver las tablas existentes creadas por los usuarios en una base de
datos usamos el procedimiento almacenado "sp_tables
@table_owner='dbo';":
sp_tables @table_owner='dbo';
El parmetro @table_owner='dbo' indica que solo muestre las tablas de

usuarios y no las que crea el SQL Server para administracin interna.
Finalizamos cada comando con un punto y coma.
Al crear una tabla debemos resolver qu campos (columnas) tendr y
que tipo de datos almacenarn cada uno de ellos, es decir, su estructura.
La sintaxis bsica y general para crear una tabla es la siguiente:
create table NOMBRETABLA(

NOMBRECAMPO1 TIPODEDATO,
...
NOMBRECAMPON TIPODEDATO
);
La tabla debe ser definida con un nombre que la identifique y con el cual
accederemos a ella.
Creamos una tabla llamada "usuarios" y entre parntesis definimos los
campos y sus tipos:
create table usuarios (
nombre varchar(30),
clave varchar(10)
);
Cada campo con su tipo debe separarse con comas de los siguientes,
excepto el ltimo.
Cuando se crea una tabla debemos indicar su nombre y definir al menos
un campo con su tipo de dato. En esta tabla "usuarios" definimos 2
campos:
nombre: que contendr una cadena de caracteres de 30 caracteres
de longitud, que almacenar el nombre de usuario y
clave: otra cadena de caracteres de 10 de longitud, que guardar
la clave de cada usuario.
Cada usuario ocupar un registro de esta tabla, con su respectivo
nombre y clave.
Para nombres de tablas, se puede utilizar cualquier caracter permitido
para nombres de directorios, el primero debe ser un caracter alfabtico y
no puede contener espacios. La longitud mxima es de 128 caracteres.
Si intentamos crear una tabla con un nombre ya existente (existe otra
tabla con ese nombre), mostrar un mensaje indicando que ya hay un
objeto llamado 'usuarios' en la base de datos y la sentencia no se
ejecutar. Esto es muy importante ya que cuando haga los ejercicios en
este sitio puede haber otra persona que haya creado una tabla con el
nombre que usted especifique.
Para ver la estructura de una tabla usamos el procedimiento almacenado
"sp_columns" junto al nombre de la tabla:
sp_columns usuarios;
aparece mucha informacin que no analizaremos en detalle, como el

nombre de la tabla, su propietario, los campos, el tipo de dato de cada
campo, su longitud, etc.:
...COLUMN_NAME TYPE_NAME
LENGHT
_______________________________________
nombre
varchar
30
clave
varchar
10
Para eliminar una tabla usamos "drop table" junto al nombre de la tabla a
eliminar:
drop table usuarios;
Si intentamos eliminar una tabla que no existe, aparece un mensaje de

error indicando tal situacin y la sentencia no se ejecuta. Para evitar este
mensaje podemos agregar a la instruccin lo siguiente:
if object_id('usuarios') is not null
En la sentencia precedente especificamos que elimine la tabla "usuarios"

si existe.
Problema:
Vamos a crear una tabla llamada "usuarios". En primer lugar
vamos a eliminar la tabla "usuarios" averiguando si existe (a
esto vamos a repetirlo siempre porque puede haber otro
usuario que haya creado una tabla con el mismo nombre):
Recordar que debemos finalizar cada comando con un punto y

coma.
La tabla "usuarios" contendr los siguientes campos:
- nombre: varchar de 30 caracteres de longitud,
- clave: varchar de 10 caracteres de longitud.
Ahora si creamos la tabla:

nombre varchar(30),
clave varchar(10)
);
aparece un mensaje indicando que el comando se complet

exitosamente.
Veamos las tablas existentes:
Veamos la estructura de la tabla "usuarios":

aparece mucha informacin que no analizaremos en detalle,

como el nombre de la tabla, su propietario, los campos y sus
tipos de datos, su longitud, etc.:
LENGHT...
_______________________________________
nombre
varchar
30
clave
varchar
10
Intentemos crear una tabla con el mismo nombre, mostrar un

mensaje indicando que ya hay un objeto llamado 'usuarios' en
la base de datos y la sentencia no se ejecutar:
nombre varchar(30),
clave varchar(10)
);
Eliminemos la tabla:
Verifiquemos si se ha eliminado:
no debe aparecer la tabla "usuarios".


nombre varchar(30),
clave varchar(10)
);

nombre varchar(30),
clave varchar(10)
);
3 - Insertar y recuperar registros de una tabla (insert into

- select)
Un registro es una fila de la tabla que contiene los datos propiamente

dichos. Cada registro tiene un dato por cada columna (campo). Nuestra
tabla "usuarios" consta de 2 campos, "nombre" y "clave".
Al ingresar los datos de cada registro debe tenerse en cuenta la cantidad
y el orden de los campos.
La sintaxis bsica y general es la siguiente:
insert into NOMBRETABLA (NOMBRECAMPO1, ..., NOMBRECAMPOn)
values (VALORCAMPO1, ..., VALORCAMPOn);
Usamos "insert into", luego el nombre de la tabla, detallamos los

nombres de los campos entre parntesis y separados por comas y luego
de la clusula "values" colocamos los valores para cada campo, tambin
entre parntesis y separados por comas.
Para agregar un registro a la tabla tipeamos:
insert into usuarios (nombre, clave) values ('Mariano','payaso');
Note que los datos ingresados, como corresponden a cadenas de

caracteres se colocan entre comillas simples.
Para ver los registros de una tabla usamos "select":
select * from usuarios;
El comando "select" recupera los registros de una tabla.

Con el asterisco indicamos que muestre todos los campos de la tabla
"usuarios".
Es importante ingresar los valores en el mismo orden en que se nombran
los campos:
insert into usuarios (clave, nombre) values ('River','Juan');
En el ejemplo anterior se nombra primero el campo "clave" y luego el

campo "nombre" por eso, los valores tambin se colocan en ese orden.
Si ingresamos los datos en un orden distinto al orden en que se
nombraron los campos, no aparece un mensaje de error y los datos se
guardan de modo incorrecto.
En el siguiente ejemplo se colocan los valores en distinto orden en que
se nombran los campos, el valor de la clave (la cadena "Boca") se
guardar en el campo "nombre" y el valor del nombre (la cadena "Luis")
en el campo "clave":
insert into usuarios (nombre,clave) values ('Boca','Luis');
Problema:
Vamos a crear una tabla llamada "usuarios". En primer lugar
vamos a eliminar la tabla "usuarios" averiguando si existe
(recuerde que debemos repetir siempre esto porque puede
haber otro usuario que haya creado una tabla con el mismo
nombre en el servidor www.sqlserverya.com.ar:
Recordar que debemos finalizar cada comando con un punto y

coma.
Creamos la tabla:
create table usuarios(
nombre varchar(30),
clave varchar(10)
);
Agregamos un registro a la tabla:

insert into usuarios (nombre, clave)
values ('Mariano','payaso');
Veamos si el registro se guard:

Ingresemos otro registro alterando el orden de los campos:

insert into usuarios (clave, nombre)
values ('River','Juan');
Veamos cmo SQL Server almacen los datos:

Ingresemos otro registro colocando los valores en distinto

orden en que se nombran los campos:
insert into usuarios (nombre,clave)
values ('Boca','Luis');
Veamos cmo se guardaron los datos:

Note que la cadena "Boca" se almacen en el campo "nombre"

y la cadena "Luis" en el campo "clave".

nombre varchar(30),
clave varchar(10)
);
insert into usuarios (nombre, clave) values ('Mariano','payaso');
insert into usuarios (clave, nombre) values ('River','Juan');
insert into usuarios (nombre,clave) values ('Boca','Luis');
Primer problema:
Necesita almacenar los datos de sus amigos en una
tabla. Los datos que guardar sern: apellido,
nombre, domicilio y telfono.
1- Elimine la tabla "agenda" si existe:
if object_id('agenda') is not null
drop table agenda;
2- Intente crear una tabla llamada "/agenda":
create table /agenda(
apellido varchar(30),
nombre varchar(20),
domicilio varchar(30),
telefono varchar(11)
);
aparece un mensaje de error porque usamos un
caracter invlido ("/") para el nombre.
3- Cree una tabla llamada "agenda", debe tener los
siguientes campos: apellido, varchar(30); nombre,
varchar(20); domicilio, varchar (30) y telefono,
varchar(11):
create table agenda(
nombre varchar(20),
);
4- Intente crearla nuevamente. Aparece mensaje de
error.
5- Visualice las tablas existentes (sp_tables
@table_owner='dbo').
6- Visualice la estructura de la tabla "agenda"
(sp_columns).
7- Elimine la tabla.
8- Intente eliminar la tabla, sin controlar si existe. Debe
aparecer un mensaje de error.
Ver solucin
drop table agenda;
create table /agenda(
nombre varchar(20),
);
nombre varchar(20),
);
nombre varchar(20),
);
sp_columns agenda;
drop table agenda;
drop table agenda;
Segundo problema:
Necesita almacenar informacin referente a los libros
de su biblioteca personal. Los datos que
guardar sern: ttulo del libro, nombre del autor y
nombre de la editorial.
1- Elimine la tabla "libros", si existe:
if object_id('libros') is not null
drop table libros;
2- Verifique que la tabla "libros" no existe en la base de
datos activa (sp_tables @table_owner='dbo').
3- Cree una tabla llamada "libros". Debe definirse con
los siguientes campos: titulo, varchar(20);
autor, varchar(30) y editorial, varchar(15).
4- Intente crearla nuevamente. Aparece mensaje de
error.
5- Visualice las tablas existentes.
6- Visualice la estructura de la tabla "libros".
7- Elimine la tabla.
8- Intente eliminar la tabla nuevamente.
drop table libros;
create table libros(
titulo varchar(20),
autor varchar(30),
editorial varchar(15)
);
titulo varchar(20),
autor varchar(30),
);
sp_columns libros;
drop table libros;
drop table libros;
4 - Tipos de datos bsicos

Ya explicamos que al crear una tabla debemos resolver qu campos
(columnas) tendr y que tipo de datos almacenar cada uno de ellos, es
decir, su estructura.
El tipo de dato especifica el tipo de informacin que puede guardar un

campo: caracteres, nmeros, etc.
Estos son algunos tipos de datos bsicos de SQL Server (posteriormente
veremos otros):
varchar: se usa para almacenar cadenas de caracteres. Una
cadena es una secuencia de caracteres. Se coloca entre comillas
(simples); ejemplo: 'Hola', 'Juan Perez'. El tipo "varchar" define una
cadena de longitud variable en la cual determinamos el mximo de
caracteres entre parntesis. Puede guardar hasta 8000 caracteres.
Por ejemplo, para almacenar cadenas de hasta 30 caracteres,
definimos un campo de tipo varchar(30), es decir, entre parntesis,
junto al nombre del campo colocamos la longitud.
Si asignamos una cadena de caracteres de mayor longitud que la
definida, la cadena no se carga, aparece un mensaje indicando tal
situacin y la sentencia no se ejecuta.
Por ejemplo, si definimos un campo de tipo varchar(10) e
intentamos asignarle la cadena 'Buenas tardes', aparece un
mensaje de error y la sentencia no se ejecuta.
integer: se usa para guardar valores numricos enteros, de
-2000000000 a 2000000000 aprox. Definimos campos de este tipo
cuando queremos representar, por ejemplo, cantidades.
float: se usa para almacenar valores numricos con decimales. Se
utiliza como separador el punto (.). Definimos campos de este tipo
para precios, por ejemplo.
Antes de crear una tabla debemos pensar en sus campos y optar por el
tipo de dato adecuado para cada uno de ellos.
Por ejemplo, si en un campo almacenaremos nmeros enteros, el tipo
"float" sera una mala eleccin; si vamos a guardar precios, el tipo "float"
es ms adecuado, no as "integer" que no tiene decimales. Otro ejemplo,
si en un campo vamos a guardar un nmero telefnico o un nmero de
documento, usamos "varchar", no "integer" porque si bien son dgitos,
con ellos no realizamos operaciones matemticas.
Problema:
Vamos a crear una tabla llamada "libros". En primer lugar
vamos a eliminar la tabla "libros" averiguando si existe:
drop table libros;
Para almacenar informacin de los libros de una librera

necesitamos los siguientes campos:
-titulo, cadena de caracteres de 20 de longitud,
-autor, cadena de caracteres de 15 de longitud,
-editorial, caracteres de 10 de longitud,
-precio, valor numrico con decimales y
-cantidad, valor numrico entero.
Al crear la tabla, entonces, elegimos el tipo de dato ms

adecuado para cada campo:
titulo varchar(20),
autor varchar(15),
editorial varchar(10),
precio float,
cantidad integer
);
Note que al especificar el tipo de dato de los campos

numricos, no colocamos entre parntesis la longitud.
Vemos la estructura de la tabla:
sp_columns libros;
Aparece la siguiente informacin:

LENGHT
_______________________________________
titulo
varchar
20
autor
varchar
15
editorial
varchar
10
precio
float
8
cantidad
int
4
Ingresamos algunos registros:

insert into libros (titulo,autor,editorial,precio,cantidad)
values ('El aleph','Borges','Emece',25.50,100);
values ('Matematica estas ahi','Paenza','Siglo XXI',18.8,200);
Note que al ingresar valores numricos (float e integer) no se

utilizan comillas y para el separador de decimales se usa el
caracter punto(.).
Veamos los registros cargados:
select * from libros;
Veamos lo que sucede si intentamos ingresar para el campo

"titulo" una cadena de ms de 20 caracteres:
values ('Alicia en el pais de las maravillas','Lewis
Carroll','Atlantida',10,200);
aparece un mensaje de error y la sentencia no se ejecuta.

vamos a cortar la cadena para que SQL Server acepte el
ingreso del registro:
values ('Alicia en el pais','Lewis Carroll','Atlantida',10,200);
Veamos los registros cargados:


drop table libros;

titulo varchar(20),
autor varchar(15),
precio float,
cantidad integer
);
sp_columns libros;



values ('Alicia en el pais','Lewis Carroll','Atlantida',10,200);
Primer problema:
Un videoclub que alquila pelculas en video almacena la
informacin de sus pelculas en una tabla
llamada "peliculas"; para cada pelcula necesita los
siguientes datos:
-nombre, cadena de caracteres de 20 de longitud,
-actor, cadena de caracteres de 20 de longitud,
-duracin, valor numrico entero.
-cantidad de copias: valor entero.
1- Elimine la tabla, si existe:
if object_id('peliculas')is not null
drop table peliculas;
2- Cree la tabla eligiendo el tipo de dato adecuado para
cada campo:
create table peliculas(
nombre varchar(20),
actor varchar(20),
duracion integer,
cantidad integer
);
3- Vea la estructura de la tabla:
4- Ingrese los siguientes registros:
insert into peliculas (nombre, actor, duracion,

cantidad)
values ('Mision imposible','Tom Cruise',128,3);
cantidad)
values ('Mision imposible 2','Tom Cruise',130,2);
cantidad)
values ('Mujer bonita','Julia Roberts',118,3);
cantidad)
values ('Elsa y Fred','China Zorrilla',110,2);
5- Muestre todos los registros.
Ver solucin
nombre varchar(20),
actor varchar(20),
duracion integer,
cantidad integer
);
sp_columns peliculas;
cantidad)
cantidad)
cantidad)

cantidad)
select *from peliculas;
Segundo problema:
Una empresa almacena los datos de sus empleados en
una tabla "empleados" que guarda los siguientes
datos: nombre, documento, sexo, domicilio,
sueldobasico.
if object_id('empleados') is not null
drop table empleados;
cada campo:
create table empleados(
nombre varchar(20),
documento varchar(8),
sexo varchar(1),
sueldobasico float
);
4- Ingrese algunos registros:
insert into empleados (nombre, documento, sexo,
domicilio, sueldobasico)
values ('Juan Perez','22333444','m','Sarmiento
123',500);
values ('Ana Acosta','24555666','f','Colon 134',650);

values ('Bartolome Barrios','27888999','m','Urquiza
479',800);
5- Seleccione todos los registros.
Ver solucin
nombre varchar(20),
actor varchar(20),
duracion integer,
cantidad integer
);
cantidad)
cantidad)
cantidad)
cantidad)
Segundo problema:

una tabla "empleados" que guarda los siguientes
datos: nombre, documento, sexo, domicilio,
sueldobasico.
cada campo:
nombre varchar(20),
sexo varchar(1),
sueldobasico float
);
123',500);
479',800);
5- Seleccione todos los registros.
Ver solucin

nombre varchar(20),
sexo varchar(1),
sueldobasico float
);
sp_columns empleados;
123',500);
479',800);
select *from empleados;
5 - Recuperar algunos campos (select)

Hemos aprendido cmo ver todos los registros de una tabla, empleando
la instruccin "select".
select * from NOMBRETABLA;
El asterisco (*) indica que se seleccionan todos los campos de la tabla.
Podemos especificar el nombre de los campos que queremos ver

separndolos por comas:
select titulo,autor from libros;
La lista de campos luego del "select" selecciona los datos

correspondientes a los campos nombrados. En el ejemplo anterior
seleccionamos los campos "titulo" y "autor" de la tabla "libros", mostrando
todos los registros. Los datos aparecen ordenados segn la lista de
seleccin, en dicha lista los nombres de los campos se separan con
comas.
Problema:
Trabajamos con la tabla "libros" que almacena los datos de los
libros de una librera.
Eliminamos la tabla, si existe:
drop table libros;
Creamos la tabla:
titulo varchar(40),
autor varchar(30),
precio float,
cantidad integer
);
Veamos la estructura de la tabla:

sp_columns libros;

Veamos todos los campos la tabla:

select *from libros;
Veamos solamente el ttulo, autor y editorial de todos los libros

especificando los nombres de los campos separados por
comas:
select titulo,autor,editorial from libros;
Con la siguiente sentencia seleccionamos los ttulos y precios

de todos los libros:
select titulo,precio from libros;
Veamos solamente la editorial y la cantidad de libros tipeamos:

select editorial,cantidad from libros;
Primer problema:
Un videoclub que alquila pelculas en video almacena la
informacin de sus pelculas en alquiler en
una tabla llamada "peliculas".
if object_id('peliculas') is not null
2- Cree la tabla:
titulo varchar(20),
actor varchar(20),
duracion integer,
cantidad integer
);
3- Vea la estructura de la tabla (sp_columns).
4- Ingrese alos siguientes registros:
insert into peliculas (titulo, actor, duracion, cantidad)

5- Realice un "select" mostrando solamente el ttulo y
actor de todas las pelculas
6- Muestre el ttulo y duracin de todas las peliculas
7- Muestre el ttulo y la cantidad de copias
Ver solucin
titulo varchar(20),
actor varchar(20),
duracion integer,
cantidad integer
);
select titulo,actor from peliculas;
select titulo,duracion from peliculas;
select titulo,cantidad from peliculas;
Segundo problema:
una tabla llamada "empleados".
2- Cree la tabla:
nombre varchar(20),
sexo varchar(1),
sueldobasico float
);
values ('Juan Juarez','22333444','m','Sarmiento
123',500);
values ('Carlos Caseres','31222333','m','Urquiza
479',850);
5- Muestre todos los datos de los empleados
6- Muestre el nombre, documento y domicilio de los

empleados
7- Realice un "select" mostrando el documento, sexo y
sueldo bsico de todos los empleados
Ver solucin
nombre varchar(20),
sexo varchar(1),
sueldobasico float
);
values ('Juan Juarez','22333444','m','Sarmiento
123',500);
values ('Carlos Caseres','31222333','m','Urquiza
479',850);
select *from empleados;
select nombre,documento,domicilio from empleados;
select documento,sexo,sueldobasico from empleados;
6 - Recuperar algunos registros (where)

Hemos aprendido a seleccionar algunos campos de una tabla.
Tambin es posible recuperar algunos registros.
Existe una clusula, "where" con la cual podemos especificar condiciones
para una consulta "select". Es decir, podemos recuperar algunos
registros, slo los que cumplan con ciertas condiciones indicadas con la
clusula "where". Por ejemplo, queremos ver el usuario cuyo nombre es
"Marcelo", para ello utilizamos "where" y luego de ella, la condicin:
select nombre, clave
from usuarios
where nombre='Marcelo';

select NOMBRECAMPO1, ..., NOMBRECAMPOn
from NOMBRETABLA
where CONDICION;
Para las condiciones se utilizan operadores relacionales (tema que

trataremos ms adelante en detalle). El signo igual(=) es un operador
relacional.
Para la siguiente seleccin de registros especificamos una condicin que
solicita los usuarios cuya clave es igual a "River":
select nombre,clave
from usuarios
where clave='River';
Si ningn registro cumple la condicin establecida con el "where", no

aparecer ningn registro.
Entonces, con "where" establecemos condiciones para recuperar algunos
registros.
Para recuperar algunos campos de algunos registros combinamos en la
consulta la lista de campos y la clusula "where":
select nombre
from usuarios
En la consulta anterior solicitamos el nombre de todos los usuarios cuya

clave sea igual a "River".
Problema:
Trabajamos con la tabla "usuarios" que consta de 2 campos:
nombre de usuario y clave.
Creamos la tabla:
nombre varchar(30),
clave varchar(10)
);
Vemos la estructura de la tabla:


values ('Marcelo','Boca');
values ('JuanPerez','Juancito');
values ('Susana','River');
values ('Luis','River');
Realizamos una consulta especificando una condicin,

queremos ver el usuario cuyo nombre es "Leonardo":
select *from usuarios
where nombre='Leonardo';
Queremos ver el nombre de los usuarios cuya clave es "River":

select nombre from usuarios
Realizamos un "select" de los nombres de los usuarios cuya

clave es "Santi":
where clave='Santi';
No se muestra ningn registro ya que ninguno cumple la

condicin.


nombre varchar(30),
clave varchar(10)
);

values ('Marcelo','Boca');
values ('JuanPerez','Juancito');
values ('Susana','River');
values ('Luis','River');
select *from usuarios

where nombre='Leonardo';


where clave='Santi';
Primer problema:
Trabaje con la tabla "agenda" en la que registra los
datos de sus amigos.
1- Elimine "agenda", si existe:

drop table agenda;
2- Cree la tabla, con los siguientes campos: apellido
(cadena de 30), nombre (cadena de 20),
domicilio (cadena de 30) y telefono (cadena de 11).
3- Visualice la estructura de la tabla "agenda".
Acosta, Ana, Colon 123, 4234567;
Bustamante, Betina, Avellaneda 135, 4458787;
Lopez, Hector, Salta 545, 4887788;
Lopez, Luis, Urquiza 333, 4545454;
Lopez, Marisa, Urquiza 333, 4545454.
5- Seleccione todos los registros de la tabla
6- Seleccione el registro cuyo nombre sea "Marisa" (1
registro)
7- Seleccione los nombres y domicilios de quienes
tengan apellido igual a "Lopez" (3 registros)
8- Muestre el nombre de quienes tengan el telfono
"4545454" (2 registros)
Ver solucin
drop table agenda;
create table agenda (
nombre varchar(20),
);
sp_columns agenda;
insert into agenda(apellido,nombre,domicilio,telefono)
values
('Acosta', 'Ana', 'Colon 123', '4234567');
values
('Bustamante', 'Betina', 'Avellaneda 135', '4458787');
values
('Lopez', 'Hector', 'Salta 545', '4887788');
values
('Lopez', 'Luis', 'Urquiza 333', '4545454');
values
('Lopez', 'Marisa', 'Urquiza 333', '4545454');
select *from agenda;
select *from agenda
where nombre='Marisa';
select nombre,domicilio from agenda
where apellido='Lopez';
select nombre from agenda
where telefono='4545454';
Segundo problema:
Trabaje con la tabla "libros" de una librera que guarda
informacin referente a sus libros
disponibles para la venta.
1- Elimine la tabla si existe.
2- Cree la tabla "libros". Debe tener la siguiente

estructura:
create table libros (
titulo varchar(20),
autor varchar(30),
editorial varchar(15));
3- Visualice la estructura de la tabla "libros".
El aleph,Borges,Emece;
Martin Fierro,Jose Hernandez,Emece;
Martin Fierro,Jose Hernandez,Planeta;
Aprenda PHP,Mario Molina,Siglo XXI;
5- Seleccione los registros cuyo autor sea "Borges" (1
registro)
6- Seleccione los ttulos de los libros cuya editorial sea
"Emece" (2 registros)
7- Seleccione los nombres de las editoriales de los
libros cuyo titulo sea "Martin Fierro" (2
registros)
Ver solucin
drop table libros;
titulo varchar(20),
autor varchar(30),
);
sp_columns libros;
insert into libros(titulo,autor,editorial) values

('El aleph','Borges','Emece');
('Martin Fierro','Jose Hernandez','Emece');
('Martin Fierro','Jose Hernandez','Planeta');
('Aprenda PHP','Mario Molina','Siglo XXI');
select *from libros
where autor='Borges';
select titulo from libros
where editorial='Emece';
select editorial from libros
where titulo='Martin Fierro';
7 - Operadores relacionales
Los operadores son smbolos que permiten realizar operaciones

matemticas, concatenar cadenas, hacer comparaciones.
SQL Server tiene 4 tipos de operadores:
1. relacionales (o de comparacin)
2. aritmticos
3. de concatenacin
4. lgicos.
Por ahora veremos solamente los primeros.
Los operadores relacionales (o de comparacin) nos permiten comparar
dos expresiones, que pueden ser variables, valores de campos, etc.
Hemos aprendido a especificar condiciones de igualdad para seleccionar

registros de una tabla; por ejemplo:
select *from libros
where autor='Borges';
Utilizamos el operador relacional de igualdad.

Los operadores relacionales vinculan un campo con un valor para que
SQL Server compare cada registro (el campo especificado) con el valor
dado.
Los operadores relacionales son los siguientes:
=
<>
>
<
>=
<=
igual
distinto
mayor
menor
mayor o igual
menor o igual
Podemos seleccionar los registros cuyo autor sea diferente de "Borges",

para ello usamos la condicin:
select * from libros
where autor<>'Borges';
Podemos comparar valores numricos. Por ejemplo, queremos mostrar

los ttulos y precios de los libros cuyo precio sea mayor a 20 pesos:
select titulo, precio
from libros
where precio>20;
Queremos seleccionar los libros cuyo precio sea menor o igual a 30:
select *from libros
where precio<=30;
Los operadores relacionales comparan valores del mismo tipo. Se

emplean para comprobar si un campo cumple con una condicin.
No son los nicos, existen otros que veremos mas adelante.
Problema:
Trabajamos con la tabla "libros" de una librera.
Eliminamos la tabla "libros", si existe:
drop table libros;
La creamos con la siguiente estructura:

titulo varchar(30),
autor varchar(30),
precio float
);
Agregamos registros a la tabla:

insert into libros (titulo,autor,editorial,precio)
values ('El aleph','Borges','Emece',24.50);
values ('Martin Fierro','Jose Hernandez','Emece',16.00);
values ('Aprenda PHP','Mario Molina','Emece',35.40);
values ('Cervantes y el quijote','Borges','Paidos',50.90);
Seleccionamos los registros cuyo autor sea diferente de

'Borges':
select *from libros
Seleccionamos los registros cuyo precio supere los 20 pesos,

slo el ttulo y precio:
select titulo,precio
from libros
where precio>20;
Note que el valor con el cual comparamos el campo "precio",

como es numrico (float), no se coloca entre comillas. Los
libros cuyo precio es menor o igual a 20 pesos no aparece en
la seleccin.
Recuperamos aquellos libros cuyo precio es menor o igual a
30:
select *from libros
where precio<=30;

drop table libros;

titulo varchar(30),
autor varchar(30),
precio float
);

values ('Martin Fierro','Jose Hernandez','Emece',16.00);
values ('Cervantes y el quijote','Borges','Paidos',50.90);
select *from libros

select titulo,precio
from libros
where precio>20;
select *from libros

where precio<=30;
Primer problema:
Un comercio que vende artculos de computacin
registra los datos de sus artculos en una tabla con
ese nombre.
1- Elimine "articulos", si existe:
if object_id('articulos') is not null
drop table articulos;
2- Cree la tabla, con la siguiente estructura:
create table articulos(
codigo integer,
nombre varchar(20),
descripcion varchar(30),
precio float,
cantidad integer
);
3- Vea la estructura de la tabla (sp_columns).
insert into articulos (codigo, nombre, descripcion,
precio,cantidad)
values (1,'impresora','Epson Stylus C45',400.80,20);
precio,cantidad)
values (2,'impresora','Epson Stylus C85',500,30);
precio,cantidad)
values (3,'monitor','Samsung 14',800,10);
precio,cantidad)
values (4,'teclado','ingles Biswal',100,50);
precio,cantidad)
values (5,'teclado','espaol Biswal',90,50);
5- Seleccione los datos de las impresoras (2 registros)
6- Seleccione los artculos cuyo precio sea mayor o
igual a 400 (3 registros)
7- Seleccione el cdigo y nombre de los artculos cuya
cantidad sea menor a 30 (2 registros)
8- Selecciones el nombre y descripcin de los artculos
que NO cuesten $100 (4 registros)
Ver solucin

codigo integer,
nombre varchar(20),
precio float,
cantidad integer
);
sp_columns articulos;
precio,cantidad)
precio,cantidad)
precio,cantidad)
precio,cantidad)
precio,cantidad)
select *from articulos
where nombre='impresora';
select *from articulos
where precio>=400;
select codigo,nombre
from articulos
where cantidad<30;
select nombre, descripcion
from articulos
where precio<>100;
Segundo problema:
Un video club que alquila pelculas en video almacena la
informacin de sus pelculas en alquiler en
una tabla denominada "peliculas".
1- Elimine la tabla, si existe.
cada campo:
titulo varchar(20),
actor varchar(20),
duracion integer,
cantidad integer
);
values ('Mujer bonita','Julia R.',90,1);
4- Seleccione las pelculas cuya duracin no supere los
90 minutos (2 registros)
5- Seleccione el ttulo de todas las pelculas en las que
el actor NO sea "Tom Cruise" (2
registros)
6- Muestre todos los campos, excepto "duracion", de
todas las pelculas de las que haya ms de 2
copias (2 registros)
Ver solucin
titulo varchar(20),
actor varchar(20),
duracion integer,
cantidad integer
);
values ('Mujer bonita','Julia R.',90,1);
select *from peliculas
where duracion<=90;
select *from peliculas
where actor<>'Tom Cruise';
select titulo,actor,cantidad
from peliculas
where cantidad >2;
8 - Borrar registros (delete)
Para eliminar los registros de una tabla usamos el comando "delete":

delete from usuarios;
Muestra un mensaje indicando la cantidad de registros que ha eliminado.

Si no queremos eliminar todos los registros, sino solamente algunos,
debemos indicar cul o cules, para ello utilizamos el comando "delete"
junto con la clausula "where" con la cual establecemos la condicin que
deben cumplir los registros a borrar.
Por ejemplo, queremos eliminar aquel registro cuyo nombre de usuario
es "Marcelo":
delete from usuarios
Si solicitamos el borrado de un registro que no existe, es decir, ningn

registro cumple con la condicin especificada, ningn registro ser
eliminado.
Tenga en cuenta que si no colocamos una condicin, se eliminan todos
los registros de la tabla nombrada.
Problema:
Trabajamos con la tabla "usuarios".
Eliminamos la tabla "usuarios", si existe:

nombre varchar(30),
clave varchar(10)
);

values ('Marcelo','River');
values ('Susana','chapita');
values ('CarlosFuentes','Boca');
values ('FedericoLopez','Boca');
Seleccionamos todos los registros:

select *from usuarios;
Vamos a eliminar el registro cuyo nombre de usuario es

"Marcelo":
Veamos el contenido de la tabla:

Intentamos eliminarlo nuevamente:


Como ningn registro cumple con la condicin no se borran

registros.
Eliminamos todos los registros cuya clave es 'Boca':
where clave='Boca';

Eliminemos todos los registros:


No hay registros.
Problema:

Eliminamos la tabla "usuarios", si existe:

nombre varchar(30),
clave varchar(10)
);

values ('CarlosFuentes','Boca');
values ('FedericoLopez','Boca');
Seleccionamos todos los registros:

Vamos a eliminar el registro cuyo nombre de usuario es

"Marcelo":

Intentamos eliminarlo nuevamente:


Como ningn registro cumple con la condicin no se borran

registros.
Eliminamos todos los registros cuya clave es 'Boca':

where clave='Boca';

Eliminemos todos los registros:


No hay registros.
Primer problema:
Trabaje con la tabla "agenda" que registra la
informacin referente a sus amigos.
1- Elimine la tabla si existe:
drop table agenda;
2- Cree la tabla con los siguientes campos: apellido
(cadena de 30), nombre (cadena de 20),
domicilio (cadena de 30) y telefono (cadena de 11):
nombre varchar(20),
);
3- Ingrese los siguientes registros (insert into):
Alvarez,Alberto,Colon 123,4234567,
Juarez,Juan,Avellaneda 135,4458787,
Lopez,Maria,Urquiza 333,4545454,
Lopez,Jose,Urquiza 333,4545454,
Salas,Susana,Gral. Paz 1234,4123456.
4- Elimine el registro cuyo nombre sea "Juan" (1
registro afectado)
5- Elimine los registros cuyo nmero telefnico sea
igual a "4545454" (2 registros afectados):
6- Muestre la tabla.
7- Elimine todos los registros (2 registros afectados):
8- Muestre la tabla.
Ver solucin
drop table agenda;
nombre varchar(20),
);
insert into agenda (apellido,nombre,domicilio,telefono)
values('Alvarez','Alberto','Colon 123','4234567');
values('Juarez','Juan','Avellaneda 135','4458787');
values('Lopez','Maria','Urquiza 333','4545454');
values('Lopez','Jose','Urquiza 333','4545454');
values('Salas','Susana','Gral. Paz 1234','4123456');
delete from agenda
where nombre='Juan';
delete from agenda
select * from agenda;
delete from agenda;
Segundo problema:
Un comercio que vende artculos de computacin
registra los datos de sus artculos en una tabla con
ese nombre.
1- Elimine "articulos", si existe:
2- Cree la tabla, con la siguiente estructura:
codigo integer,
nombre varchar(20),
precio float,
cantidad integer
);
3- Vea la estructura de la tabla.
precio,cantidad)
precio,cantidad)

precio,cantidad)
precio,cantidad)
precio,cantidad)
5- Elimine los artculos cuyo precio sea mayor o igual a
500 (2 registros)
delete from articulos
where precio>=500;
7- Elimine todas las impresoras (1 registro)
8- Elimine todos los artculos cuyo cdigo sea diferente
a 4 (1 registro)
where codigo<>4;
9- Mostrar la tabla despus que borra cada registro.
Ver solucin
codigo integer,
nombre varchar(20),
precio float,
cantidad integer
);
sp_columns articulos;
precio,cantidad)
precio,cantidad)
precio,cantidad)
precio,cantidad)
precio,cantidad)
where precio>=500;
select * from articulos;
where codigo<>4;
9 - Actualizar registros (update)
Decimos que actualizamos un registro cuando modificamos alguno de

sus valores.
Para modificar uno o varios datos de uno o varios registros utilizamos
"update" (actualizar).
Por ejemplo, en nuestra tabla "usuarios", queremos cambiar los valores
de todas las claves, por "RealMadrid":
update usuarios set clave='RealMadrid';
Utilizamos "update" junto al nombre de la tabla y "set" junto con el campo

a modificar y su nuevo valor.
El cambio afectar a todos los registros.
Podemos modificar algunos registros, para ello debemos establecer
condiciones de seleccin con "where".
Por ejemplo, queremos cambiar el valor correspondiente a la clave de
nuestro usuario llamado "Federicolopez", queremos como nueva clave
"Boca", necesitamos una condicin "where" que afecte solamente a este
registro:
update usuarios set clave='Boca'
where nombre='Federicolopez';
Si Microsoft SQL Server no encuentra registros que cumplan con la

condicin del "where", no se modifica ninguno.
Las condiciones no son obligatorias, pero si omitimos la clusula "where",
la actualizacin afectar a todos los registros.
Tambin podemos actualizar varios campos en una sola instruccin:
update usuarios set nombre='Marceloduarte', clave='Marce'
Para ello colocamos "update", el nombre de la tabla, "set" junto al

nombre del campo y el nuevo valor y separado por coma, el otro nombre
del campo con su nuevo valor.
Problema:
Eliminamos la tabla si existe:
Creamos la tabla:
nombre varchar(20),
clave varchar(10)
);

values ('Carlosfuentes','Boca');
values ('Federicolopez','Boca');
Cambiaremos los valores de todas las claves, por la cadena

"RealMadrid":
update usuarios set clave='RealMadrid';
El cambio afect a todos los registros, vemoslo:

Necesitamos cambiar el valor de la clave del usuario llamado

"Federicolopez" por "Boca":
update usuarios set clave='Boca'
where nombre='Federicolopez';
Verifiquemos que la actualizacin se realiz:

Vimos que si Microsoft SQL Server no encuentra registros que

cumplan con la condicin no se modifican registros:
update usuarios set clave='payaso'
where nombre='JuanaJuarez';
Si vemos la tabla veremos que no a cambiado:

Para actualizar varios campos en una sola instruccin

empleamos:
update usuarios set nombre='Marceloduarte', clave='Marce'

Si vemos la tabla:
Primer problema:
Trabaje con la tabla "agenda" que almacena los datos
de sus amigos.
drop table agenda;
2- Cree la tabla:
nombre varchar(20),
);
3- Ingrese los siguientes registros (1 registro
actualizado):
values ('Acosta','Alberto','Colon 123','4234567');
values ('Juarez','Juan','Avellaneda 135','4458787');
values ('Lopez','Maria','Urquiza 333','4545454');
values ('Lopez','Jose','Urquiza 333','4545454');
values ('Suarez','Susana','Gral. Paz 1234','4123456');
4- Modifique el registro cuyo nombre sea "Juan" por
"Juan Jose" (1 registro afectado)
5- Actualice los registros cuyo nmero telefnico sea

igual a "4545454" por "4445566"
(2 registros afectados)
6- Actualice los registros que tengan en el campo
"nombre" el valor "Juan" por "Juan Jose" (ningn
registro afectado porque ninguno cumple con la
condicin del "where")
7 - Luego de cada actualizacin ejecute un select que
muestre todos los registros de la tabla.
Ver solucin
drop table agenda;
nombre varchar(20),
);
values ('Acosta','Alberto','Colon 123','4234567');
values ('Juarez','Juan','Avellaneda 135','4458787');
values ('Lopez','Maria','Urquiza 333','4545454');
values ('Lopez','Jose','Urquiza 333','4545454');
values ('Suarez','Susana','Gral. Paz 1234','4123456');
update agenda set nombre='Juan Jose'

update agenda set telefono='4445566'
update agenda set nombre='Juan Jose'
Segundo problema:
Trabaje con la tabla "libros" de una librera.
drop table libros;
2- Crela con los siguientes campos: titulo (cadena de
30 caracteres de longitud), autor (cadena de
20), editorial (cadena de 15) y precio (float):
titulo varchar(30),
autor varchar(20),
precio float
);
insert into libros (titulo, autor, editorial, precio)
values ('Martin Fierro','Jose
Hernandez','Planeta',35.50);

values ('Cervantes y el quijote','Borges','Emece',25);
values ('Matematica estas ahi','Paenza','Siglo
XXI',15);
4- Muestre todos los registros (5 registros):
5- Modifique los registros cuyo autor sea igual a
"Paenza", por "Adrian Paenza" (1 registro
afectado)
update libros set autor='Adrian Paenza'
where autor='Paenza';
6- Nuevamente, modifique los registros cuyo autor sea
igual a "Paenza", por "Adrian Paenza" (ningn
registro afectado porque ninguno cumple la condicin)
7- Actualice el precio del libro de "Mario Molina" a 27
pesos (1 registro afectado):
update libros set precio=27
where autor='Mario Molina';
8- Actualice el valor del campo "editorial" por "Emece
S.A.", para todos los registros cuya
editorial sea igual a "Emece" (3 registros afectados):
update libros set editorial='Emece S.A.'
9 - Luego de cada actualizacin ejecute un select que
mustre todos los registros de la tabla.
Ver solucin

drop table libros;
titulo varchar(30),
autor varchar(20),
precio float
);
values ('Martin Fierro','Jose
Hernandez','Planeta',35.50);
values ('Cervantes y el quijote','Borges','Emece',25);
values ('Matematica estas ahi','Paenza','Siglo
XXI',15);
update libros set precio=27
where autor='Mario Molina';

update libros set editorial='Emece S.A.'
Para aclarar algunas instrucciones, en ocasiones, necesitamos agregar
comentarios.
Es posible ingresar comentarios en la lnea de comandos, es decir, un
texto que no se ejecuta; para ello se emplean dos guiones (--) al
comienzo de la lnea:
select * from libros --mostramos los registros de
libros;
en la lnea anterior, todo lo que est luego de los guiones (hacia la
derecha) no se ejecuta.
Para agregar varias lneas de comentarios, se coloca una barra seguida
de un asterisco (/*) al comienzo del bloque de comentario y al finalizarlo,
un asterisco seguido de una barra (*/).
select titulo, autor
/*mostramos ttulos y
nombres de los autores*/
from libros;
todo lo que est entre los smbolos "/*" y "*/" no se ejecuta.
Problema:
Trabajamos con la tabla "libros" que almacena los datos de los
libros de una librera.
drop table libros;
Creamos la tabla:
titulo varchar(30),
autor varchar(20),
);
Agregamos un registro:
insert into libros (titulo,autor,editorial)
values ('El aleph','Borges','Emece');
Mostramos todos los libros y agregamos un comentario de

linea:
select * from libros --mostramos los registros de libros;
vamos a mostrar el ttulo y autor de todos los libros y

agregamos un bloque de comentarios:
select titulo, autor
/*mostramos ttulos y
nombres de los autores*/
from libros;
Note que lo que est entre los smbolos no se ejecuta.

11 - Valores null (is null)
"null" significa "dato desconocido" o "valor inexistente". No es lo mismo
que un valor "0", una cadena vaca o una cadena literal "null".
A veces, puede desconocerse o no existir el dato correspondiente a
algn campo de un registro. En estos casos decimos que el campo
puede contener valores nulos.
Por ejemplo, en nuestra tabla de libros, podemos tener valores nulos en
el campo "precio" porque es posible que para algunos libros no le
hayamos establecido el precio para la venta.
En contraposicin, tenemos campos que no pueden estar vacos jams.
Veamos un ejemplo. Tenemos nuestra tabla "libros". El campo "titulo" no
debera estar vaco nunca, igualmente el campo "autor". Para ello, al
crear la tabla, debemos especificar que dichos campos no admitan
valores nulos:
titulo varchar(30) not null,
autor varchar(20) not null,
editorial varchar(15) null,
precio float
);
Para especificar que un campo no admita valores nulos, debemos

colocar "not null" luego de la definicin del campo.
En el ejemplo anterior, los campos "editorial" y "precio" si admiten valores
nulos.
Cuando colocamos "null" estamos diciendo que admite valores nulos
(caso del campo "editorial"); por defecto, es decir, si no lo aclaramos, los
campos permiten valores nulos (caso del campo "precio").
Si ingresamos los datos de un libro, para el cual an no hemos definido
el precio podemos colocar "null" para mostrar que no tiene precio:
values('El aleph','Borges','Emece',null);
Note que el valor "null" no es una cadena de caracteres, no se coloca

entre comillas.
Entonces, si un campo acepta valores nulos, podemos ingresar "null"
cuando no conocemos el valor.
Tambin podemos colocar "null" en el campo "editorial" si desconocemos
el nombre de la editorial a la cual pertenece el libro que vamos a
ingresar:
values('Alicia en el pais','Lewis Carroll',null,25);
Si intentamos ingresar el valor "null" en campos que no admiten valores

nulos (como "titulo" o "autor"), SQL Server no lo permite, muestra un
mensaje y la insercin no se realiza; por ejemplo:
values(null,'Borges','Siglo XXI',25);
Para ver cules campos admiten valores nulos y cules no, podemos
emplear el procedimiento almacenado "sp_columns" junto al nombre de
la tabla. Nos muestra mucha informacin, en la columna "IS_NULLABLE"
vemos que muestra "NO" en los campos que no permiten valores nulos y
"YES" en los campos que si los permiten.
Para recuperar los registros que contengan el valor "null" en algn
campo, no podemos utilizar los operadores relacionales vistos
anteriormente: = (igual) y <> (distinto); debemos utilizar los operadores
"is null" (es igual a null) y "is not null" (no es null):
where precio is null;
La sentencia anterior tendr una salida diferente a la siguiente:

where precio=0;
Con la primera sentencia veremos los libros cuyo precio es igual a "null"
(desconocido); con la segunda, los libros cuyo precio es 0.
Igualmente para campos de tipo cadena, las siguientes sentencias
"select" no retornan los mismos registros:
select * from libros where editorial is null;
select * from libros where editorial='';
Con la primera sentencia veremos los libros cuya editorial es igual a

"null", con la segunda, los libros cuya editorial guarda una cadena vaca.
Entonces, para que un campo no permita valores nulos debemos
especificarlo luego de definir el campo, agregando "not null". Por defecto,
los campos permiten valores nulos, pero podemos especificarlo
igualmente agregando "null".
Problema:
Trabajamos con la tabla "libros" de una librera.
Eliminamos la tabla "libros", si existe:
drop table libros;
Creamos la tabla especificando que los campos "titulo" y

"autor" no admitan valores nulos:
autor varchar(30) not null,
editorial varchar(15) null,
precio float
);
Los campos "editorial" y "precio" si permiten valores nulos; el

primero, porque lo especificamos colocando "null" en la
definicin del campo, el segundo lo asume por defecto.
Agregamos un registro a la tabla con valor nulo para el campo
"precio":
values('El aleph','Borges','Emece',null);
Recuerde que el valor "null" no es una cadena de caracteres,

por lo tanto no se coloca entre comillas.
Ingresamos otro registro, con valor nulo para el campo
"editorial", campo que admite valores "null":
values('Alicia en el pais','Lewis Carroll',null,0);
Veamos lo que sucede si intentamos ingresar el valor "null" en

campos que no lo admiten, como "titulo":
values(null,'Borges','Siglo XXI',25);
aparece un mensaje y la sentencia no se ejecuta.

Para ver cules campos admiten valores nulos y cules no,
empleamos el procedimiento almacenado "sp_columns":
sp_columns libros;
nos muestra muchas columnas, una de ellas tiene el

encabezado "IS_NULLABLE", vemos que aparece "NO" en los
campos que no permiten valores nulos y "YES" en los campos
que si los permiten.
Dijimos que el valor "null" no es lo mismo que una cadena
vaca. Vamos a ingresar un registro con cadena vaca para el
campo "editorial":
values('Uno','Richard Bach','',18.50);
Ingresamos otro registro, ahora cargamos una cadena vaca en

el campo "titulo":
values('','Richard Bach','Planeta',22);
Veamos todos los regiustros ingresados:

Recuperemos los registros que contengan el valor "null" en el

campo "precio":
select *from libros

La sentencia anterior tendr una salida diferente a la siguiente:

select *from libros
where precio=0;
Con la primera sentencia veremos los libros cuyo precio es

igual a "null" (desconocido); con la segunda, los libros cuyo
precio es 0.
Recuperemos los libros cuyo nombre de editorial es "null":
select *from libros
where editorial is null;
Ahora veamos los libros cuya editorial almacena una cadena

vaca:
select *from libros
where editorial='';
Para recuperar los libros cuyo precio no sea nulo tipeamos:

select *from libros
where precio is not null;
Primer problema:
Una farmacia guarda informacin referente a sus
medicamentos en una tabla llamada "medicamentos".
if object_id('medicamentos') is not null
drop table medicamentos;
2- Cree la tabla con la siguiente estructura:
create table medicamentos(
codigo integer not null,
nombre varchar(20) not null,
laboratorio varchar(20),
precio float,
cantidad integer not null
);
3- Visualice la estructura de la tabla "medicamentos":

sp_columns medicamentos;
note que los campos "codigo", "nombre" y "cantidad",
en la columna "IS_NULLABLE" aparece "NO" y en
las otras "YES".
4- Ingrese algunos registros con valores "null" para los
campos que lo admitan:
insert into medicamentos
(codigo,nombre,laboratorio,precio,cantidad)
values(1,'Sertal gotas',null,null,100);
values(2,'Sertal compuesto',null,8.90,150);
values(3,'Buscapina','Roche',null,200);
5- Vea todos los registros:
select *from medicamentos;
6- Ingrese un registro con valor "0" para el precio y
cadena vaca para el laboratorio:
insert into medicamentos (codigo,nombre,
laboratorio,precio,cantidad)
values(4,'Bayaspirina','',0,150);
7- Ingrese un registro con valor "0" para el cdigo y
cantidad y cadena vaca para el nombre:
values(0,'','Bayer',15.60,0);
8- Muestre todos los registros:
9- Intente ingresar un registro con valor nulo para un

campo que no lo admite (aparece un mensaje de
error):
values(null,'Amoxidal jarabe','Bayer',25,120);
10- Recupere los registros que contengan valor "null"
en el campo "laboratorio", luego los que
tengan una cadena vaca en el mismo campo. Note que
el resultado es diferente.
11- Recupere los registros que contengan valor "null"
en el campo "precio", luego los que tengan el
valor 0 en el mismo campo. Note que el resultado es
distinto.
12- Recupere los registros cuyo laboratorio no contenga
una cadena vaca, luego los que sean
distintos de "null".
Note que la salida de la primera sentencia no muestra
los registros con cadenas vacas y tampoco los
que tienen valor nulo; el resultado de la segunda
sentencia muestra los registros con valor para el
campo laboratorio (incluso cadena vaca).
13- Recupere los registros cuyo precio sea distinto de
0, luego los que sean distintos de "null":
Note que la salida de la primera sentencia no muestra
los registros con valor 0 y tampoco los que
tienen valor nulo; el resultado de la segunda sentencia
muestra los registros con valor para el
campo precio (incluso el valor 0).
Ver solucin
if object_id('medicamentos') is not null
drop table medicamentos;
create table medicamentos(

codigo integer not null,
nombre varchar(20) not null,
laboratorio varchar(20),
precio float,
cantidad integer not null
);
sp_columns medicamentos;
values(1,'Sertal gotas',null,null,100);
values(2,'Sertal compuesto',null,8.90,150);
values(3,'Buscapina','Roche',null,200);
insert into medicamentos (codigo,nombre,
laboratorio,precio,cantidad)
values(4,'Bayaspirina','',0,150);
values(0,'','Bayer',15.60,0);
values(null,'Amoxidal jarabe','Bayer',25,120);
select *from medicamentos

where laboratorio is null;
where laboratorio='';
where precio=0;
where laboratorio<>'';
where laboratorio is not null;
where precio<>0;
where precio is not null;
Segundo problema:
Trabaje con la tabla que almacena los datos sobre
pelculas, llamada "peliculas".
2- Crela con la siguiente estructura:

codigo int not null,
actor varchar(20),
duracion int
);
3- Visualice la estructura de la tabla
note que el campo "codigo" y "titulo", en la columna
"IS_NULLABLE" muestra "NO" y los otros campos
"YES".
insert into peliculas (codigo,titulo,actor,duracion)
values(1,'Mision imposible','Tom Cruise',120);
values(2,'Harry Potter y la piedra filosofal',null,180);
values(3,'Harry Potter y la camara secreta','Daniel
R.',null);
values(0,'Mision imposible 2','',150);
values(4,'','L. Di Caprio',220);
values(5,'Mujer bonita','R. Gere-J. Roberts',0);
5- Recupere todos los registros para ver cmo SQL
Server los almacen:
6- Intente ingresar un registro con valor nulo para
campos que no lo admiten (aparece un mensaje de
error):
values(null,'Mujer bonita','R. Gere-J. Roberts',190);
7- Muestre los registros con valor nulo en el campo

"actor" y luego los que guardan una cadena vaca
(note que la salida es distinta) (1 registro)
8- Modifique los registros que tengan valor de duracin
desconocido (nulo) por "120" (1 registro
actualizado)
9- Coloque 'Desconocido' en el campo "actor" en los
registros que tengan una cadena vaca en dicho
campo (1 registro afectado)
10- Muestre todos los registros. Note que el cambio
anterior no afect a los registros con valor
nulo en el campo "actor".
11- Elimine los registros cuyo ttulo sea una cadena
vaca (1 registro)
Ver solucin
actor varchar(20),
duracion int
);
values(1,'Mision imposible','Tom Cruise',120);
values(2,'Harry Potter y la piedra filosofal',null,180);
values(3,'Harry Potter y la camara secreta','Daniel

R.',null);
values(0,'Mision imposible 2','',150);
values(4,'','L. Di Caprio',220);
values(5,'Mujer bonita','R. Gere-J. Roberts',0);
values(null,'Mujer bonita','R. Gere-J. Roberts',190);
select * from peliculas
where actor is null;
update peliculas set duracion=120 where duracion is
null;
update peliculas set actor='Desconocido'
where actor='';
select * from peliculas;
delete from peliculas
where titulo='';
select * from peliculas;
12 - Clave primaria
Una clave primaria es un campo (o varios) que identifica un solo registro
(fila) en una tabla.
Para un valor del campo clave existe solamente un registro.
Veamos un ejemplo, si tenemos una tabla con datos de personas, el
nmero de documento puede establecerse como clave primaria, es un
valor que no se repite; puede haber personas con igual apellido y

nombre, incluso el mismo domicilio (padre e hijo por ejemplo), pero su
documento ser siempre distinto.
Si tenemos la tabla "usuarios", el nombre de cada usuario puede
establecerse como clave primaria, es un valor que no se repite; puede
haber usuarios con igual clave, pero su nombre de usuario ser siempre
diferente.
Podemos establecer que un campo sea clave primaria al momento de
crear la tabla o luego que ha sido creada. Vamos a aprender a
establecerla al crear la tabla. Hay 2 maneras de hacerlo, por ahora
veremos la sintaxis ms sencilla.
Tenemos nuestra tabla "usuarios" definida con 2 campos ("nombre" y
"clave").
create table NOMBRETABLA(
CAMPO TIPO,
...
primary key (NOMBRECAMPO)
);
En el siguiente ejemplo definimos una clave primaria, para nuestra tabla

"usuarios" para asegurarnos que cada usuario tendr un nombre
diferente y nico:
nombre varchar(20),
clave varchar(10),
primary key(nombre)
);
Lo que hacemos agregar luego de la definicin de cada campo, "primary

key" y entre parntesis, el nombre del campo que ser clave primaria.
Una tabla slo puede tener una clave primaria. Cualquier campo (de
cualquier tipo) puede ser clave primaria, debe cumplir como requisito,
que sus valores no se repitan ni sean nulos. Por ello, al definir un campo
como clave primaria, automticamente SQL Server lo convierte a "not
null".
Luego de haber establecido un campo como clave primaria, al ingresar
los registros, SQL Server controla que los valores para el campo
establecido como clave primaria no estn repetidos en la tabla; si
estuviesen repetidos, muestra un mensaje y la insercin no se realiza. Es
decir, si en nuestra tabla "usuarios" ya existe un usuario con nombre
"juanperez" e intentamos ingresar un nuevo usuario con nombre

"juanperez", aparece un mensaje y la instruccin "insert" no se ejecuta.
Igualmente, si realizamos una actualizacin, SQL Server controla que los
valores para el campo establecido como clave primaria no estn
repetidos en la tabla, si lo estuviese, aparece un mensaje indicando que
se viProblema:

Creamos la tabla definiendo el campo "nombre" como clave

primaria:
nombre varchar(20),
clave varchar(10),
primary key(nombre)
);
Al campo "nombre" no lo definimos "not null", pero al

establecerse como clave primaria, SQL Server lo convierte en
"not null", veamos que en la columna "IS_NULLABLE" aparece
"NO":

values ('juanperez','Boca');
values ('raulgarcia','River');
Recordemos que cuando un campo es clave primaria, sus

valores no se repiten. Intentamos ingresar un valor de clave
primaria existente:
values ('juanperez','payaso');
Cuando un campo es clave primaria, sus valores no pueden ser

nulos. Intentamos ingresar el valor "null" en el campo clave
primaria:
values (null,'payaso');

Si realizamos alguna actualizacin, SQL Server controla que
los valores para el campo establecido como clave primaria no
estn repetidos en la tabla. Intentemos actualizar el nombre de
un usuario colocando un nombre existente:
update usuarios set nombre='juanperez'
where nombre='raulgarcia';
aparece un mensaje indicando que se viola la clave primaria y

la actualizacin no se realiza.
Primer problema:
Trabaje con la tabla "libros" de una librera.
drop table libros;
2- Crela con los siguientes campos, estableciendo
como clave primaria el campo "codigo":
autor varchar(20),
primary key(codigo)
);
insert into libros (codigo,titulo,autor,editorial)
values (1,'El aleph','Borges','Emece');
values (2,'Martin Fierro','Jose Hernandez','Planeta');

values (3,'Aprenda PHP','Mario Molina','Nuevo Siglo');
4- Ingrese un registro con cdigo repetido (aparece un
mensaje de error)
5- Intente ingresar el valor "null" en el campo "codigo"
6- Intente actualizar el cdigo del libro "Martin Fierro" a
"1" (mensaje de error)
Ver solucin
drop table libros;
autor varchar(20),
primary key(codigo)
);
values (1,'El aleph','Borges','Emece');
values (2,'Martin Fierro','Jose Hernandez','Planeta');
values (3,'Aprenda PHP','Mario Molina','Nuevo Siglo');
values (2,'Alicia en el pais de las maravillas','Lewis
Carroll','Planeta');
values (null,'Alicia en el pais de las maravillas','Lewis
Carroll','Planeta');
update libros set codigo=1

where titulo='Martin Fierro';
Segundo problema:
Un instituto de enseanza almacena los datos de sus
estudiantes en una tabla llamada "alumnos".
1- Elimine la tabla "alumnos" si existe:
if object_id('alumnos') is not null
drop table alumnos;
2- Cree la tabla con la siguiente estructura intentando
establecer 2 campos como clave primaria, el
campo "documento" y "legajo" (no lo permite):
create table alumnos(
legajo varchar(4) not null,
nombre varchar(30),
primary key(documento),
primary key(legajo)
);
3- Cree la tabla estableciendo como clave primaria el
campo "documento":
nombre varchar(30),
primary key(documento)
);
4- Verifique que el campo "documento" no admite
valores nulos:
sp_columns alumnos;
insert into alumnos

(legajo,documento,nombre,domicilio)
values('A233','22345345','Perez Mariana','Colon 234');
insert into alumnos
values('A567','23545345','Morales Marcos','Avellaneda
348');
6- Intente ingresar un alumno con nmero de
documento existente (no lo permite)
7- Intente ingresar un alumno con documento nulo (no
lo permite)
Ver solucin
if object_id('alumnos') is not null
drop table alumnos;
nombre varchar(30),
primary key(documento),
primary key(legajo)
);
nombre varchar(30),
primary key(documento)
);
sp_columns alumnos;
insert into alumnos

values('A233','22345345','Perez Mariana','Colon 234');
insert into alumnos
values('A567','23545345','Morales Marcos','Avellaneda
348');
insert into alumnos
values('A642','23545345','Gonzalez Analia','Caseros
444');
insert into alumnos
values('A685',null,'Miranda Carmen','Uspallata 999');

SQL Server Tutorial

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

SQL Server Tutorial

Caricato da

Copyright:

Formati disponibili

Orden

Objetivos y alcances del tutorial

Crear una tabla (create table sp_tables - sp_columns - drop

Insertar y recuperar registros

Tipos de datos bsicos

Recuperar algunos campos

Recuperar algunos registros

Borrar registros (delete)

Actualizar registros (update)

Valores null (is null)

Campo con atributo Identity

Otras caractersticas del

Otros tipos de datos en SQL

Tipo de dato (texto)

Tipo de dato (numrico)

Tipo de dato (fecha y hora)

Ingresar algunos campos

Valores por defecto (default)

Funciones para el manejo de

Funciones para el uso de fechas

Ordenar registros (order by)

Operadores lgicos ( and - or not)

Otros operadores relacionales

Otros operadores relacionales

Otros operadores relacionales

Bsqueda de patrones (like not like)

Contar registros (count)

Contar registros (count_big)

Agrupar registros (group by)

Seleccionar grupos (having)

Modificador del group by (with

Modificador del group by (with

Clusulas compute y compute

Registros duplicados (distinct)

Clave primaria compuesta

Integridad de los datos

Deshabilitar restricciones (with

Restriccin primary key

Eliminar restricciones (alter

Crear y asociar reglas (create

Eliminar y dasasociar reglas

Informacin de reglas (sp_help

Desasociar y eliminar valores

Trabajar con varias tablas

Combinacin interna (inner

Combinacin externa izquierda

Combinacin externa derecha

Combinacin externa completa

Combinaciones cruzadas (cross

Combinaciones con update y

Restricciones (foreign key)

Restricciones foreign key en la

Restricciones foreign key

Restricciones foreign key

Restricciones foreign key

Restricciones al crear la tabla

Agregar y eliminar campos

Alterar campos (alter table alter)

Agregar campos y restricciones

Tipo de dato definido por el

Tipo de dato definido por el

Tipo de dato definido por el

Tipo de dato definido por el

Subconsultas como expresin