Curso SQL

1 - Objetivos y alcances del tutorial de Microsoft Sql
Server
El curso brinda un concepto teórico corto, luego un problema resuelto que invito a
ejecutar, modificar y jugar con el mismo. Por último, y lo más 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 creación de tablas, insert, delete, update, definición de
índices y restricciones, creación y ejecución de procedimientos almacenados, vistas,
subconsultas, creación de trigger etc.
La única restricción 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 información 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 intersección de una
columna con una fila, contiene un dato específico, 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
información que almacenará.
Cada campo (columna) también 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 parámetro @table_owner='dbo' indica que solo muestre las tablas de usuarios y no

las que crea el SQL Server para administración interna.
Finalizamos cada comando con un punto y coma.
Al crear una tabla debemos resolver qué campos (columnas) tendrá y qué tipo de datos
almacenarán cada uno de ellos, es decir, su estructura.
La sintaxis básica 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 paréntesis 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 carácter permitido para nombres de
directorios, el primero debe ser un carácter alfabético y no puede contener espacios. La
longitud máxima 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 información 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 situación y la sentencia no se ejecuta. Para evitar este mensaje podemos agregar a la
instrucción lo siguiente:
if object_id('usuarios') is not null

En la sentencia precedente especificamos que elimine la tabla "usuarios" si existe.
Ejercicio
Necesita almacenar los datos de sus amigos en una tabla. Los datos que
guardará serán: apellido,nombre, domicilio y teléfono.
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 inválido ("/")
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(apellido varchar(30), nombre varchar(20),

domicilio varchar(30), telefono varchar(11));
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.
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 básica 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 paréntesis y separados por comas y luego de la cláusula "values"
colocamos los valores para cada campo, también entre paréntesis 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 también 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');

Ejercicio
Trabaje con la tabla "agenda" que almacena información de sus amigos.

1- Elimine la tabla "agenda", si existe:
drop table agenda;
2- Cree una tabla llamada "agenda". Debe tener los siguientes campos:
apellido(cadena de 30), nombre(cadena de 20), domicilio(cadena de 30)
y telefono (cadena de 11).
3- Visualice las tablas existentes para verificar la creación de

"agenda"
(sp_tables @table_owner='dbo').
4- Visualice la estructura de la tabla "agenda" (sp_columns).
5- Ingrese los siguientes registros:

insert into agenda (apellido, nombre, domicilio, telefono)
values ('Moreno','Alberto','Colon 123','4234567');
insert into agenda (apellido,nombre, domicilio, telefono)
values ('Torres','Juan','Avellaneda 135','4458787');
6- Seleccione todos los registros de la tabla:

select * from agenda;
7- Elimine la tabla "agenda":

drop table agenda;
8- Intente eliminar la tabla nuevamente (aparece un mensaje de error):

drop table agenda;
4 - Tipos de datos básicos

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

caracteres, números, etc.
Estos son algunos tipos de datos básicos 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 máximo de caracteres entre paréntesis. Puede guardar hasta
8000 caracteres. Por ejemplo, para almacenar cadenas de hasta 30 caracteres,
definimos un campo de tipo varchar(30), es decir, entre paréntesis, 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 situación 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 numéricos enteros, de -2000000000 a

2000000000 aprox. Definimos campos de este tipo cuando queremos
representar, por ejemplo, cantidades.
 float: se usa para almacenar valores numéricos 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 números enteros, el tipo "float" sería una
mala elección; si vamos a guardar precios, el tipo "float" es más adecuado, no así
"integer" que no tiene decimales. Otro ejemplo, si en un campo vamos a guardar un
número telefónico o un número de documento, usamos "varchar", no "integer" porque si
bien son dígitos, con ellos no realizamos operaciones matemáticas.
Ejercicio-1:
Un videoclub que alquila películas en video almacena la información de

sus películas en una tabla llamada "peliculas"; para cada película
necesita los siguientes datos:
-nombre, cadena de caracteres de 20 de longitud,
-actor, cadena de caracteres de 20 de longitud,
-duración, valor numérico 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:

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

Ejercicio-2
Vamos a crear una tabla llamada "libros". En primer lugar vamos a eliminar la tabla
"libros" averiguando si existe:
if object_id('libros') is not null

drop table libros;
Para almacenar información de los libros de una librería 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 numérico con decimales y
-cantidad, valor numérico entero.
Al crear la tabla, entonces, elegimos el tipo de dato más adecuado para cada campo:
create table libros(

titulo varchar(20),
autor varchar(15),
editorial varchar(10),
precio float,
cantidad integer
);
Note que al especificar el tipo de dato de los campos numéricos, no colocamos entre
paréntesis la longitud.
Vemos la estructura de la tabla:
sp_columns libros;
Aparece la siguiente información:
...COLUMN_NAME TYPE_NAME 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 numéricos (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 más
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: select * from libros;
5 - Recuperar algunos campos (select)

Hemos aprendido cómo ver todos los registros de una tabla, empleando la instrucción
"select".
La sintaxis básica y general es la siguiente: 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 separándolos 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 según la
lista de selección, en dicha lista los nombres de los campos se separan con comas.
Ejercicio-1
Un videoclub que alquila películas en video almacena la información de

sus películas en alquiler en una tabla llamada "peliculas".

if object_id('peliculas') is not null
2- Cree la tabla:
create table peliculas(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)
values ('Mision imposible','Tom Cruise',180,3);
values ('Mision imposible 2','Tom Cruise',190,2);
values ('Mujer bonita','Julia Roberts',118,3);
values ('Elsa y Fred','China Zorrilla',110,2);
5- Realice un "select" mostrando solamente el título y actor de todas

las películas
6- Muestre el título y duración de todas las peliculas
7- Muestre el título y la cantidad de copias
Ejercicio-2
Trabajamos con la tabla "libros" que almacena los datos de los libros de una librería.
Eliminamos la tabla, si existe:

drop table libros;
Creamos la tabla:
create table libros(titulo varchar(40), autor varchar(30),

editorial varchar(15), precio float, cantidad integer );
Veamos la estructura de la tabla: sp_columns libros;

values ('El aleph','Borges','Emece',25.50,100);
values ('Alicia en el pais de las maravillas','Lewis
Carroll','Atlantida',10,200);
values ('Matematica estas ahi','Paenza','Siglo XXI',18.8,200);
Veamos todos los campos la tabla: select *from libros;
Veamos solamente el título, 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 títulos 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;

6 - Recuperar algunos registros (where)
Hemos aprendido a seleccionar algunos campos de una tabla. También es posible
recuperar algunos registros. Existe una cláusula, "where" con la cual podemos
especificar condiciones para una consulta "select". Es decir, podemos recuperar algunos
registros, sólo los que cumplan con ciertas condiciones indicadas con la cláusula
"where". Por ejemplo, queremos ver el usuario cuyo nombre es "Marcelo", para ello
utilizamos "where" y luego de ella, la condición:
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 más

adelante en detalle). El signo igual(=) es un operador relacional. Para la siguiente
selección de registros especificamos una condición que solicita los usuarios cuya clave
es igual a "River":
select nombre,clave from usuarios where clave='River';
Si ningún registro cumple la condición establecida con el "where", no aparecerá ningún

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 cláusula "where":
select nombre from usuarios where clave='River';
En la consulta anterior solicitamos el nombre de todos los usuarios cuya clave sea igual
a "River".
Ejercicio-1
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 teléfono "4545454" (2

registros)
Ejercicio-2
Trabajamos con la tabla "usuarios" que consta de 2 campos: nombre de usuario y clave.

Creamos la tabla:
create table usuarios (nombre varchar(30),clave varchar(10) );
Vemos la estructura de la tabla:
sp_columns usuarios;
insert into usuarios (nombre, clave) values ('Marcelo','Boca');

insert into usuarios (nombre, clave) values ('JuanPerez','Juancito');
insert into usuarios (nombre, clave) values ('Susana','River');
insert into usuarios (nombre, clave) values ('Luis','River');
Realizamos una consulta especificando una condición, 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 where clave='River';
Realizamos un "select" de los nombres de los usuarios cuya clave es "Santi":
select nombre from usuarios where clave='Santi';

7 - Operadores relacionales
Los operadores son símbolos que permiten realizar operaciones matemáticas,
concatenar cadenas, hacer comparaciones.
SQL Server tiene 4 tipos de operadores:
1. relacionales (o de comparación)
2. aritméticos
3. de concatenación
4. lógicos.
Por ahora veremos solamente los primeros.
Los operadores relacionales (o de comparación) 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 condición: select * from libros where autor<>'Borges';
Podemos comparar valores numéricos. Por ejemplo, queremos mostrar los títulos 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 condición. No son los únicos, existen otros que
veremos más adelante.
Ejercicio-1
Un comercio que vende artículos de computación registra los datos de

sus artículos 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).
4- Ingrese algunos registros:

insert into articulos (codigo, nombre, descripcion, precio,cantidad)
values (1,'impresora','Epson Stylus C45',400.80,20);
values (2,'impresora','Epson Stylus C85',500,30);
values (3,'monitor','Samsung 14',800,10);
values (4,'teclado','ingles Biswal',100,50);
values (5,'teclado','español Biswal',90,50);
5- Seleccione los datos de las impresoras (2 registros)
6- Seleccione los artículos cuyo precio sea mayor o igual a 400 (3

registros)
7- Seleccione el código y nombre de los artículos cuya cantidad sea

menor a 30 (2 registros)
8- Selecciones el nombre y descripción de los artículos que NO cuesten

$100 (4 registros)
Ejercicio-2
Trabajamos con la tabla "libros" de una librería.
Eliminamos la tabla "libros", si existe:

drop table libros;
La creamos con la siguiente estructura:
create table libros(titulo varchar(30), autor varchar(30),

editorial varchar(15), 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 where autor<>'Borges';
Seleccionamos los registros cuyo precio supere los 20 pesos, sólo el título y precio:
select titulo,precio from libros where precio>20;
Note que el valor con el cual comparamos el campo "precio", como es numérico (float),
no se coloca entre comillas. Los libros cuyo precio es menor o igual a 20 pesos no
aparece en la selección.
Recuperamos aquellos libros cuyo precio es menor o igual a 30:
select *from libros where precio<=30;
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
cuál o cuáles, para ello utilizamos el comando "delete" junto con la clausula "where"
con la cual establecemos la condición que deben cumplir los registros a borrar.
Por ejemplo, queremos eliminar aquel registro cuyo nombre de usuario es "Marcelo":
delete from usuarios where nombre='Marcelo';
Si solicitamos el borrado de un registro que no existe, es decir, ningún registro cumple

con la condición especificada, ningún registro será eliminado. Tenga en cuenta que si no
colocamos una condición, se eliminan todos los registros de la tabla nombrada.
Ejercicio-1
Trabaje con la tabla "agenda" que registra la información 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):
create table agenda( apellido varchar(30), 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 número telefónico sea igual a "4545454"

(2 registros afectados):
6- Muestre la tabla.
7- Elimine todos los registros (2 registros afectados):
8- Muestre la tabla.
Ejercicio-2
Trabajamos con la tabla "usuarios".
Eliminamos la tabla "usuarios", si existe:

La creamos con la siguiente estructura:
create table usuarios(nombre varchar(30),clave varchar(10) );
Agregamos registros a la tabla:
insert into usuarios (nombre,clave) values ('Marcelo','River');

insert into usuarios (nombre,clave) values ('Susana','chapita');
insert into usuarios (nombre,clave) values ('CarlosFuentes','Boca');
insert into usuarios (nombre,clave) values ('FedericoLopez','Boca');
Seleccionamos todos los registros: select *from usuarios;
Vamos a eliminar el registro cuyo nombre de usuario es "Marcelo":
delete from usuarios where nombre='Marcelo';
Veamos el contenido de la tabla: select * from usuarios;

Intentamos eliminarlo nuevamente: delete from usuarios where
nombre='Marcelo';
Como ningún registro cumple con la condición no se borran registros.
Eliminamos todos los registros cuya clave es 'Boca':
delete from usuarios where clave='Boca';
Eliminemos todos los registros: delete from usuarios;
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 selección con "where".
Por ejemplo, queremos cambiar el valor correspondiente a la clave de nuestro usuario
llamado "Federicolopez", queremos como nueva clave "Boca", necesitamos una
condición "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 condición del
"where", no se modifica ninguno. Las condiciones no son obligatorias, pero si omitimos
la cláusula "where", la actualización afectará a todos los registros. También podemos
actualizar varios campos en una sola instrucción:
update usuarios set nombre='Marceloduarte', clave='Marce'

where nombre='Marcelo';
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.
Ejercicio-1
Trabaje con la tabla "agenda" que almacena los datos de sus amigos.

drop table agenda;
2- Cree la tabla:
create table agenda(apellido varchar(30),nombre varchar(20),
3- Ingrese los siguientes registros (1 registro actualizado):

insert into agenda (apellido,nombre,domicilio,telefono)
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 número telefónico 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" (ningún registro afectado porque ninguno cumple
con la condición del "where")
7 - Luego de cada actualización ejecute un select que muestre todos

los registros de la tabla.
Ejercicio-2
Trabaje con la tabla "libros" de una librería.

drop table libros;
2- Créela con los siguientes campos:titulo(cadena de 30 caracteres de

longitud),autor(cadena de 20),editorial(cadena de 15) y precio float):
create table libros ( titulo varchar(30), autor varchar(20),
editorial varchar(15), precio float );

insert into libros (titulo, autor, editorial, precio)
values ('El aleph','Borges','Emece',25.00);
values ('Martin Fierro','Jose Hernandez','Planeta',35.50);
values ('Aprenda PHP','Mario Molina','Emece',45.50);
values ('Cervantes y el quijote','Borges','Emece',25);
values ('Matematica estas ahi','Paenza','Siglo XXI',15);
4- Muestre todos los registros (5 registros): select *from libros;
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" (ningún registro afectado porque ninguno
cumple la condición)
update libros set autor='Adrian Paenza' where autor='Paenza';
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.' where editorial='Emece';
9 - Luego de cada actualización ejecute un select que mustre todos los

registros de la tabla.
10 - Comentarios
Para aclarar algunas instrucciones, en ocasiones, necesitamos agregar comentarios.
Es posible ingresar comentarios en la línea de comandos, es decir, un texto que no se
ejecuta; para ello se emplean dos guiones (--) al comienzo de la línea:
select * from libros --mostramos los registros de libros;
en la línea anterior, todo lo que está luego de los guiones (hacia la derecha) no se
ejecuta. Para agregar varias líneas 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 títulos y nombres de los autores*/

from libros;
todo lo que está entre los símbolos "/*" y "*/" no se ejecuta.
Ejercicio-1

drop table libros;
Creamos la tabla: create table libros(titulo varchar(30), autor

varchar(20), editorial varchar(15));
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 título y autor de todos los libros y agregamos un bloque de

comentarios:
select titulo, autor /*mostramos títulos y nombres de los autores*/

from libros;
Note que lo que está entre los símbolos 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 vacía o una cadena literal "null". A veces, puede desconocerse o no
existir el dato correspondiente a algún 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 contraposición, tenemos campos que no pueden estar vacíos jamás. Veamos un

ejemplo. Tenemos nuestra tabla "libros". El campo "titulo" no debería estar vacío nunca,
igualmente el campo "autor". Para ello, al crear la tabla, debemos especificar que dichos
campos no admitan valores nulos:
create table libros(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 definición 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 aún 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. También 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 inserción no se
realiza; por ejemplo:

values(null,'Borges','Siglo XXI',25);
Para ver cuáles campos admiten valores nulos y cuáles no, podemos emplear el
procedimiento almacenado "sp_columns" junto al nombre de la tabla. Nos muestra
mucha información, 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 algún 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):
select * from libros where precio is null;
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.
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 vacía.
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".
Primer problema:
Una farmacia guarda información 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);
insert into medicamentos (codigo,nombre,laboratorio,precio,cantidad)
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 vacía

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 código y cantidad y

cadena vacía para el nombre:
values(0,'','Bayer',15.60,0);
8- Muestre todos los registros: select *from medicamentos;
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 vacía 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

vacía, luego los que sean distintos de "null".
Note que la salida de la primera sentencia no muestra los registros
con cadenas vacías y tampoco los que tienen valor nulo; el resultado
de la segunda sentencia muestra los registros con valor para el
campo laboratorio (incluso cadena vacía).
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).
Segundo problema:
Trabaje con la tabla que almacena los datos sobre películas, llamada
"peliculas".
2- Créela con la siguiente estructura:

create table peliculas(codigo int not null,
titulo varchar(40) not null, actor varchar(20), duracion int);
3- Visualice la estructura de la tabla: sp_columns peliculas;
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 cómo SQL Server los almacenó:
select *from peliculas;
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 vacía (note que la salida es distinta)
(1 registro)
8- Modifique los registros que tengan valor de duración desconocido

(nulo) por "120" (1 registro actualizado)
9- Coloque 'Desconocido' en el campo "actor" en los registros que

tengan una cadena vacía 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 título sea una cadena vacía(1 registro)
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 número 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 más sencilla.
Tenemos nuestra tabla "usuarios" definida con 2 campos ("nombre" y "clave").

create table NOMBRETABL( 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:
create table usuarios(nombre varchar(20),clave varchar(10),

primary key(nombre));
Lo que hacemos agregar luego de la definición de cada campo, "primary key" y entre
paréntesis, el nombre del campo que será clave primaria. Una tabla sólo 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, automáticamente 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
estén repetidos en la tabla; si estuviesen repetidos, muestra un mensaje y la inserción 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 instrucción "insert" no se ejecuta.
Igualmente, si realizamos una actualización, SQL Server controla que los valores para el
campo establecido como clave primaria no estén repetidos en la tabla, si lo estuviese,
aparece un mensaje indicando que se viola la clave primaria y la actualización no se
realiza.
Primer problema:
drop table libros;
2- Créela con los siguientes campos, estableciendo como clave primaria

el campo "codigo":
create table libros(codigo int not null, titulo varchar(40) not null,
autor varchar(20), editorial varchar(15), 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 código repetido (aparece un mensaje de
error)
5- Intente ingresar el valor "null" en el campo "codigo"
6- Intente actualizar el código del libro "Martin Fierro" a "1"

(mensaje de error)
Segundo problema:
Un instituto de enseñanza 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,documento varchar(8),
nombre varchar(30), domicilio varchar(30),primary key(documento),
primary key(legajo));
3- Cree la tabla estableciendo como clave primaria el campo

"documento":
create table alumnos(legajo varchar(4) not null,documento varchar(8),
nombre varchar(30), domicilio 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 (legajo,documento,nombre,domicilio)
values('A567','23545345','Morales Marcos','Avellaneda 348');
6- Intente ingresar un alumno con número de documento existente (no lo

permite)
7- Intente ingresar un alumno con documento nulo (no lo permite)
13 - Campo con atributo Identity

Un campo numérico puede tener un atributo extra "identity". Los valores de un campo
con este atributo generan valores secuenciales que se inician en 1 y se incrementan en 1
automáticamente. Se utiliza generalmente en campos correspondientes a códigos de
identificación para generar valores únicos para cada nuevo registro que se inserta. Sólo
puede haber un campo "identity" por tabla.
Para que un campo pueda establecerse como "identity", éste debe ser entero (también
puede ser de un subtipo de entero o decimal con escala 0, tipos que estudiaremos
posteriormente). Para que un campo genere sus valores automáticamente, debemos
agregar el atributo "identity" luego de su definición al crear la tabla:
create table libros(codigo int identity, titulo varchar(40) not null,
autor varchar(30), editorial varchar(15), precio float);
Cuando un campo tiene el atributo "identity" no se puede ingresar valor para él, porque
se inserta automáticamente tomando el último valor como referencia, o 1 si es el
primero. Para ingresar registros omitimos el campo definido como "identity", por
ejemplo:
values ('El aleph','Borges','Emece',23);
Este primer registro ingresado guardará el valor 1 en el campo correspondiente al

código.
Si continuamos ingresando registros, el código (dato que no ingresamos) se cargará

automáticamente siguiendo la secuencia de autoincremento.
No está permitido ingresar el valor correspondiente al campo "identity", por ejemplo:
insert into libros (codigo,titulo,autor,editorial,precio)

values(5,'Martin Fierro','Jose Hernandez','Paidos',25);
generará un mensaje de error.
"identity" permite indicar el valor de inicio de la secuencia y el incremento, pero lo

veremos posteriormente.
Un campo definido como "identity" generalmente se establece como clave primaria.
Un campo "identity" no es editable, es decir, no se puede ingresar un valor ni

actualizarlo.
Un campo de identidad no permite valores nulos, aunque no se indique especificamente.

Si ejecutamos el procedimiento "sp_columns()" veremos que en el campo "codigo" en
la columna "TYPE_NAME" aparece "int identity" y en la columna "IS_NULLABLE"
aparece "NO".
Los valores secuenciales de un campo "identity" se generan tomando como referencia el

último valor ingresado; si se elimina el último registro ingresado (por ejemplo 3) y
luego se inserta otro registro, SQL Server seguirá la secuencia, es decir, colocará el
valor "4".
Primer problema:
1- Elimine la tabla,si existe:
2- Cree la tabla con un campo "codigo" que genere valores secuenciales

automáticamente:
create table medicamentos(codigo int identity,nombre varchar(20) not
null, laboratorio varchar(20),precio float, cantidad integer);
3- Visualice la estructura de la tabla "medicamentos":
sp_columns medicamentos;

insert into medicamentos (nombre, laboratorio,precio,cantidad)
values('Sertal','Roche',5.2,100);
values('Buscapina','Roche',4.10,200);
values('Amoxidal 500','Bayer',15.60,100);
5- Verifique que SQL Server generó valores para el campo "código" de

modo automático:
select *from medicamentos;
6- Intente ingresar un registro con un valor para el campo "codigo"
7- Intente actualizar un valor de código (aparece un mensaje de error)
8- Elimine el registro con codigo "3" (1 registro eliminado)
9- Ingrese un nuevo registro:

values('Amoxilina 500','Bayer',15.60,100);
10- Seleccione todos los registros para ver qué valor guardó SQL
Server en el campo código: select *from medicamentos;
Segundo problema:
Un videoclub almacena información sobre sus películas en una tabla
llamada "peliculas".
2- Créela definiendo un campo "codigo" autoincrementable y como clave

primaria:
create table peliculas(codigo int identity,titulo varchar(40),
actor varchar(20), duracion int, primary key(codigo));
3- Ejecute el procedimiento almacenado para visualizar la estructura

de la tabla: sp_columns peliculas;

insert into peliculas (titulo,actor,duracion)
values('Mision imposible','Tom Cruise',120);
values('Harry Potter y la piedra filosofal','Daniel R.',180);
values('Harry Potter y la camara secreta','Daniel R.',190);
values('Mision imposible 2','Tom Cruise',120);
values('La vida es bella','zzz',220);
5- Seleccione todos los registros y verifique la carga automática de

los códigos: select *from peliculas;
6- Intente actualizar el codigo de una película (aparece un mensaje de

error)
7- Elimine la película "La vida es bella".
8- Ingrese un nuevo registro.
9- Visualice los registros para ver el valor almacenado en codigo

(valor 7): select *from peliculas;
14 - Otras características del atributo Identity

El atributo "identity" permite indicar el valor de inicio de la secuencia y el incremento,
para ello usamos la siguiente sintaxis:
create table libros(codigo int identity(100,2), titulo varchar(20),

autor varchar(30), precio float );
Los valores comenzarán en "100" y se incrementarán de 2 en 2; es decir, el primer

registro ingresado tendrá el valor "100", los siguientes "102", "104", "106", etc.
La función "ident_seed()" retorna el valor de inicio del campo "identity" de la tabla que
nombramos: select ident_seed('libros');
La función "ident_incr()" retorna el valor de incremento del campo "identity" de la tabla

nombrada: select ident_incr('libros');
Hemos visto que en un campo declarado "identity" no puede ingresarse explícitamente

un valor. Para permitir ingresar un valor en un campo de identidad se debe activar la
opción "identity_insert": set identity_insert libros on;
Es decir, podemos ingresar valor en un campo "identity" seteando la opción

"identity_insert" en "on". Cuando "identity_insert" está en ON, las instrucciones "insert"
deben explicitar un valor:
insert into libros (codigo,titulo)

values (5,'Alicia en el pais de las maravillas');
Si no se coloca un valor para el campo de identidad, la sentencia no se ejecuta y aparece

un mensaje de error:
insert into libros (titulo,autor, editorial)

values ('Matematica estas ahi','Paenza','Paidos');
El atributo "identity" no implica unicidad, es decir, permite repetición de valores; por

ello hay que tener cuidado al explicitar un valor porque se puede ingresar un valor
repetido.
Para desactivar la opción "identity_insert" tipeamos:
set identity_insert libros off;
Primer problema:
1- Elimine la tabla,si existe:
2- Cree la tabla con un campo "codigo" que genere valores secuenciales

automáticamente comenzando en 10 e incrementándose en 1:
create table medicamentos(codigo integer identity(10,1),

nombre varchar(20) not null, laboratorio varchar(20), precio float,
cantidad integer);

values('Sertal','Roche',5.2,100);
values('Buscapina','Roche',4.10,200);
values('Amoxidal 500','Bayer',15.60,100);
4- Verifique que SQL Server generó valores para el campo "código" de

modo automático:
select *from medicamentos;
5- Intente ingresar un registro con un valor para el campo "codigo".
6- Setee la opción "identity_insert" en "on"
7- Ingrese un nuevo registro sin valor para el campo "codigo" (no lo

permite):
values('Amoxilina 500','Bayer',15.60,100);
8- Ingrese un nuevo registro con valor para el campo "codigo"

repetido.
9- Use la función "ident_seed()" para averiguar el valor de inicio del

campo "identity" de la tabla "medicamentos"
10- Emplee la función "ident_incr()" para saber cuál es el valor de

incremento del campo "identity"
de "medicamentos"
Segundo problema:
Un videoclub almacena información sobre sus películas en una tabla
llamada "peliculas".

2- Créela definiendo un campo "codigo" autoincrementable que comience

en 50 y se incremente en 3:
create table peliculas(codigo int identity (50,3),titulo varchar(40),
actor varchar(20), duracion int);

values('Mision imposible','Tom Cruise',120);
4- Seleccione todos los registros y verifique la carga automática de

los códigos:
select *from peliculas;
5- Setee la opción "identity_insert" en "on"
6- Ingrese un registro con valor de código menor a 50.
7- Ingrese un registro con valor de código mayor al último generado.
8- Averigue el valor de inicio del campo "identity" de la tabla

"peliculas".
9- Averigue el valor de incremento del campo "identity" de

"peliculas".
10- Intente ingresar un registro sin valor para el campo código.
11- Desactive la opción se inserción para el campo de identidad.
12- Ingrese un nuevo registro y muestre todos los registros para ver
cómo SQL Server siguió la secuencia tomando el último valor del campo
como referencia.
15 - Truncate table
Aprendimos que para borrar todos los registro de una tabla se usa "delete" sin condición
"where". También podemos eliminar todos los registros de una tabla con "truncate
table". Por ejemplo, queremos vaciar la tabla "libros", usamos:
truncate table libros;
La sentencia "truncate table" vacía la tabla (elimina todos los registros) y conserva la
estructura de la tabla. La diferencia con "drop table" es que esta sentencia borra la tabla,
"truncate table" la vacía. La diferencia con "delete" es la velocidad, es más rápido
"truncate table" que "delete" (se nota cuando la cantidad de registros es muy grande) ya
que éste borra los registros uno a uno.
Otra diferencia es la siguiente: cuando la tabla tiene un campo "identity", si borramos

todos los registros con "delete" y luego ingresamos un registro, al cargarse el valor en el
campo de identidad, continúa con la secuencia teniendo en cuenta el valor mayor que se
había guardado; si usamos "truncate table" para borrar todos los registros, al ingresar
otra vez un registro, la secuencia del campo de identidad vuelve a iniciarse en 1.
Por ejemplo, tenemos la tabla "libros" con el campo "codigo" definido "identity", y el
valor más alto de ese campo es "2", si borramos todos los registros con "delete" y luego
ingresamos un registro, éste guardará el valor de código "3"; si en cambio, vaciamos la
tabla con "truncate table", al ingresar un nuevo registro el valor del código se iniciará en
1 nuevamente.
Primer problema:
Un instituto de enseñanza almacena los datos de sus estudiantes en una
tabla llamada "alumnos".
1- Elimine la tabla "alumnos" si existe:
drop table alumnos;

create table alumnos(legajo int identity, documento varchar(8),
nombre varchar(30), domicilio varchar(30));
3- Ingrese los siguientes registros y muéstrelos para ver la secuencia

de códigos:
insert into alumnos (documento,nombre,domicilio)
values('22345345','Perez Mariana','Colon 234');
values('23545345','Morales Marcos','Avellaneda 348');
values('24356345','Gonzalez Analia','Caseros 444');
values('25666777','Torres Ramiro','Dinamarca 209');
4- Elimine todos los registros con "delete".
5- Ingrese los siguientes registros y selecciónelos para ver cómo SQL

Server generó los códigos:
select *from alumnos;
6- Elimine todos los registros con "truncate table".
7- Ingrese los siguientes registros y muestre todos los registros para

ver que SQL Server reinició
la secuencia del campo "identity":
select *from alumnos;
Segundo problema:
1- Elimine "articulos", si existe:
if object_id('articulos') is not null
2- Cree la tabla, con la siguiente estructura:
create table articulos(codigo integer identity,nombre varchar(20),
descripcion varchar(30), precio float );

insert into articulos (nombre, descripcion, precio)
values ('impresora','Epson Stylus C45',400.80);
values ('impresora','Epson Stylus C85',500);
4- Elimine todos los registros con "truncate table".
5- Ingrese algunos registros y muéstrelos para ver que la secuencia de

códigos se reinicia:
values ('monitor','Samsung 14',800);
values ('teclado','ingles Biswal',100);
values ('teclado','español Biswal',90);
select *from articulos;
6- Elimine todos los registros con "delete".
7- Ingrese algunos registros y muéstrelos para ver que la secuencia de

códigos continua:
values ('teclado','ingles Biswal',100);
values ('teclado','español Biswal',90);
select *from articulos;
16 - Otros tipos de datos en SQL Server

Ya explicamos que al crear una tabla debemos elegir la estructura adecuada, esto es,
definir los campos y sus tipos más precisos, según el caso. El tipo de dato especificado
en la definición de cada campo indica los valores permitidos para cada uno de ellos.
Hasta ahora hemos visto 3 tipos de datos: varchar, integer y float. Hay más tipos,
incluso, subtipos.
Los valores que podemos guardar son:
1. TEXTO: Para almacenar texto usamos cadenas de caracteres.

Las cadenas se colocan entre comillas simples. Podemos almacenar letras,
símbolos y dígitos con los que no se realizan operaciones matemáticas, por
ejemplo, códigos de identificación, números de documentos, números
telefónicos.
SQL Server ofrece los siguientes tipos: char, nchar, varchar, nvarchar, text y
ntext.
2. NUMEROS: Existe variedad de tipos numéricos para representar enteros,
decimales, monedas. Para almacenar valores enteros, por ejemplo, en campos
que hacen referencia a cantidades, precios, etc., usamos el tipo integer (y sus
subtipos: tinyint, smallint y bigint). Para almacenar valores con decimales
exactos, utilizamos: numeric o decimal (son equivalentes). Para guardar valores
decimales aproximados: float y real. Para almacenar valores monetarios: money
y smallmoney.
3. FECHAS y HORAS: para guardar fechas y horas SQL Server dispone de 2
tipos: datetime y smalldatetime.
Existen otros tipos de datos que analizaremos en secciones próximas.
Entonces, cuando creamos una tabla y definir sus campos debemos elegir el tipo de dato
más preciso. Por ejemplo, si necesitamos almacenar nombres usamos texto; si un campo
numérico almacenará solamente valores enteros el tipo "integer" es más adecuado que,
por ejemplo un "float"; si necesitamos almacenar precios, lo más lógico es utilizar el
tipo "money".
A continuación analizaremos en detalle cada tipo de datos básicos.
17 - Tipo de dato (texto)

definir los campos y sus tipos más precisos, según el caso.Para almacenar TEXTO
usamos cadenas de caracteres. Las cadenas se colocan entre comillas simples.
Podemos almacenar letras, símbolos y dígitos con los que no se realizan operaciones
matemáticas, por ejemplo, códigos de identificación, números de documentos, números
telefónicos.
Tenemos los siguientes tipos:
1. varchar(x): define una cadena de caracteres de longitud variable en la cual

determinamos el máximo de caracteres con el argumento "x" que va entre
paréntesis.
Si se omite el argumento coloca 1 por defecto. Su rango va de 1 a 8000
caracteres.
2. char(x): define una cadena de longitud fija determinada por el argumento "x". Si
se omite el argumento coloca 1 por defecto. Su rango es de 1 a 8000 caracteres.
Si la longitud es invariable, es conveniente utilizar el tipo char; caso contrario, el

tipo varchar. Ocupa tantos bytes como se definen con el argumento "x".
"char" viene de character, que significa caracter en inglés.
3. text: guarda datos binarios de longitud variable, puede contener hasta

2000000000 caracteres. No admite argumento para especificar su longitud.
4. nvarchar(x): es similar a "varchar", excepto que permite almacenar caracteres
Unicode, su rango va de 0 a 4000 caracteres porque se emplean 2 bytes por cada
caracter.
5. nchar(x): es similar a "char" excpeto que acepta caracteres Unicode, su rango
va de 0 a 4000 caracteres porque se emplean 2 bytes por cada caracter.
6. ntext: es similar a "text" excepto que permite almacenar caracteres Unicode,
puede contener hasta 1000000000 caracteres. No admite argumento para
especificar su longitud.
En general se usarán los 3 primeros.
Si intentamos almacenar en un campo una cadena de caracteres de mayor longitud que

la definida, aparece un mensaje indicando tal situación y la sentencia no se ejecuta.
Por ejemplo, si definimos un campo de tipo varchar(10) y le asignamos la cadena

'Aprenda PHP' (11 caracteres), aparece un mensaje y la sentencia no se ejecuta.
Si ingresamos un valor numérico (omitiendo las comillas), lo convierte a cadena y lo

ingresa como tal.
Por ejemplo, si en un campo definido como varchar(5) ingresamos el valor 12345, lo

toma como si hubiésemos tipeado '12345', igualmente, si ingresamos el valor 23.56, lo
convierte a '23.56'. Si el valor numérico, al ser convertido a cadena supera la longitud
definida, aparece un mensaje de error y la sentencia no se ejecuta.
Es importante elegir el tipo de dato adecuado según el caso, el más preciso.
Para almacenar cadenas que varían en su longitud, es decir, no todos los registros
tendrán la misma longitud en un campo determinado, se emplea "varchar" en lugar de
"char".
Por ejemplo, en campos que guardamos nombres y apellidos, no todos los nombres y
apellidos tienen la misma longitud.
Para almacenar cadenas que no varían en su longitud, es decir, todos los registros
tendrán la misma longitud en un campo determinado, se emplea "char".
Por ejemplo, definimos un campo "codigo" que constará de 5 caracteres, todos los
registros tendrán un código de 5 caracteres, ni más ni menos.
Para almacenar valores superiores a 8000 caracteres se debe emplear "text".
Tipo Bytes de almacenamiento

_______________________________________
varchar(x) 0 a 8K
char(x) 0 a 8K
text 0 a 2GB
nvarchar(x) 0 a 8K
nchar(x) 0 a 8K
ntext 0 a 2GB
Primer problema:
Una concesionaria de autos vende autos usados y almacena los datos de
los autos en una tabla llamada "autos".
1- Elimine la tabla "autos" si existe:
if object_id('autos') is not null
drop table autos;
2- Cree la tabla eligiendo el tipo de dato adecuado para cada campo,
estableciendo el campo "patente" como clave primaria:
create table autos(patente char(6), marca varchar(20),modelo char(4),
precio float, primary key (patente));
Hemos definido el campo "patente" de tipo "char" y no "varchar" porque

la cadena de caracteres siempre tendrá la misma longitud (6
caracteres). Lo mismo sucede con el campo "modelo", en el cual
almacenaremos el año, necesitamos 4 caracteres fijos.

insert into autos values('ACD123','Fiat 128','1970',15000);
insert into autos values('ACG234','Renault 11','1990',40000);
insert into autos values('BCD333','Peugeot 505','1990',80000);
insert into autos values('GCD123','Renault Clio','1990',70000);
insert into autos values('BCC333','Renault Megane','1998',95000);
insert into autos values('BVF543','Fiat 128','1975',20000);
4- Seleccione todos los autos del año 1990:

select *from autos where modelo='1990';
Segundo problema:
Una empresa almacena los datos de sus clientes en una tabla llamada
"clientes".
1- Elimine la tabla "clientes" si existe:
if object_id('clientes') is not null
drop table clientes;
2- Créela eligiendo el tipo de dato más adecuado para cada campo:

create table clientes( documento char(8), apellido varchar(20),
nombre varchar(20), domicilio varchar(30), telefono varchar (11));
3- Analice la definición de los campos. Se utiliza char(8) para el

documento porque siempre constará de 8 caracteres. Para el número
telefónico se usar "varchar" y no un tipo numérico porque si bien es
un número, con él no se realizarán operaciones matemáticas.

insert into clientes
values('2233344','Perez','Juan','Sarmiento 980','4342345');
insert into clientes (documento,apellido,nombre,domicilio)
values('2333344','Perez','Ana','Colon 234');
values('2433344','Garcia','Luis','Avellaneda 1454','4558877');
values('2533344','Juarez','Ana','Urquiza 444','4789900');
5- Seleccione todos los clientes de apellido "Perez" (2 registros):

select *from clientes where apellido='Perez';
18 - Tipo de dato (numérico)

definir los campos y sus tipos más precisos, según el caso. Para almacenar valores
NUMERICOS SQL Server dispone de varios tipos. Para almacenar valores ENTEROS,
por ejemplo, en campos que hacen referencia a cantidades, usamos:
1) integer o int: su rango es de -2000000000 a 2000000000 aprox. El tipo
"integer" tiene subtipos:
- smallint: Puede contener hasta 5 digitos. Su rango va desde –32000 hasta
32000 aprox.
- tinyint: Puede almacenar valores entre 0 y 255.
- bigint: De –9000000000000000000 hasta 9000000000000000000 aprox.
Para almacenar valores numéricos EXACTOS con decimales, especificando la cantidad

de cifras a la izquierda y derecha del separador decimal, utilizamos:
2) decimal o numeric (t,d): Pueden tener hasta 38 digitos, guarda un valor exacto. El
primer argumento indica el total de dígitos y el segundo, la cantidad de decimales.
Por ejemplo, si queremos almacenar valores entre -99.99 y 99.99 debemos definir el
campo como tipo "decimal(4,2)". Si no se indica el valor del segundo argumento, por
defecto es "0". Por ejemplo, si definimos "decimal(4)" se pueden guardar valores entre
-9999 y 9999.
El rango depende de los argumentos, también los bytes que ocupa.

Se utiliza el punto como separador de decimales. Si ingresamos un valor con más
decimales que los permitidos, redondea al más cercano; por ejemplo, si definimos
"decimal(4,2)" e ingresamos el valor "12.686", guardará "12.69", redondeando hacia
arriba; si ingresamos el valor "12.682", guardará "12.67", redondeando hacia abajo.
Para almacenar valores numéricos APROXIMADOS con decimales utilizamos:
3) float y real: De 1.79E+308 hasta 1.79E+38. Guarda valores aproximados.

4) real: Desde 3.40E+308 hasta 3.40E+38. Guarda valores aproximados.
Para almacenar valores MONETARIOS empleamos:
5) money: Puede tener hasta 19 digitos y sólo 4 de ellos puede ir luego del separador
decimal; entre –900000000000000.5808 aprox y 900000000000000.5807.
6) smallmoney: Entre –200000.3648 y 200000.3647 aprox. Para todos los tipos

numéricos:
- si intentamos ingresar un valor fuera de rango, no lo permite.
- si ingresamos una cadena, SQL Server intenta convertirla a valor numérico, si dicha
cadena consta solamente de dígitos, la conversión se realiza, luego verifica si está
dentro del rango, si es así, la ingresa, sino, muestra un mensaje de error y no ejecuta la
sentencia. Si la cadena contiene caracteres que SQL Server no puede convertir a valor
numérico, muestra un mensaje de error y la sentencia no se ejecuta.
Por ejemplo, definimos un campo de tipo decimal(5,2), si ingresamos la cadena '12.22',
la convierte al valor numérico 12.22 y la ingresa; si intentamos ingresar la cadena
'1234.56', la convierte al valor numérico 1234.56, pero como el máximo valor permitido
es 999.99, muestra un mensaje indicando que está fuera de rango. Si intentamos ingresar
el valor '12y.25', SQL Server no puede realizar la conversión y muestra un mensaje de
error.
Es importante elegir el tipo de dato adecuado según el caso, el más preciso. Por
ejemplo, si un campo numérico almacenará valores positivos menores a 255, el tipo
"int" no es el más adecuado, conviene el tipo "tinyint", de esta manera usamos el menor
espacio de almacenamiento posible. Si vamos a guardar valores monetarios menores a
200000 conviene emplear "smallmoney" en lugar de "money".

_______________________________________
int 4
smallint 2
tinyint 1
bigint 8
decimal 2 a 17
float 4 u 8
real 4 u 8
money 8
smallmoney 4
Primer problema:
Un banco tiene registrados las cuentas corrientes de sus clientes en
una tabla llamada "cuentas".La tabla contiene estos datos:
Número de Cuenta Documento Nombre Saldo

______________________________________________________________
1234 25666777 Pedro Perez 500000.60
2234 27888999 Juan Lopez -250000
3344 27888999 Juan Lopez 4000.50
3346 32111222 Susana Molina 1000
1- Elimine la tabla "cuentas" si existe:

if object_id('cuentas') is not null
drop table cuentas;
2- Cree la tabla eligiendo el tipo de dato adecuado para almacenar los

datos descriptos arriba:
- Número de cuenta: entero, no nulo, no puede haber valores

repetidos, clave primaria;
- Documento del propietario de la cuenta: cadena de caracteres de 8
de longitud (siempre 8), no nulo;
- Nombre del propietario de la cuenta: cadena de caracteres de 30 de
longitud,
- Saldo de la cuenta: valores altos con decimales.

insert into cuentas(numero,documento,nombre,saldo)
values('1234','25666777','Pedro Perez',500000.60);
values('2234','27888999','Juan Lopez',-250000);
values('3344','27888999','Juan Lopez',4000.50);
values('3346','32111222','Susana Molina',1000);
Note que hay dos cuentas, con distinto número de cuenta, de la misma
persona.
4- Seleccione todos los registros cuyo saldo sea mayor a "4000"

(2 registros)
5- Muestre el número de cuenta y saldo de todas las cuentas cuyo

propietario sea "Juan Lopez" (2 registros)
6- Muestre las cuentas con saldo negativo (1 registro)

7- Muestre todas las cuentas cuyo número es igual o mayor a "3000"
(2 registros):
select *from cuentas where numero>=3000;
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;

create table empleados(nombre varchar(30),documento char(8),sexo
char(1),domicilio varchar(30), sueldobasico decimal(7,2),--máximo
estimado 99999.99 cantidadhijos tinyint--no superará los 255);

insert into
empleados(nombre,documento,sexo,domicilio,sueldobasico,cantidadhijos)
values ('Juan Perez','22333444','m','Sarmiento 123',500,2);
insert into empleados
nombre,documento,sexo,domicilio,sueldobasico,cantidadhijos)
values ('Ana Acosta','24555666','f','Colon 134',850,0);
(nombre,documento,sexo,domicilio,sueldobasico,cantidadhijos)
values ('Bartolome Barrios','27888999','m','Urquiza
479',10000.80,4);
4- Ingrese un valor de "sueldobasico" con más decimales que los

definidos (redondea los decimales al valor más cercano 800.89):
(nombre,documento,sexo,domicilio,sueldobasico,cantidadhijos)
values ('Susana Molina','29000555','f','Salta 876',800.888,3);
5- Intente ingresar un sueldo que supere los 7 dígitos (no lo permite)
6- Muestre todos los empleados cuyo sueldo no supere los 900 pesos (1
registro):
7- Seleccione los nombres de los empleados que tengan hijos (3

registros):
19 - Tipo de dato (fecha y hora)

definir los campos y sus tipos más precisos, según el caso. Para almacenar valores de
tipo FECHA Y HORA SQL Server dispone de dos tipos:
1) datetime: puede almacenar valores desde 01 de enero de 1753 hasta 31 de diciembre

de 9999.
2) smalldatetime: el rango va de 01 de enero de 1900 hasta 06 de junio de 2079.
Las fechas se ingresan entre comillas simples. Para almacenar valores de tipo fecha se
permiten como separadores "/", "-" y ".".
SQL Server reconoce varios formatos de entrada de datos de tipo fecha. Para establecer
el orden de las partes de una fecha (dia, mes y año) empleamos "set dateformat". Estos
son los formatos:
-mdy: 4/15/96 (mes y día con 1 ó 2 dígitos y año con 2 ó 4 dígitos),

-myd: 4/96/15,
-dmy: 15/4/1996
-dym: 15/96/4,
-ydm: 96/15/4,
-ydm: 1996/15/4,
Para ingresar una fecha con formato "día-mes-año", tipeamos:
set dateformat dmy;
El formato por defecto es "mdy".
Todos los valores de tipo "datetime" se muestran en formato "año-mes-día

hora:minuto:segundo .milisegundos", independientemente del formato de ingreso que
hayamos seteado.
Podemos ingresar una fecha, sin hora, en tal caso la hora se guarda como "00:00:00".
Por ejemplo, si ingresamos '25-12-01' (año de 2 dígitos), lo mostrará así: '2001-12-25
00:00:00.000'.
Podemos ingresar una hora sin fecha, en tal caso, coloca la fecha "1900-01-01". Por
ejemplo, si ingresamos '10:15', mostrará '1900-01-01 10:15.000'.
Podemos emplear los operadores relacionales vistos para comparar fechas.

_______________________________________
datetime 8
smalldatetime 4
Primer problema:
Una facultad almacena los datos de sus alumnos en una tabla denominada
"alumnos".
drop table alumnos;

create table alumnos(apellido varchar(30),nombre varchar(30),
documento char(8), domicilio varchar(30), fechaingreso datetime,
fechanacimiento datetime);
3- Setee el formato para entrada de datos de tipo fecha para que

acepte valores "día-mes-año": set dateformat 'dmy';
4- Ingrese un alumno empleando distintos separadores para las fechas:

insert into alumnos values('Gonzalez','Ana','22222222','Colon
123','10-08-1990','15/02/1972');
5- Ingrese otro alumno empleando solamente un dígito para día y mes y
2 para el año:
insert into alumnos values('Juarez','Bernardo','25555555','Sucre
456','03-03-1991','15/02/1972');
6- Ingrese un alumnos empleando 2 dígitos para el año de la fecha de

ingreso y "null" en
"fechanacimiento":
insert into alumnos values('Perez','Laura','26666666','Bulnes
345','03-03-91',null);
7- Intente ingresar un alumno con fecha de ingreso correspondiente a

"15 de marzo de 1990" pero en
orden incorrecto "03-15-90":
insert into alumnos values('Lopez','Carlos','27777777','Sarmiento
1254','03-15-1990',null);
aparece un mensaje de error porque lo lee con el formato día, mes y
año y no reconoce el mes 15.
8- Muestre todos los alumnos que ingresaron antes del '1-1-91'.

1 registro.
9- Muestre todos los alumnos que tienen "null" en "fechanacimiento":

select *from alumnos where fechanacimiento is null;
1 registro.
10- Intente ingresar una fecha de ingreso omitiendo los separadores:

insert into alumnos values('Rosas','Romina','28888888','Avellaneda
487','03151990',null);
No lo acepta.
11- Setee el formato de entrada de fechas para que acepte valores

"mes-dia-año".
12- Ingrese el registro del punto 7.
Problema:
Una empresa almacena los datos de sus empleados en una tabla "empleados".

Creamos la tabla eligiendo el tipo de dato adecuado para cada campo:
create table empleados(nombre varchar(20),documento char(8),

fechaingreso datetime);
Seteamos el formato de la fecha para que guarde día, mes y año:
set dateformat dmy;
insert into empleados values('Ana Gomez','22222222','12-01-1980');

insert into empleados values('Bernardo Huerta','23333333','15-03-
81');
insert into empleados values('Carla Juarez','24444444','20/05/1983');
insert into empleados values('Daniel Lopez','25555555','2.5.1990');
El segundo registro ingresado tiene 2 dígitos correspondientes al año; en el tercero

empleamos la barra ('/') como separador y en el cuarto empleamos como separador el
punto ('.') y colocamos un sólo dígito en la part del día y el mes.
Recuperamos los registros:
select *from empleados;
Note que el formato de visualización es "y-m-d".
Mostramos los datos de los empleados cuya fecha de ingreso es anterior a '01-01-1985':
select *from empleados where fechaingreso<'01-01-1985';
Actualizamos el nombre a "Maria Carla Juarez' del empleado cuya fecha de ingreso es
igual a '20/05/1983':
update empleados set nombre='Maria Carla Juarez' where

fechaingreso='20.5.83';
Veamos si se actualizó: select *from empleados;
Borramos los empleados cuya fecha de ingreso es distinta a '20.5.83':
delete from empleados where fechaingreso<>'20/05/1983';
Veamos si se eliminaron: select *from empleados;
20 - Ingresar algunos campos (insert into)

Hemos aprendido a ingresar registros listando todos los campos y colocando valores
para todos y cada uno de ellos luego de "values". Si ingresamos valores para todos los
campos, podemos omitir la lista de nombres de los campos.
Por ejemplo, si tenemos creada la tabla "libros" con los campos "titulo", "autor" y
"editorial", podemos ingresar un registro de la siguiente manera:
insert into libros values ('Uno','Richard Bach','Planeta');
También es posible ingresar valores para algunos campos. Ingresamos valores

solamente para los campos "titulo" y "autor":
insert into libros (titulo, autor) values ('El aleph','Borges');
SQL Server almacenará el valor "null" en el campo "editorial", para el cual no hemos
explicitado un valor.
Al ingresar registros debemos tener en cuenta:
- la lista de campos debe coincidir en cantidad y tipo de valores con la lista de valores
luego de "values". Si se listan más (o menos) campos que los valores ingresados,
aparece un mensaje de error y la sentencia no se ejecuta.
- si ingresamos valores para todos los campos podemos obviar la lista de campos.
- podemos omitir valores para los campos que NO hayan sido declarados "not null", es
decir, que permitan valores nulos (se guardará "null"); si omitimos el valor para un
campo "not null", la sentencia no se ejecuta.
- se DEBE omitir el valor para el campo"identity". Salvo que identity_insert este en on.
- se pueden omitir valores para campos declarados "not null" siempre que tengan
definido un valor por defecto con la cláusula "default" (tema que veremos a
continuación).
Primer problema:
Un banco tiene registrados las cuentas corrientes de sus clientes en
una tabla llamada "cuentas".
1- Elimine la tabla "cuentas" si existe:
if object_id('cuentas') is not null
drop table cuentas;
2- Cree la tabla :
create table cuentas(numero int identity, documento char(8) not null,
nombre varchar(30), saldo money );
3- Ingrese un registro con valores para todos sus campos, inclusive el

campo identity, omitiendo la lista de campos (error, no se debe
ingresar para el campo identity):
insert into cuentas values (1,'25666777','Juan Perez',2500.50);
4- Ingrese un registro con valores para todos sus campos omitiendo la

lista de campos (excepto el campo "identity"):
insert into cuentas values ('25666777','Juan Perez',2500.50);
5- Ingrese un registro omitiendo algún campo que admitan valores

nulos.
6- Intente ingresar un registro con valor para el campo "numero"

(error):
insert into cuentas (numero,documento,nombre,saldo)
values (5,'28999777','Luis Lopez',34000);
7- Intente ingresar un registro listando 3 campos y colocando 4

valores (error)
8- Intente ingresar un registro sin valor para el campo "documento"

(error)
9- Vea los registros ingresados: select *from libros;
Problema:

drop table libros;
Creamos la tabla:

autor varchar(30), editorial varchar(15) );
Si ingresamos valores para todos los campos, podemos omitir la lista de campos:
insert into libros values ('Uno','Richard Bach','Planeta');
Podemos ingresar valores para algunos de los campos:
insert into libros (titulo, autor) values ('El aleph','Borges');
No podemos omitir el valor para un campo declarado "not null", como el campo
"titulo":
insert into libros (autor,editorial)

values ('Lewis Carroll','Planeta');
aparece un mensaje y la inserción no se realiza.
Veamos cómo SQL Server almacenó los registros: select *from libros;
21 - Valores por defecto (default)

Hemos visto que si al insertar registros no se especifica un valor para un campo que
admite valores nulos, se ingresa automáticamente "null" y si el campo está declarado
"identity", se inserta el siguiente de la secuencia. A estos valores se les denomina
valores por defecto o predeterminados. Un valor por defecto se inserta cuando no está
presente al ingresar un registro y en algunos casos en que el dato ingresado es inválido.
Para campos de cualquier tipo no declarados "not null", es decir, que admiten valores
nulos, el valor por defecto es "null". Para campos declarados "not null", no existe valor
por defecto, a menos que se declare explícitamente con la cláusula "default".
Para todos los tipos, excepto los declarados "identity", se pueden explicitar valores por
defecto con la cláusula "default".
Podemos establecer valores por defecto para los campos cuando creamos la tabla. Para
ello utilizamos "default" al definir el campo. Por ejemplo, queremos que el valor por
defecto del campo "autor" de la tabla "libros" sea "Desconocido" y el valor por defecto
del campo "cantidad" sea "0":
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);
Si al ingresar un nuevo registro omitimos los valores para el campo "autor" y

"cantidad", Sql Server insertará los valores por defecto; el siguiente valor de la
secuencia en "codigo", en "autor" colocará "Desconocido" y en cantidad "0".
Entonces, si al definir el campo explicitamos un valor mediante la cláusula "default",

ése será el valor por defecto.
Ahora, al visualizar la estructura de la tabla con "sp_columns" podemos entender lo que

informa la columna "COLUMN_DEF", muestra el valor por defecto del campo.
También se puede utilizar "default" para dar el valor por defecto a los campos en
sentencias "insert", por ejemplo:
insert into libros (titulo,autor,precio,cantidad)

values ('El gato con botas',default,default,100);
Si todos los campos de una tabla tienen valores predeterminados (ya sea por ser
"identity", permitir valores nulos o tener un valor por defecto), se puede ingresar un
registro de la siguiente manera:
insert into libros default values;
La sentencia anterior almacenará un registro con los valores predeterminados para cada
uno de sus campos.
Entonces, la cláusula "default" permite especificar el valor por defecto de un campo. Si

no se explicita, el valor por defecto es "null", siempre que el campo no haya sido
declarado "not null".
Los campos para los cuales no se ingresan valores en un "insert" tomarán los valores
por defecto:
- si tiene el atributo "identity": el valor de inicio de la secuencia si es el primero o el

siguiente valor de la secuencia, no admite cláusula "default";
- si permite valores nulos y no tiene cláusula "default", almacenará "null";
- si está declarado explícitamente "not null", no tiene valor "default" y no tiene el

atributo "identity", no hay valor por defecto, así que causará un error y el "insert" no se
ejecutará.
- si tiene cláusula "default" (admita o no valores nulos), el valor definido como

predeterminado;
- para campos de tipo fecha y hora, si omitimos la parte de la fecha, el valor

predeterminado para la fecha es "1900-01-01" y si omitimos la parte de la hora,
"00:00:00".
Un campo sólo puede tener un valor por defecto. Una tabla puede tener todos sus
campos con valores por defecto. Que un campo tenga valor por defecto no significa que
no admita valores nulos, puede o no admitirlos.
Primer problema:
Un comercio que tiene un stand en una feria registra en una tabla
llamada "visitantes" algunos datos de las personas que visitan o
compran en su stand para luego enviarle publicidad de sus productos.
1- Elimine la tabla "visitantes", si existe:

if object_id('visitantes') is not null
drop table visitantes;

create table visitantes(nombre varchar(30),edad tinyint, sexo char(1)
default 'f',domicilio varchar(30),ciudad varchar(20) default Cordoba',
telefono varchar(11),mail varchar(30) default 'no tiene',
montocompra decimal (6,2));
4- Vea la información de las columnas "COLUMN_DEF" y "IS_NULLABLE":

sp_columns visitantes;
5- Ingrese algunos registros sin especificar valores para algunos

campos para ver cómo opera la cláusula "default":
insert into visitantes (nombre, domicilio, montocompra)
values ('Susana Molina','Colon 123',59.80);
insert into visitantes (nombre, edad, ciudad, mail)
values ('Marcos Torres',29,'Carlos Paz','marcostorres@hotmail.com');
select *from visitantes;
6- Use la palabra "default" para ingresar valores en un insert.
7- Ingrese un registro con "default values".
Problema:


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);
Como todos los campos de "libros" tienen valores predeterminados, podemos tipear:
insert into libros default values;

La sentencia anterior almacenará un registro con los valores predeterminados 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);
22 - Columnas calculadas (operadores aritméticos y de

concatenación)
Aprendimos que los operadores son símbolos que permiten realizar distintos tipos de
operaciones. Dijimos que SQL Server tiene 4 tipos de operadores: 1) relacionales o de
comparación (los vimos), 2) lógicos (lo veremos más adelante, 3) aritméticos y 4) de
concatenación.
Los operadores aritméticos permiten realizar cálculos con valores numéricos.

Son: multiplicación (*), división (/) y módulo (%) (el resto de dividir números enteros),
suma (+) y resta (-). Es posible obtener salidas en las cuales una columna sea el
resultado de un cálculo y no un campo de una tabla.
Si queremos ver los títulos, precio y cantidad de cada libro escribimos la siguiente
sentencia: select titulo,precio,cantidad from libros;
Si queremos saber el monto total en dinero de un título podemos multiplicar el precio
por la cantidad por cada título, pero también podemos hacer que SQL Server realice el
cálculo y lo incluya en una columna extra en la salida:
select titulo, precio,cantidad, precio*cantidad from libros;
Si queremos saber el precio de cada libro con un 10% de descuento podemos incluir en
la sentencia los siguientes cálculos:
select titulo,precio,precio-(precio*0.1) from libros;
También podemos actualizar los datos empleando operadores aritméticos:
update libros set precio=precio-(precio*0.1);
Todas las operaciones matemáticas retornan "null" en caso de error. Ejemplo:
select 5/0;
Los operadores de concatenación: permite concatenar cadenas, el más (+).
Para concatenar el título, el autor y la editorial de cada libro usamos el operador de

concatenación ("+"):
select titulo+'-'+autor+'-'+editorial from libros;
Note que concatenamos además unos guiones para separar los campos.
Primer problema:
if object_id ('articulos') is not null
2- Cree la tabla:
create table articulos(codigo int identity,nombre varchar(20),
descripcion varchar(30),precio smallmoney,cantidad tinyint default 0,
primary key (codigo));

insert into articulos (nombre, descripcion, precio,cantidad)
values ('impresora','Epson Stylus C45',400.80,20);
values ('impresora','Epson Stylus C85',500);
insert into articulos (nombre, descripcion, precio,cantidad)
values ('teclado','ingles Biswal',100,50);
4- El comercio quiere aumentar los precios de todos sus artículos en

un 15%. Actualice todos los precios empleando operadores aritméticos.
5- Vea el resultado: select *from articulos;

6- Muestre todos los artículos, concatenando el nombre y la
descripción de cada uno de ellos separados por coma.
7- Reste a la cantidad de todos los teclados, el valor 5, empleando el

operador aritmético menos ("-")
Problema:

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),cantidad tinyint default 0,primary key (codigo));

values('El aleph','Borges','Emece',25);
insert into libros
values('Java en 10 minutos','Mario Molina','Siglo XXI',50.40,100);
values('Alicia en el pais de las maravillas','Lewis
Carroll','Emece',15,50);
Queremos saber el monto total en dinero de cada libro:
select titulo, precio,cantidad, precio*cantidad from libros;
Queremos saber el precio de cada libro con un 10% de descuento:
select titulo,precio, precio-(precio*0.1) from libros;
Actualizamos los precios con un 10% de descuento y vemos el resultado:
update libros set precio=precio-(precio*0.1);

Queremos una columna con el título, el autor y la editorial de cada libro:
select titulo+'-'+autor+'-'+editorial from libros;
23 - Alias
Una manera de hacer más comprensible el resultado de una consulta consiste en
cambiar los encabezados de las columnas. Por ejemplo, tenemos la tabla "agenda" con
un campo "nombre" (entre otros) en el cual se almacena el nombre y apellido de
nuestros amigos; queremos que al mostrar la información de dicha tabla aparezca como
encabezado del campo "nombre" el texto "nombre y apellido", para ello colocamos un
alias de la siguiente manera:
select nombre as NombreYApellido, domicilio,telefono from agenda;
Para reemplazar el nombre de un campo por otro, se coloca la palabra clave "as"
seguido del texto del encabezado.
Si el alias consta de una sola cadena las comillas no son necesarias, pero si contiene más
de una palabra, es necesario colocarla entre comillas simples:
select nombre as 'Nombre y apellido', domicilio,teléfono from agenda;
Un alias puede contener hasta 128 caracteres. También se puede crear un alias para
columnas calculadas. La palabra clave "as" es opcional en algunos casos, pero es
conveniente usarla.
Entonces, un "alias" se usa como nombre de un campo o de una expresión. En estos

casos, son opcionales, sirven para hacer más comprensible el resultado; en otros casos,
que veremos más adelante, son obligatorios.
Primer problema:
drop table libros;
2- Cree la tabla:
precio decimal(6,2),cantidad tinyint default 0,primary key (codigo));

insert into libros
4- Muestre todos los campos de los libros y un campo extra, con el

encabezado "monto total" en la que calcule el monto total en dinero de
cada libro (precio por cantidad)
5- Muestre el título, autor y precio de todos los libros de editorial

"Emece" y agregue dos columnas extra en las cuales muestre el
descuento de cada libro, con el encabezado "descuento" y el precio con
un 10% de descuento con el encabezado "precio final".
6- Muestre una columna con el título y el autor concatenados con el

encabezado "Título y autor"
Problema:
Trabajamos con nuestra tabla "agenda".


drop table agenda;
Creamos la tabla:
create table agenda(nombre varchar(30), domicilio varchar(30),

telefono varchar(11));
insert into agenda values('Juan Perez','Avellaneda 908','4252525');

insert into agenda values('Marta Lopez','Sucre 34','4556688');
insert into agenda values('Carlos Garcia','Sarmiento 1258',null);
Mostramos la información con el encabezado "NombreYApellido" para el campo

"nombre":
select nombre as NombreYApellido,domicilio,teléfono from agenda;
Mostramos la información con el encabezado "Nombre y apellido" para el campo

"nombre", necesitamos emplear comillas:
select nombre as 'Nombre y apellido', domicilio,teléfono from agenda;
La palabra clave "as" es opcional, podemos obviarla:
select nombre 'Nombre y apellido', domicilio,teléfono from agenda;
24 - Funciones
Una función es un conjunto de sentencias que operan como una unidad lógica. Una
función tiene un nombre, retorna un parámetro de salida y opcionalmente acepta
parámetros de entrada. Las funciones de SQL Server no pueden ser modificadas, las
funciones definidas por el usuario si.
SQL Server ofrece varios tipos de funciones para realizar distintas operaciones. Se
pueden clasificar de la siguiente manera:
1) de agregado: realizan operaciones que combinan varios valores y retornan un único

valor. Son "count", "sum", "min" y "max".
2) escalares: toman un solo valor y retornan un único valor. Pueden agruparse de la

siguiente manera:
- de configuración: retornan información referida a la configuración.
Ejemplo: select @@version;
retorna la fecha, versión y tipo de procesador de SQL Server.
- de cursores: retornan información sobre el estado de un cursor.
- de fecha y hora: operan con valores "datetime" y "smalldatetime". Reciben un

parámetro de tipo fecha y hora y retornan un valor de cadena, numérico o de fecha y
hora.
- matemáticas: realizan operaciones numéricas, geométricas y trigonométricas.
- de metadatos: informan sobre las bases de datos y los objetos.
- de seguridad: devuelven información referente a usuarios y funciones.
- de cadena: operan con valores "char", "varchar", "nchar", "nvarchar", "binary" y

"varbinary" y devuelven un valor de cadena o numérico.
- del sistema: informan sobre opciones, objetos y configuraciones del sistema. Ejemplo:
select user_name();
- estadísticas del sistema: retornan información referente al rendimiento del sistema.
- texto e imagen: realizan operaciones con valor de entrada de tipo text o image y
retornan información referente al mismo.
3) de conjuntos de filas: retornan conjuntos de registros.
Se pueden emplear las funciones del sistema en cualquier lugar en el que se permita una
expresión en una sentencia "select".
Estudiaremos algunas de ellas.
25 - Funciones para el manejo de cadenas

Microsoft SQL Server tiene algunas funciones para trabajar con cadenas de caracteres.
Estas son algunas:
- substring(cadena,inicio,longitud): devuelve una parte de la cadena especificada como

primer argumento, empezando desde la posición especificada por el segundo argumento
y de tantos caracteres de longitud como indica el tercer argumento. Ejemplo:
select substring('Buenas tardes',8,6);
retorna "tardes".
- str(numero,longitud,cantidaddecimales): convierte números a caracteres; el primer
parámetro indica el valor numérico a convertir, el segundo la longitud del resultado
(debe ser mayor o igual a la parte entera del número más el signo si lo tuviese) y el
tercero, la cantidad de decimales. El segundo y tercer argumento son opcionales y deben
ser positivos. String significa cadena en inglés.
Ejemplo: se convierte el valor numérico "123.456" a cadena, especificando 7 de

longitud y 3 decimales:
select str(123.456,7,3);
select str(-123.456,7,3);
retorna '-123.46';
Si no se colocan el segundo y tercer argumeno, la longitud predeterminada es 10 y la

cantidad de decimales 0 y se redondea a entero. Ejemplo: se convierte el valor numérico
"123.456" a cadena:
select str(123.456);
retorna '123';
select str(123.456,3);
retorna '123';
Si el segundo parámetro es menor a la parte entera del número, devuelve asteriscos (*).
Ejemplo: select str(123.456,2,3);
retorna "**".
- stuff(cadena1,inicio,cantidad,cadena2): inserta la cadena enviada como cuarto

argumento, en la posición indicada en el segundo argumento, reemplazando la cantidad
de caracteres indicada por el tercer argumento en la cadena que es primer parámetro.
Stuff significa rellenar en inglés. Ejemplo:
select stuff('abcde',3,2,'opqrs');
retorna "abopqrse". Es decir, coloca en la posición 2 la cadena "opqrs" y reemplaza 2

caracteres de la primer cadena.
Los argumentos numéricos deben ser positivos y menor o igual a la longitud de la

primera cadena, caso contrario, retorna "null".
Si el tercer argumento es mayor que la primera cadena, se elimina hasta el primer

carácter.
- len(cadena): retorna la longitud de la cadena enviada como argumento. "len" viene de

length, que significa longitud en inglés. Ejemplo:
select len('Hola');
devuelve 4.
- char(x): retorna un caracter en código ASCII del entero enviado como argumento.
Ejemplo:
select char(65);
retorna "A".
- left(cadena,longitud): retorna la cantidad (longitud) de caracteres de la cadena

comenzando desde la izquierda, primer caracter. Ejemplo:
select left('buenos dias',8);
retorna "buenos d".
- right(cadena,longitud): retorna la cantidad (longitud) de caracteres de la cadena

comenzando desde la derecha, último caracter. Ejemplo:
select right('buenos dias',8);
retorna "nos dias".
-lower(cadena): retornan la cadena con todos los caracteres en minúsculas. lower

significa reducir en inglés. Ejemplo:
select lower('HOLA ESTUDIAnte');
retorna "hola estudiante".
-upper(cadena): retornan la cadena con todos los caracteres en mayúsculas. Ejemplo:
select upper('HOLA ESTUDIAnte');
-ltrim(cadena): retorna la cadena con los espacios de la izquierda eliminados. Trim

significa recortar. Ejemplo:
select ltrim(' Hola ');
retorna "Hola ".
- rtrim(cadena): retorna la cadena con los espacios de la derecha eliminados. Ejemplo:
select rtrim(' Hola ');
retorna " Hola".
- replace(cadena,cadenareemplazo,cadenareemplazar): retorna la cadena con todas las

ocurrencias de la subcadena reemplazo por la subcadena a reemplazar. Ejemplo:
select replace('xxx.sqlserverya.com','x','w');
retorna "www.sqlserverya.com'.
- reverse(cadena): devuelve la cadena invirtiendo el order de los caracteres. Ejemplo:
select reverse('Hola');
retorna "aloH".
- patindex(patron,cadena): devuelve la posición de comienzo (de la primera ocurrencia)

del patrón especificado en la cadena enviada como segundo argumento. Si no la
encuentra retorna 0. Ejemplos:
select patindex('%Luis%', 'Jorge Luis Borges');
retorna 7.
select patindex('%or%', 'Jorge Luis Borges');
retorna 2.
select patindex('%ar%', 'Jorge Luis Borges');
retorna 0.
- charindex(subcadena,cadena,inicio): devuelve la posición donde comienza la

subcadena en la cadena, comenzando la búsqueda desde la posición indicada por
"inicio". Si el tercer argumento no se coloca, la búsqueda se inicia desde 0. Si no la
encuentra, retorna 0. Ejemplos:
select charindex('or','Jorge Luis Borges',5);
retorna 13.
select charindex('or','Jorge Luis Borges');
retorna 2.
select charindex('or','Jorge Luis Borges',14);
retorna 0.
select charindex('or', 'Jorge Luis Borges');
retorna 0.
- replicate(cadena,cantidad): repite una cadena la cantidad de veces especificada.

Ejemplo:
select replicate ('Hola',3);

retorna "HolaHolaHola";
- space(cantidad): retorna una cadena de espacios de longitud indicada por "cantidad",

que debe ser un valor positivo. Ejemplo:
select 'Hola'+space(1)+'que tal';
retorna "Hola que tal".
Se pueden emplear estas funciones enviando como argumento el nombre de un campo

de tipo caracter.
Problema:


drop table libros;
Creamos la tabla:

precio decimal(6,2),cantidad tinyint default 0, primary key (codigo));

insert into libros
Mostramos sólo los 12 primeros caracteres de los títulos de los libros y sus autores,
empleando la función "substring()":
select substring(titulo,1,12) as titulo from libros;
Mostramos sólo los 12 primeros caracteres de los títulos de los libros y sus autores,
ahora empleando la función "left()":
select left(titulo,12) as titulo from libros;
Mostramos los títulos de los libros y sus precios convirtiendo este último a cadena de
caracteres con un solo decimal, empleando la función "str":
select titulo, str(precio,6,1) from libros;

Mostramos los títulos de los libros y sus precios convirtiendo este último a cadena de
caracteres especificando un solo argumento:
select titulo, str(precio) from libros;
Se redondea a entero.
Mostramos los títulos, autores y editoriales de todos libros, al último campo lo

queremos en mayúsculas:
select titulo, autor, upper(editorial) from libros;
26 - Funciones matemáticas
Las funciones matemáticas realizan operaciones con expresiones numéricas y retornan
un resultado, operan con tipos de datos numéricos. Microsoft SQL Server tiene algunas
funciones para trabajar con números. Aquí presentamos algunas.
-abs(x): retorna el valor absoluto del argumento "x". Ejemplo:
select abs(-20);
retorna 20.
-ceiling(x): redondea hacia arriba el argumento "x". Ejemplo:
select ceiling(12.34);
retorna 13.
-floor(x): redondea hacia abajo el argumento "x". Ejemplo:
select floor(12.34);
retorna 12.
- %: %: devuelve el resto de una división. Ejemplos:
select 10%3;
retorna 1.
select 10%2;
retorna 0.
-power(x,y): retorna el valor de "x" elevado a la "y" potencia. Ejemplo:

select power(2,3);
retorna 8.
-round(numero,longitud): retorna un número redondeado a la longitud especificada.

"longitud" debe ser tinyint, smallint o int. Si "longitud" es positivo, el número de
decimales es redondeado según "longitud"; si es negativo, el número es redondeado
desde la parte entera según el valor de "longitud". Ejemplos:
select round(123.456,1);
retorna "123.400", es decir, redondea desde el primer decimal.
select round(123.456,2);
retorna "123.460", es decir, redondea desde el segundo decimal.
select round(123.456,-1);
retorna "120.000", es decir, redondea desde el primer valor entero (hacia la izquierda).
select round(123.456,-2);
retorna "100.000", es decir, redondea desde el segundo valor entero (hacia la izquierda).
-sign(x): si el argumento es un valor positivo devuelve 1;-1 si es negativo y si es 0, 0.
-square(x): retorna el cuadrado del argumento. Ejemplo:
select square(3); retorna 9.
-srqt(x): devuelve la raiz cuadrada del valor enviado como argumento.
SQL Server dispone de funciones trigonométricas que retornan radianes.

de tipo numérico.
Problema:


drop table libros;
Creamos la tabla:

precio decimal(6,2),primary key (codigo));

values('El aleph','Borges','Emece',25.33);
insert into libros
values('Java en 10 minutos','Mario Molina','Siglo XXI',50.65);
Carroll','Emece',19.95);
Vamos a mostrar los precios de los libros redondeando el valor hacia abajo y hacia
arriba:
select titulo,autor,precio,floor(precio) as abajo,ceiling(precio) as

arriba from libros;
27 - Funciones para el uso de fechas y horas

getdate(): retorna la fecha y hora actuales. Ejemplo:
select getdate();
- datepart(partedefecha,fecha): retorna la parte específica de una fecha, el año,

trimestre, día, hora, etc.
Los valores para "partedefecha" pueden ser: year (año), quarter (cuarto), month (mes),
day (dia), week (semana), hour (hora), minute (minuto), second (segundo) y millisecond
(milisegundo). Ejemplos:
select datepart(month,getdate());
retorna el número de mes actual;
select datepart(day,getdate());
retorna el día actual;
select datepart(hour,getdate());
retorna la hora actual;
- datename(partedefecha,fecha): retorna el nombre de una parte específica de una

fecha. Los valores para "partedefecha" pueden ser los mismos que se explicaron
anteriormente. Ejemplos:
select datename(month,getdate());
retorna el nombre del mes actual;
select datename(day,getdate());
- dateadd(partedelafecha,numero,fecha): agrega un intervalo a la fecha especificada, es
decir, retorna una fecha adicionando a la fecha enviada como tercer argumento, el
intervalo de tiempo indicado por el primer parámetro, tantas veces como lo indica el
segundo parámetro. Los valores para el primer argumento pueden ser: year (año),
quarter (cuarto), month (mes), day (dia), week (semana), hour (hora), minute (minuto),
second (segundo) y millisecond (milisegundo). Ejemplos:
select dateadd(day,3,'1980/11/02');
retorna "1980/11/05", agrega 3 días.
select dateadd(month,3,'1980/11/02');
retorna "1981/02/02", agrega 3 meses.
select dateadd(hour,2,'1980/11/02');
retorna "1980/02/02 2:00:00", agrega 2 horas.
select dateadd(minute,16,'1980/11/02');
retorna "1980/02/02 00:16:00", agrega 16 minutos.
- datediff(partedelafecha,fecha1,fecha2): calcula el intervalo de tiempo (según el primer

argumento) entre las 2 fechas. El resultado es un valor entero que corresponde a fecha2-
fecha1. Los valores de "partedelafecha) pueden ser los mismos que se especificaron
anteriormente. Ejemplos:
select datediff (day,'2005/10/28','2006/10/28');
retorna 365 (días).
select datediff(month,'2005/10/28','2006/11/29');
retorna 13 (meses).
- day(fecha): retorna el día de la fecha especificada. Ejemplo:
select day(getdate());
- month(fecha): retorna el mes de la fecha especificada. Ejemplo:
select month(getdate());
- year(fecha): retorna el año de la fecha especificada. Ejemplo:
select year(getdate());

de tipo datetime o smalldatetime.
Problema:

drop table libros;
Creamos la tabla:
create table libros(titulo varchar(40) not null,autor varchar(20)

default 'Desconocido',editorial varchar(20),edicion datetime,
precio decimal(6,2));
insert into libros

values('El aleph','Borges','Emece','1980/10/10',25.33);
insert into libros
values('Java en 10 minutos','Mario Molina','Siglo
XXI','2000/05/05',50.65);
insert into libros
Carroll','Emece','2000/08/09',19.95);
insert into libros
values('Aprenda PHP','Mario Molina','Siglo XXI','2000/02/04',45);
Mostramos el título del libro y el año de edición:
select titulo, datepart (year,edicion) from libros;
Mostramos el título del libro y el nombre del mes de edición:
select titulo, datename (month,edicion) from libros;
Mostramos el título del libro y los años que tienen de editados:
select titulo, datediff(year,edicion,getdate()) from libros;
Muestre los títulos de los libros que se editaron el día 9, de cualquier mes de cualquier
año:
select titulo from libros where datepart(day,edicion)=9;
28 - Ordenar registros (order by)

Podemos ordenar el resultado de un "select" para que los registros se muestren
ordenados por algún campo, para ello usamos la cláusula "order by".
La sintaxis básica es la siguiente:
select *from NOMBRETABLA order by CAMPO;
Por ejemplo, recuperamos los registros de la tabla "libros" ordenados por el título:
select *from libros order by titulo;
Aparecen los registros ordenados alfabéticamente por el campo especificado.
También podemos colocar el número de orden del campo por el que queremos que se
ordene en lugar de su nombre, es decir, referenciar a los campos por su posición en la
lista de selección. Por ejemplo, queremos el resultado del "select" ordenado por
"precio":
select titulo,autor,precio from libros order by 3;
Por defecto, si no aclaramos en la sentencia, los ordena de manera ascendente (de menor
a mayor). Podemos ordenarlos de mayor a menor, para ello agregamos la palabra clave
"desc": select *libros order by editorial desc;
También podemos ordenar por varios campos, por ejemplo, por "titulo" y "editorial":
select *from libros order by titulo,editorial;
Incluso, podemos ordenar en distintos sentidos, por ejemplo, por "titulo" en sentido
ascendente y "editorial" en sentido descendente:
select *from libros order by titulo asc, editorial desc;
Debe aclararse al lado de cada campo, pues estas palabras claves afectan al campo
inmediatamente anterior.
Es posible ordenar por un campo que no se lista en la selección.
Se permite ordenar por valores calculados o expresiones.
La cláusula "order by" no puede emplearse para campos text, ntext e image.
Primer problema:
En una página web se guardan los siguientes datos de las visitas:
número de visita, nombre, mail, pais, fecha.
1- Elimine la tabla "visitas", si existe:
if object_id('visitas') is not null
drop table visitas;

create table visitas (numero int identity,nombre varchar(30) default
'Anonimo', mail varchar(50), pais varchar (20), fecha datetime,
primary key(numero));

insert into visitas (nombre,mail,pais,fecha)
values ('Ana Maria Lopez','AnaMaria@hotmail.com','Argentina','2006-
10-10 10:10');
values ('Gustavo
Gonzalez','GustavoGGonzalez@hotmail.com','Chile','2006-10-10 21:30');
values ('Juancito','JuanJosePerez@hotmail.com','Argentina','2006-10-
11 15:45');
values ('Fabiola
Martinez','MartinezFabiola@hotmail.com','Mexico','2006-10-12 08:15');
values ('Fabiola
12 16:20');
15 16:25');
4- Ordene los registros por fecha, en orden descendente.
5- Muestre el nombre del usuario, pais y el nombre del mes, ordenado

por pais (ascendente) y nombre del mes (descendente)
6- Muestre el pais, el mes, el día y la hora y ordene las visitas por

nombre del mes, del día y la hora.
7- Muestre los mail, país, ordenado por país, de todos los que
visitaron la página en octubre (4 registros)
Problema:


drop table libros;
Creamos la tabla:

autor varchar(20) default 'Desconocido', editorial varchar(20),
precio decimal(6,2), primary key (codigo));

values('El aleph','Borges','Emece',25.33);
insert into libros
values('Java en 10 minutos','Mario Molina','Siglo XXI',50.65);
Carroll','Emece',19.95);
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;
29 - Operadores lógicos ( and - or - not)

Hasta el momento, hemos aprendido a establecer una condición con "where" utilizando
operadores relacionales. Podemos establecer más de una condición con la cláusula
"where", para ello aprenderemos los operadores lógicos.
Son los siguientes:
- and, significa "y",

- or, significa "y/o",
- not, significa "no", invierte el resultado
- (), paréntesis
Los operadores lógicos se usan para combinar condiciones.Si queremos recuperar todos
los libros cuyo autor sea igual a "Borges" y cuyo precio no supere los 20 pesos,
necesitamos 2 condiciones:
select *from libros where (autor='Borges') and (precio<=20);
Los registros recuperados en una sentencia que une 2 condiciones con el operador
"and", cumplen con las 2 condiciones.
Queremos ver los libros cuyo autor sea "Borges" y/o cuya editorial sea "Planeta":
select *from libros where autor='Borges' or editorial='Planeta';

En la sentencia anterior usamos el operador "or"; indicamos que recupere los libros en
los cuales el valor del campo "autor" sea "Borges" y/o el valor del campo "editorial" sea
"Planeta", es decir, seleccionará los registros que cumplan con la primera condición, con
la segunda condición o con ambas condiciones.
Los registros recuperados con una sentencia que une 2 condiciones con el operador "or",
cumplen 1 de las condiciones o ambas.
Queremos recuperar los libros que NO cumplan la condición dada, por ejemplo,
aquellos cuya editorial NO sea "Planeta":
select *from libros where not editorial='Planeta';
El operador "not" invierte el resultado de la condición a la cual antecede.
Los registros recuperados en una sentencia en la cual aparece el operador "not", no

cumplen con la condición a la cual afecta el "NOT".
Los paréntesis se usan para encerrar condiciones, para que se evalúen como una sola
expresión. Cuando explicitamos varias condiciones con diferentes operadores lógicos
(combinamos "and", "or") permite establecer el orden de prioridad de la evaluación;
además permite diferenciar las expresiones más claramente.
Por ejemplo, las siguientes expresiones devuelven un resultado diferente:
select*from libros where (autor='Borges') or (editorial='Paidos'

and precio<20);
select *from libros where (autor='Borges' or editorial='Paidos') and

(precio<20);
Si bien los paréntesis no son obligatorios en todos los casos, se recomienda utilizarlos
para evitar confusiones.
El orden de prioridad de los operadores lógicos es el siguiente: "not" se aplica antes que
"and" y "and" antes que "or", si no se especifica un orden de evaluación mediante el uso
de paréntesis. El orden en el que se evalúan los operadores con igual nivel de
precedencia es indefinido, por ello se recomienda usar los paréntesis.
Entonces, para establecer más de una condición en un "where" es necesario emplear

operadores lógicos. "and" significa "y", indica que se cumplan ambas condiciones; "or"
significa "y/o", indica que se cumpla una u otra condición (o ambas); "not" significa
"no", indica que no se cumpla la condición especificada.
Primer problema:
Trabaje con la tabla llamada "medicamentos" de una farmacia.

create table medicamentos(codigo int identity,nombre varchar(20),
laboratorio varchar(20),precio decimal(5,2), cantidad tinyint,
primary key(codigo));

insert into medicamentos values('Sertal','Roche',5.2,100);
insert into medicamentos values('Buscapina','Roche',4.10,200);
insert into medicamentos values('Amoxidal 500','Bayer',15.60,100);
insert into medicamentos values('Paracetamol 500','Bago',1.90,200);
insert into medicamentos values('Bayaspirina','Bayer',2.10,150);
insert into medicamentos values('Amoxidal jarabe','Bayer',5.10,250);
4- Recupere los códigos y nombres de los medicamentos cuyo laboratorio

sea 'Roche' y cuyo precio sea menor a 5 (1 registro cumple con ambas
condiciones)
5- Recupere los medicamentos cuyo laboratorio sea 'Roche' o cuyo

precio sea menor a 5 (4 registros):
select * from medicamentos where laboratorio='Roche' or precio<5;
Note que el resultado es diferente al del punto 4, hemos cambiado el
operador de la sentencia anterior.
6- Muestre todos los medicamentos cuyo laboratorio NO sea "Bayer" y

cuya cantidad sea=100 (1 registro)
7- Muestre todos los medicamentos cuyo laboratorio sea "Bayer" y cuya

cantidad NO sea=100 (2 registros):
select * from medicamentos where laboratorio='Bayer' and not
cantidad=100;
Analice estas 2 últimas sentencias. El operador "not" afecta a la
condición a la cual antecede, no a las siguientes. Los resultados de
los puntos 6 y 7 son diferentes.
8- Elimine todos los registros cuyo laboratorio sea igual a "Bayer" y

su precio sea mayor a 10 (1 registro eliminado)
9- Cambie la cantidad por 200, a todos los medicamentos de "Roche"

cuyo precio sea mayor a 5 (1 registro afectado)
10- Borre los medicamentos cuyo laboratorio sea "Bayer" o cuyo precio
sea menor a 3 (3 registros borrados)
Segundo problema:
Trabajamos con la tabla "peliculas" de un video club que alquila
películas en video.
1- Elimine la tabla, si existe;

create table peliculas(codigo int identity,titulo varchar(40) not
null, actor varchar(20),duracion tinyint, primary key (codigo));

insert into peliculas values('Mision imposible','Tom Cruise',120);
insert into peliculas
insert into peliculas values('Mision imposible 2','Tom Cruise',120);
insert into peliculas values('Mujer bonita','Richard Gere',120);
insert into peliculas values('Tootsie','D. Hoffman',90);
insert into peliculas values('Un oso rojo','Julio Chavez',100);
insert into peliculas values('Elsa y Fred','China Zorrilla',110);
4- Recupere los registros cuyo actor sea "Tom Cruise" or "Richard

Gere" (3 registros)
5- Recupere los registros cuyo actor sea "Tom Cruise" y duración menor
a 100 (ninguno cumple ambascondiciones)
6- Cambie la duración a 200, de las películas cuyo actor sea "Daniel

R." y cuya duración sea 180 (1 registro afectado)
7- Borre todas las películas donde el actor NO sea "Tom Cruise" y cuya
duración sea mayor o igual a 100 (2 registros eliminados)
30 - Otros operadores relacionales (is null)

Hemos aprendido los operadores relacionales "=" (igual), "<>" (distinto), ">" (mayor),
"<" (menor), ">=" (mayor o igual) y "<=" (menor o igual). Dijimos que no eran los
únicos. Existen otro operador relacional "is null".
Se emplea el operador "is null" para recuperar los registros en los cuales esté
almacenado el valor "null" en un campo específico:
select *from libros where editorial is null;
Para obtener los registros que no contiene "null", se puede emplear "is not null", esto
mostrará los registros con valores conocidos. Siempre que sea posible, emplee
condiciones de búsqueda positivas ("is null"), evite las negativas ("is not null") porque
con ellas se evalúan todos los registros y esto hace más lenta la recuperación de los
datos.
Primer problema:
Trabajamos con la tabla "peliculas" de un video club que alquila
películas en video.
1- Elimine la tabla, si existe;

create table peliculas(codigo int identity,titulo varchar(40) not
null,actor varchar(20),duracion tinyint, primary key (codigo));

insert into peliculas values('Mision imposible','Tom Cruise',120);
values('Harry Potter y la piedra filosofal','Daniel R.',null);
insert into peliculas values('Mision imposible 2','Tom Cruise',120);
insert into peliculas values('Mujer bonita',null,120);
insert into peliculas values('Tootsie','D. Hoffman',90);
insert into peliculas (titulo) values('Un oso rojo');
4- Recupere las películas cuyo actor sea nulo (2 registros)
5- Cambie la duración a 0, de las películas que tengan duración igual a

"null" (2 registros)
6- Borre todas las películas donde el actor sea "null" y cuya duración
sea 0 (1 registro)
Problema:


drop table libros;
Creamos la tabla:

precio decimal(6,2),);
insert into libros values('El aleph','Borges','Emece',15.90);

insert into libros
values('Cervantes y el quijote','Borges','Paidos',null);
insert into libros
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);
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;
31 - Otros operadores relacionales (between)

Hemos visto los operadores relacionales: = (igual), <> (distinto), > (mayor), < (menor),
>= (mayor o igual), <= (menor o igual), is null/is not null (si un valor es NULL o no).
Otro operador relacional es "between", trabajan con intervalos de valores. Hasta ahora,
para recuperar de la tabla "libros" los libros con precio mayor o igual a 20 y menor o
igual a 40, usamos 2 condiciones unidas por el operador lógico "and":
select *from libros where precio>=20 and precio<=40;
Podemos usar "between" y así simplificar la consulta:
select *from libros where precio between 20 and 40;
Averiguamos si el valor de un campo dado (precio) está entre los valores mínimo y
máximo especificados (20 y 40 respectivamente). "between" significa "entre". Trabaja
con intervalo de valores. Este operador se puede emplear con tipos de datos numéricos y
money (en tales casos incluyen los valores mínimo y máximo) y tipos de datos fecha y
hora (incluye sólo el valor mínimo). No tiene en cuenta los valores "null".
Si agregamos el operador "not" antes de "between" el resultado se invierte, es decir, se

recuperan los registros que están fuera del intervalo especificado. Por ejemplo,
recuperamos los libros cuyo precio NO se encuentre entre 20 y 35, es decir, los menores
a 15 y mayores a 25:
select *from libros where precio not between 20 and 35;
Siempre que sea posible, emplee condiciones de búsqueda positivas ("between"), evite
las negativas ("not between") porque hace más lenta la recuperación de los datos.
Entonces, se puede usar el operador "between" para reducir las condiciones "where".
Primer problema:
En una página web se guardan los siguientes datos de las visitas:
número de visita, nombre, mail, pais, fechayhora de la visita.
1- Elimine la tabla "visitas", si existe:
if object_id('visitas') is not null
drop table visitas;

create table visitas(numero int identity,nombre varchar(30) default
'Anonimo', mail varchar(50), pais varchar (20), fechayhora datetime,
primary key(numero));

insert into visitas (nombre,mail,pais,fechayhora)
values ('Ana Maria Lopez','AnaMaria@hotmail.com','Argentina','2006-
10-10 10:10');
values ('Gustavo
Gonzalez','GustavoGGonzalez@gotmail.com','Chile','2006-10-10 21:30');
11 15:45');
values ('Fabiola
values ('Fabiola
values ('Juancito','JuanJosePerez@gmail.com','Argentina','2006-09-12
16:20');
15 16:25');
insert into visitas (nombre,mail,pais)
values ('Federico1','federicogarcia@xaxamail.com','Argentina');
4- Seleccione los usuarios que visitaron la página entre el '2006-09-

12' y '2006-10-11' (5 registros)
Note que incluye los de fecha mayor o igual al valor mínimo y menores
al valor máximo, y que los valores null no se incluyen.
5- Recupere las visitas cuyo número se encuentra entre 2 y 5 (4

registros), Note que incluye los valores límites.
Segundo problema:
Una concesionaria de autos vende autos usados y almacena la
información en una tabla llamada "autos".
1- Elimine la tabla "autos" si existe:
if object_id('autos') is not null
drop table autos;

create table autos(patente char(6), marca varchar(20), modelo char(4),
precio decimal(8,2), primary key(patente));

insert into autos values('ACD123','Fiat 128','1970',15000);
insert into autos values('ACG234','Renault 11','1980',40000);
insert into autos values('BCD333','Peugeot 505','1990',80000);
insert into autos values('GCD123','Renault Clio','1995',70000);
insert into autos values('BCC333','Renault Megane','1998',95000);
insert into autos values('BVF543','Fiat 128','1975',20000);
4- Seleccione todos los autos cuyo modelo se encuentre entre '1970' y

'1990' usando el operador "between" y ordénelos por dicho campo
(4 registros)
5- Seleccione todos los autos cuyo precio esté entre 50000 y 100000.
32 - Otros operadores relacionales (in)

Se utiliza "in" para averiguar si el valor de un campo está incluido en una lista de
valores especificada. En la siguiente sentencia usamos "in" para averiguar si el valor del
campo autor está incluido en la lista de valores especificada (en este caso, 2 cadenas).
Hasta ahora, para recuperar los libros cuyo autor sea 'Paenza' o 'Borges' usábamos 2
condiciones:
select *from libros where autor='Borges' or autor='Paenza';
Podemos usar "in" y simplificar la consulta:
select *from libros where autor in('Borges','Paenza');
Para recuperar los libros cuyo autor no sea 'Paenza' ni 'Borges' usábamos:
select *from libros where autor<>'Borges' and autor<>'Paenza';
También podemos usar "in" anteponiendo "not":
select *from libros where autor not in ('Borges','Paenza');

Empleando "in" averiguamos si el valor del campo está incluido en la lista de valores
especificada; con "not" antecediendo la condición, invertimos el resultado, es decir,
recuperamos los valores que no se encuentran (coindicen) con la lista de valores. Los
valores "null" no se consideran.
Recuerde: siempre que sea posible, emplee condiciones de búsqueda positivas ("in"),
evite las negativas ("not in") porque con ellas se evalún todos los registros y esto hace
más lenta la recuperación de los datos.
Primer problema:

laboratorio varchar(20),precio decimal(6,2),cantidad tinyint,
fechavencimiento datetime not null, primary key(codigo));

insert into medicamentos values('Sertal','Roche',5.2,1,'2005-02-01');
insert into medicamentos
values('Buscapina','Roche',4.10,3,'2006-03-01');
values('Amoxidal 500','Bayer',15.60,100,'2007-05-01');
values('Paracetamol 500','Bago',1.90,20,'2008-02-01');
values('Bayaspirina','Bayer',2.10,150,'2009-12-01');
values('Amoxidal jarabe','Bayer',5.10,250,'2010-10-01');
4- Recupere los nombres y precios de los medicamentos cuyo laboratorio

sea "Bayer" o "Bago" empleando el operador "in" (4 registros)
5- Seleccione los remedios cuya cantidad se encuentre entre 1 y 5

empleando el operador "between" y luego el operador "in" (2
registros):
select *from medicamentos where cantidad between 1 and 5;
select *from medicamentos where cantidad in (1,2,3,4,5);
Note que es más conveniente emplear, en este caso, el operador
""between".
Problema:


drop table libros;
Creamos la tabla:

autor varchar(20),editorial varchar(20), precio decimal(6,2));

insert into libros
values('Cervantes y el quijote','Borges','Paidos',null);
insert into libros
insert into libros
values('Matematica estas ahi','Paenza','Siglo XXI',15);
insert into libros (titulo,precio) values('Antología poética',32);
values('Martin Fierro','Jose Hernandez',40);
values('Aprenda PHP','Mario Molina',56.50);
Recuperamos los libros cuyo autor es "Paenza" o "Borges":
select *from libros where autor in('Borges','Paenza');
Recuperamos los libros cuyo autor NO es "Paenza" ni "Borges":
select *from libros where autor not in ('Borges','Paenza');
Note que los valores "null" no se consideran.
33 - Búsqueda de patrones (like - not like)

Existe un operador relacional que se usa para realizar comparaciones exclusivamente
de cadenas, "like" y "not like".Hemos realizado consultas utilizando operadores
relacionales para comparar cadenas. Por ejemplo, sabemos recuperar los libros cuyo
autor sea igual a la cadena "Borges":
select *from libros where autor='Borges';
El operador igual ("=") nos permite comparar cadenas de caracteres, pero al realizar la
comparación, busca coincidencias de cadenas completas, realiza una búsqueda exacta.
Imaginemos que tenemos registrados estos 2 libros:
"El Aleph", "Borges";

"Antologia poetica", "J.L. Borges";
Si queremos recuperar todos los libros de "Borges" y especificamos la siguiente

condición:
select *from libros where autor='Borges';
sólo aparecerá el primer registro, ya que la cadena "Borges" no es igual a la cadena "J.L.
Borges". Esto sucede porque el operador "=" (igual), también el operador "<>" (distinto)
comparan cadenas de caracteres completas. Para comparar porciones de cadenas
utilizamos los operadores "like" y "not like".
Entonces, podemos comparar trozos de cadenas de caracteres para realizar consultas.
Para recuperar todos los registros cuyo autor contenga la cadena "Borges" debemos
tipear: select *from libros where autor like "%Borges%";
El símbolo "%" (porcentaje) reemplaza cualquier cantidad de caracteres (incluyendo

ningún caracter). Es un caracter comodín. "like" y "not like" son operadores de
comparación que señalan igualdad o diferencia.
Para seleccionar todos los libros que comiencen con "M":
select *from libros where titulo like 'M%';
Note que el símbolo "%" ya no está al comienzo, con esto indicamos que el título debe
tener como primera letra la "M" y luego, cualquier cantidad de caracteres.
Para seleccionar todos los libros que NO comiencen con "M":
select *from libros where titulo not like 'M%';
Así como "%" reemplaza cualquier cantidad de caracteres, el guión bajo "_" reemplaza
un caracter, es otro caracter comodín. Por ejemplo, queremos ver los libros de "Lewis
Carroll" pero no recordamos si se escribe "Carroll" o "Carrolt", entonces tipeamos esta
condición:
select *from libros where autor like "%Carrol_";
Otro caracter comodín es [] reemplaza cualquier carácter contenido en el conjunto

especificado dentro de los corchetes.
Para seleccionar los libros cuya editorial comienza con las letras entre la "P" y la "S"
usamos la siguiente sintaxis:
select titulo,autor,editorial from libros where editorial

like '[P-S]%';
Ejemplos:
... like '[a-cf-i]%': busca cadenas que comiencen con a,b,c,f,g,h o i;

... like '[-acfi]%': busca cadenas que comiencen con -,a,c,f o i;
... like 'A[_]9%': busca cadenas que comiencen con 'A_9';
... like 'A[nm]%': busca cadenas que comiencen con 'An' o 'Am'.
El cuarto caracter comodín es [^] reemplaza cualquier caracter NO presente en el

conjunto especificado dentro de los corchetes.
Para seleccionar los libros cuya editorial NO comienza con las letras "P" ni "N"
tipeamos:
select titulo,autor,editorial from libros where editorial

like '[^PN]%';
"like" se emplea con tipos de datos char, nchar, varchar, nvarchar o datetime. Si
empleamos "like" con tipos de datos que no son caracteres, SQL Server convierte (si es
posible) el tipo de dato a caracter. Por ejemplo, queremos buscar todos los libros cuyo
precio se encuentre entre 10.00 y 19.99:
select titulo,precio from libros where precio like '1_.%';
Queremos los libros que NO incluyen centavos en sus precios:
select titulo,precio from libros where precio like '%.00';
Para búsquedas de caracteres comodines como literales, debe incluirlo dentro de

corchetes, por ejemplo, si busca:
... like '%[%]%': busca cadenas que contengan el signo '%';

... like '%[_]%': busca cadenas que contengan el signo '_';
... like '%[[]%': busca cadenas que contengan el signo '[';
Primer problema:
Una empresa almacena los datos de sus empleados en una tabla
"empleados".
2- Cree la tabla:
create table empleados(nombre varchar(30),documento char(8),
domicilio varchar(30),fechaingreso datetime,seccion varchar(20),
sueldo decimal(6,2), primary key(documento));

values('Juan Perez','22333444','Colon 123','1990-10-
08','Gerencia',900.50);
values('Ana Acosta','23444555','Caseros 987','1995-12-
18','Secretaria',590.30);
values('Lucas Duarte','25666777','Sucre 235','2005-05-
15','Sistemas',790);
values('Pamela Gonzalez','26777888','Sarmiento 873','1999-02-
12','Secretaria',550);
values('Marcos Juarez','30000111','Rivadavia 801','2002-09-
22','Contaduria',630.70);
values('Yolanda Perez','35111222','Colon 180','1990-10-
08','Administracion',400);
values('Rodolfo Perez','35555888','Coronel Olmedo 588','1990-05-
28','Sistemas',800);
4- Muestre todos los empleados con apellido "Perez" empleando el

operador "like" (3 registros)
5- Muestre todos los empleados cuyo domicilio comience con "Co" y

tengan un "8" (2 registros)
6- Seleccione todos los empleados cuyo documento finalice en 0,2,4,6 u
8 (4 registros)
7- Seleccione todos los empleados cuyo documento NO comience con 1 ni

3 y cuyo nombre finalice en
"ez" (2 registros)
8- Recupere todos los nombres que tengan una "y" o una "j" en su
nombre o apellido (3 registros)
9- Muestre los nombres y sección de los empleados que pertenecen a

secciones que comiencen con "S" o
"G" y tengan 8 caracteres (3 registros)
10- Muestre los nombres y sección de los empleados que pertenecen a

secciones que NO comiencen con
"S" o "G" (2 registros)
11- Muestre todos los nombres y sueldos de los empleados cuyos sueldos
incluyen centavos (3
registros)
12- Muestre los empleados que hayan ingresado en "1990" (3 registros)

Problema:


drop table libros;
Creamos la tabla:

precio decimal(6,2), primary key(codigo));

insert into libros
values('Antología poética','J. L. Borges','Planeta',null);
insert into libros
insert into libros
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';
34 - Contar registros (count)

Existen en SQL Server funciones que nos permiten contar registros, calcular sumas,
promedios, obtener valores máximos y mínimos. Estas funciones se denominan
funciones de agregado y operan sobre un conjunto de valores (registros), no con datos
individuales y devuelven un único valor.
Imaginemos que nuestra tabla "libros" contiene muchos registros. Para averiguar la
cantidad sin necesidad de contarlos manualmente usamos la función "count()":
select count(*) from libros;
La función "count()" cuenta la cantidad de registros de una tabla, incluyendo los que
tienen valor nulo. También podemos utilizar esta función junto con la cláusula "where"
para una consulta más específica. Queremos saber la cantidad de libros de la editorial
"Planeta":
select count(*) from libros where editorial='Planeta';
Para contar los registros que tienen precio (sin tener en cuenta los que tienen valor
nulo), usamos la función "count()" y en los paréntesis colocamos el nombre del campo
que necesitamos contar:
select count(precio) from libros;

Note que "count(*)" retorna la cantidad de registros de una tabla (incluyendo los que
tienen valor "null") mientras que "count(precio)" retorna la cantidad de registros en los
cuales el campo "precio" no es nulo. No es lo mismo. "count(*)" cuenta registros, si en
lugar de un asterisco colocamos como argumento el nombre de un campo, se
contabilizan los registros cuyo valor en ese campo NO es nulo.
Primer problema:

laboratorio varchar(20), precio decimal(6,2),
cantidad tinyint, fechavencimiento datetime not null,
numerolote int default null, primary key(codigo));

values('Sertal','Roche',5.2,1,'2005-02-01',null);
values('Buscapina','Roche',4.10,3,'2006-03-01',null);
values('Amoxidal 500','Bayer',15.60,100,'2007-05-01',null);
values('Paracetamol 500','Bago',1.90,20,'2008-02-01',null);
values('Bayaspirina',null,2.10,null,'2009-12-01',null);
values('Amoxidal jarabe','Bayer',null,250,'2009-12-15',null);
4- Muestre la cantidad de registros empleando la función "count(*)" (6

registros)
5- Cuente la cantidad de medicamentos que tienen laboratorio conocido

(5 registros)
6- Cuente la cantidad de medicamentos que tienen precio distinto a

"null" y que tienen cantidad distinto a "null", disponer alias para
las columnas.
7- Cuente la cantidad de remedios con precio conocido, cuyo

laboratorio comience con "B" (2registros)
8- Cuente la cantidad de medicamentos con número de lote distitno de

"null" (0 registros)
Problema:


drop table libros;
Creamos la tabla:

precio decimal(6,2), primary key(codigo));

insert into libros
values('Antología poética','J. L. Borges','Planeta',null);
insert into libros
insert into libros
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;

Curso SQL

Cargado por

Copyright:

Formatos disponibles

Curso SQL

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Curso SQL

Cargado por

Copyright:

Formatos disponibles

1 - Objetivos y alcances del tutorial de Microsoft Sql

Siempre que lancemos un comando SQL en el sitio www.sqlserverya.com.ar estaremos

2 - Crear una tabla (create table - sp_tables -

Cada registro contiene un dato por cada columna de la tabla.

Las tablas forman parte de una base de datos.

Nosotros trabajaremos con la base de datos llamada wi520641_sqlserverya (este nombre

El parámetro @table_owner='dbo' indica que solo muestre las tablas de usuarios y no

La sintaxis básica y general para crear una tabla es la siguiente:

create table NOMBRETABLA(

create table usuarios (

 nombre: que contendrá una cadena de caracteres de 30 caracteres de longitud,

Para ver la estructura de una tabla usamos el procedimiento almacenado "sp_columns"

Aparece mucha información que no analizaremos en detalle, como el nombre de la

drop table usuarios;

if object_id('usuarios') is not null

En la sentencia precedente especificamos que elimine la tabla "usuarios" si existe.

2- Intente crear una tabla llamada "/agenda":

create table agenda(apellido varchar(30), 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).

8- Intente eliminar la tabla, sin controlar si existe. Debe aparecer

La sintaxis básica y general es la siguiente:

insert into NOMBRETABLA (NOMBRECAMPO1, ..., NOMBRECAMPOn)

Para agregar un registro a la tabla tipeamos:

insert into usuarios (nombre, clave) values ('Mariano','payaso');

Para ver los registros de una tabla usamos "select":

select * from usuarios;

insert into usuarios (clave, nombre) values ('River','Juan');

En el ejemplo anterior se nombra primero el campo "clave" y luego el campo "nombre"

insert into usuarios (nombre,clave) values ('Boca','Luis');

Trabaje con la tabla "agenda" que almacena información de sus amigos.

3- Visualice las tablas existentes para verificar la creación de

4- Visualice la estructura de la tabla "agenda" (sp_columns).

5- Ingrese los siguientes registros:

6- Seleccione todos los registros de la tabla:

7- Elimine la tabla "agenda":

8- Intente eliminar la tabla nuevamente (aparece un mensaje de error):

4 - Tipos de datos básicos

El tipo de dato especifica el tipo de información que puede guardar un campo:

 varchar: se usa para almacenar cadenas de caracteres. Una cadena es una

Si asignamos una cadena de caracteres de mayor longitud que la definida, la

 integer: se usa para guardar valores numéricos enteros, de -2000000000 a

Un videoclub que alquila películas en video almacena la información de

1- Elimine la tabla, si existe:

2- Cree la tabla eligiendo el tipo de dato adecuado para cada campo:

3- Vea la estructura de la tabla:

4- Ingrese los siguientes registros:

5- Muestre todos los registros.

if object_id('libros') is not null

-titulo, cadena de caracteres de 20 de longitud,

create table libros(

Vemos la estructura de la tabla:

Aparece la siguiente información:

...COLUMN_NAME TYPE_NAME LENGHT

Ingresamos algunos registros:

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

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

Aparece un mensaje de error y la sentencia no se ejecuta. vamos a cortar la cadena para