Indice del Manual de SQL SERVER 2005 POR ISMAEL DE LOS ANGELES JIMENEZ

Tema 1 - Objetivos y alcances del tutorial de Sql Server. Tema 2 - Insertar y recuperar registros de una tabla (insert into-select) Tema 3 - Tipos de datos bsicos Tema 4 - Tipos de datos bsicos Tema 5 - Recuperar algunos campos (select) Tema 6 - Recuperar algunos registros (where) Tema 7 - Operadores relacionales Tema 8 - Borrar registros (delete) Tema 9 - Actualizar registros (update) Tema 10 - Comentarios Tema 11 - Valores null (is null) Tema 12 - Clave primaria Tema 13 - Campo con atributo Identity Tema 14 - Truncate table Tema 15 - Otros tipos de datos en SQL Server Tema 16 - Tipo de dato (numrico) Tema 17 - Tipo de dato (fecha y hora) Tema 18 - Ingresar algunos campos (insert into) Tema 19 - Valores por defecto (default) Tema 20 - Crear un Alias Tema 21 - Fuciones Tema 22 - Funciones para el manejo de cadenas

Tema 1- Objetivos y alcances del tutorial de Microsoft Sql Server

El curso brinda un concepto terico corto, luego un problema resuelto que invito a ejecutar, modificar y jugar con el mismo. Por ltimo, y lo ms importante, una serie de ejercicios propuestos que nos permitir saber si podemos aplicar el concepto. La nica herramienta que necesitamos inicialmente es este sitio ya que podr ejecutar todos los problemas como son la creacin de tablas, insert, delete, update, definicin de ndices y restricciones, creacin y ejecucin de procedimientos almacenados, vistas, subconsultas, creacin de trigger etc. La nica restriccin es que todos los visitantes de este sitio comparten la misma base de datos llamada: wi520641_sqlserverya (este nombre un poco singular se debe a que las empresas de hosting es la que lo define) Siempre que lancemos un comando SQL en el sitio www.sqlserverya.com.ar estaremos accediendo a la base de datos wi520641_sqlserverya.

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

Al crear una tabla debemos resolver qu campos (columnas) tendr y que tipo de datos almacenarn cada uno de ellos, es decir, su estructura. La sintaxis bsica y general para crear una tabla es la siguiente:

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

COLUMN_NAME TYPE_NAME LENGHT _______________________________________________ Nombre varchar 30 Clave varchar 10 _______________________________________________

Para eliminar una tabla usamos "drop table" junto al nombre de la tabla a eliminar: drop table usuarios; Si intentamos eliminar una tabla que no existe, aparece un mensaje de error indicando tal situacin y la sentencia no se ejecuta. Para evitar este mensaje podemos agregar a la instruccin lo siguiente: if object_id('usuarios') is not null drop table usuarios; En la sentencia precedente especificamos que elimine la tabla "usuarios" si existe.

Problema: Vamos a crear una tabla llamada "usuarios". En primer lugar vamos a eliminar la tabla "usuarios" averiguando si existe (a esto vamos a repetirlo siempre porque puede haber otro usuario que haya creado una tabla con el mismo nombre): if object_id('usuarios') is not null drop table usuarios; Recordar que debemos finalizar cada comando con un punto y coma. La tabla "usuarios" contendr los siguientes campos: - nombre: varchar de 30 caracteres de longitud, - clave: varchar de 10 caracteres de longitud. Ahora si creamos la tabla: create table usuarios ( nombre varchar(30), clave varchar(10) ); Aparece un mensaje indicando que el comando se complet exitosamente.

Veamos las tablas existentes: sp_tables @table_owner='dbo'; Veamos la estructura de la tabla "usuarios": sp_columns usuarios; Aparece mucha informacin que no analizaremos en detalle, como el nombre de la tabla, su propietario, los campos y sus tipos de datos, su longitud, etc.: COLUMN_NAME TYPE_NAME LENGHT _______________________________________ Nombre varchar 30 Clave varchar 10 _______________________________________

Intentemos crear una tabla con el mismo nombre, mostrar un mensaje indicando que ya hay un objeto llamado 'usuarios' en la base de datos y la sentencia no se ejecutar:

create table usuarios ( Nombre varchar(30), Clave varchar(10) ); Eliminemos la tabla: drop table usuarios; Verifiquemos si se ha eliminado: sp_tables @table_owner='dbo';

no debe aparecer la tabla "usuarios".

if object_id('usuarios') is not null drop table usuarios; create table usuarios ( nombre varchar(30), clave varchar(10) ); sp_tables @table_owner='dbo'; sp_columns usuarios; create table usuarios ( nombre varchar(30), clave varchar(10) ); drop table usuarios; sp_tables @table_owner='dbo';

clave varchar(10) ); sp_tables @table_ow ner='dbo'; sp_columns usuarios; create table usuarios ( nombre varchar(30), clave varchar(10) ); drop table usuarios; sp_tables @table_ow ner='dbo';

Ejecutar los comandos SQL

Primer problema: Necesita almacenar los datos de sus amigos en una tabla. Los datos que guardar sern: apellido, nombre, domicilio y telfono. 1- Elimine la tabla "agenda" si existe: if object_id('agenda') is not null drop table agenda;

2- Intente crear una tabla llamada "/agenda": create table /agenda( apellido varchar(30), nombre varchar(20), domicilio varchar(30), telefono varchar(11) ); aparece un mensaje de error porque usamos un caracter invlido ("/") para el nombre. 3- Cree una tabla llamada "agenda", debe tener los siguientes campos: apellido, varchar(30); nombre,varchar(20); domicilio, varchar (30) 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.

Ver solucin

if object_id('agenda') is not null drop table agenda; create table /agenda( apellido varchar(30), nombre varchar(20), domicilio varchar(30), telefono varchar(11) ); create table agenda( apellido varchar(30), nombre varchar(20), domicilio varchar(30), telefono varchar(11) ); create table agenda( apellido varchar(30), nombre varchar(20), domicilio varchar(30), telefono varchar(11) ); sp_tables @table_owner='dbo'; sp_columns agenda; drop table agenda; drop table agenda;

Tema 2-Insertar y recuperar registros de una tabla (insert into-select)

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

Usamos "insert into", luego el nombre de la tabla, detallamos los nombres de los campos entre parntesis y separados por comas y luego de la clusula "values" colocamos los valores para cada campo, tambin entre parntesis y separados por comas.

Para agregar un registro a la tabla tipeamos: insert into usuarios (nombre, clave) values ('Mariano','payaso'); Note que los datos ingresados, como corresponden a cadenas de caracteres se colocan entre comillas simples. Para ver los registros de una tabla usamos "select":

select * from usuarios;

El comando "select" recupera los registros de una tabla. Con el asterisco indicamos que muestre todos los campos de la tabla "usuarios".

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

Recordar que debemos finalizar cada comando con un punto y coma. Creamos la tabla: create table usuarios( nombre varchar(30), clave varchar(10) ); Agregamos un registro a la tabla: insert into usuarios (nombre, clave) values ('Mariano','payaso'); Veamos si el registro se guard: select * from usuarios; Ingresemos otro registro alterando el orden de los campos: insert into usuarios (clave, nombre) values ('River','Juan'); Veamos cmo SQL Server almacen los datos: select * from usuarios; Ingresemos otro registro colocando los valores en distinto orden en que se nombran los campos: insert into usuarios (nombre,clave) values ('Boca','Luis'); Veamos cmo se guardaron los datos: select * from usuarios; Note que la cadena "Boca" se almacen en el campo "nombre" y la cadena "Luis" en el campo "clave". if object_id('usuarios') is not null drop table usuarios; create table usuarios( nombre varchar(30), clave varchar(10) ); insert into usuarios (nombre, clave) values ('Mariano','payaso'); select * from usuarios; insert into usuarios (clave, nombre) values ('River','Juan'); select * from usuarios; insert into usuarios (nombre,clave) values ('Boca','Luis'); select * from usuarios; Primer problema: Necesita almacenar los datos de sus amigos en una tabla. Los datos que guardar sern: apellido, nombre, domicilio y telfono. 1- Elimine la tabla "agenda" si existe: if object_id('agenda') is not null drop table agenda;

2- Intente crear una tabla llamada "/agenda": create table /agenda( apellido varchar(30), nombre varchar(20), domicilio varchar(30), telefono varchar(11) ); aparece un mensaje de error porque usamos un caracter invlido ("/") para el nombre. 3- Cree una tabla llamada "agenda", debe tener los siguientes campos: apellido, varchar(30); nombre, varchar(20); domicilio, varchar (30) 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. Ver solucin if object_id('agenda') is not null drop table agenda; create table /agenda( apellido varchar(30), nombre varchar(20), domicilio varchar(30), telefono varchar(11) ); create table agenda( apellido varchar(30), nombre varchar(20), domicilio varchar(30), telefono varchar(11) ); create table agenda( apellido varchar(30), nombre varchar(20), domicilio varchar(30), telefono varchar(11) );

sp_tables @table_owner='dbo'; sp_columns agenda; drop table agenda; drop table agenda;

Tema 3- Tipos de datos bsicos

Ya explicamos que al crear una tabla debemos resolver qu campos (columnas) tendr y que tipo de datos almacenar cada uno de ellos, es decir, su estructura.El tipo de dato especifica el tipo de informacin que puede guardar un campo: caracteres, nmeros, etc. Estos son algunos tipos de datos bsicos de SQL Server (posteriormente veremos otros):

varchar: se usa para almacenar cadenas de caracteres. Una cadena es una secuencia de caracteres. Se coloca entre comillas (simples); ejemplo: 'Hola', 'Juan Perez'. El tipo "varchar" define una cadena de longitud variable en la cual determinamos el mximo de caracteres entre parntesis. Puede guardar hasta 8000 caracteres. Por ejemplo, para almacenar cadenas de hasta 30 caracteres, definimos un campo de tipo varchar(30), es decir, entre parntesis, junto al nombre del campo colocamos la longitud. Si asignamos una cadena de caracteres de mayor longitud que la definida, la cadena no se carga, aparece un mensaje indicando tal situacin y la sentencia no se ejecuta. Por ejemplo, si definimos un campo de tipo varchar(10) e intentamos asignarle la cadena 'Buenas tardes', aparece un mensaje de error y la sentencia no se ejecuta.

integer: se usa para guardar valores numricos enteros, de -2000000000 a 2000000000 aprox. Definimos campos de este tipo cuando queremos representar, por ejemplo, cantidades. float: se usa para almacenar valores numricos con decimales. Se utiliza separador el punto (.). Definimos campos de este tipo para precios, por ejemplo. como

Antes de crear una tabla debemos pensar en sus campos y optar por el tipo de dato adecuado para cada uno de ellos.Por ejemplo, si en un campo almacenaremos nmeros enteros, el tipo "float" sera una mala eleccin; si vamos a guardar precios, el tipo "float" es ms adecuado, no as "integer" que no tiene decimales. Otro ejemplo, si en un campo vamos a guardar un nmero telefnico o un nmero de documento, usamos "varchar", no "integer" porque si bien son dgitos, con ellos no realizamos peraciones matemticas. Problema: 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 informacin de los libros de una librera necesitamos los siguientes campos: -titulo, cadena de caracteres de 20 de longitud, -autor, cadena de caracteres de 15 de longitud, -editorial, caracteres de 10 de longitud,

-precio, valor numrico con decimales y -cantidad, valor numrico entero. Al crear la tabla, entonces, elegimos el tipo de dato ms adecuado para cada campo: 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 numricos, no colocamos entre parntesis la longitud. Vemos la estructura de la tabla: sp_columns libros; Aparece la siguiente informacin: 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); insert into libros (titulo,autor,editorial,precio,cantidad) values ('Matematica estas ahi','Paenza','Siglo XXI',18.8,200); Note que al ingresar valores numricos (float e integer) no se utilizan comillas y para el separador de decimales se usa el caracter punto(.). Veamos los registros cargados: select * from libros; Veamos lo que sucede si intentamos ingresar para el campo "titulo" una cadena de ms de 20 caracteres: insert into libros (titulo,autor,editorial,precio,cantidad) 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: insert into libros (titulo,autor,editorial,precio,cantidad) values ('Alicia en el pais','Lewis Carroll','Atlantida',10,200); Veamos los registros cargados:

select * from libros; if object_id('libros') is not null drop table libros; create table libros( titulo varchar(20), autor varchar(15), editorial varchar(10), precio float, cantidad integer ); sp_columns libros; insert values insert values into libros (titulo,autor,editorial,precio,cantidad) ('El aleph','Borges','Emece',25.50,100); into libros (titulo,autor,editorial,precio,cantidad) ('Matematica estas ahi','Paenza','Siglo XXI',18.8,200);

select * from libros; insert values insert values select into libros (titulo,autor,editorial,precio,cantidad) ('Alicia en el pais de las maravillas','Lewis Carroll','Atlantida',10,200); into libros (titulo,autor,editorial,precio,cantidad) ('Alicia en el pais','Lewis Carroll','Atlantida',10,200); * from libros;

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

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

5- Muestre todos los registros. Ver solucin

if object_id('peliculas')is not null drop table peliculas; create table peliculas( nombre varchar(20), actor varchar(20), duracion integer, cantidad integer ); sp_columns peliculas; insert values insert values insert values insert values into peliculas (nombre, actor, duracion, cantidad) ('Mision imposible','Tom Cruise',128,3); into peliculas (nombre, actor, duracion, cantidad) ('Mision imposible 2','Tom Cruise',130,2); into peliculas (nombre, actor, duracion, cantidad) ('Mujer bonita','Julia Roberts',118,3); into peliculas (nombre, actor, duracion, cantidad) ('Elsa y Fred','China Zorrilla',110,2);

select *from peliculas;

Tema 4 - Tipos de datos bsicos

Ya explicamos que al crear una tabla debemos resolver qu campos (columnas) tendr y que tipo de datos almacenar cada uno de ellos, es decir, su estructura. El tipo de dato especifica el tipo de informacin que puede guardar un campo: caracteres, nmeros, etc. Estos son algunos tipos de datos bsicos de SQL Server (posteriormente veremos otros): Varchar: se usa para almacenar cadenas de caracteres. Una cadena es una secuencia de caracteres. Se coloca entre comillas (simples); ejemplo: 'Hola', 'Juan Perez'. El tipo "varchar" define una cadena de longitud variable en la cual determinamos el mximo de caracteres entre parntesis. Puede guardar hasta 8000 caracteres. Por ejemplo, para almacenar cadenas de hasta 30 caracteres, definimos un campo de tipo varchar(30), es decir, entre parntesis, junto al nombre del campo colocamos la longitud. Si asignamos una cadena de caracteres de mayor longitud que la definida, la cadena no se carga, aparece un mensaje indicando tal situacin y la sentencia no se ejecuta. Por ejemplo, si definimos un campo de tipo varchar(10) e intentamos asignarle la cadena 'Buenas tardes', aparece un mensaje de error y la sentencia no se ejecuta. Integer: se usa para guardar valores numricos enteros, de -2000000000 a 2000000000 aprox. Definimos campos de este tipo cuando queremos representar, por ejemplo, cantidades. Float: se usa para almacenar valores numricos con decimales. Se utiliza como separador el punto (.). Definimos campos de este tipo para precios, por ejemplo. Antes de crear una tabla debemos pensar en sus campos y optar por el tipo de dato adecuado para cada uno de ellos. Por ejemplo, si en un campo almacenaremos nmeros enteros, el tipo "float" sera una mala eleccin; si vamos a guardar precios, el tipo "float" es ms adecuado, no as "integer" que no tiene decimales. Otro ejemplo, si en un campo vamos a guardar un nmero telefnico o un nmero de documento, usamos "varchar", no "integer" porque si bien son dgitos, con ellos no realizamos operaciones matemticas. Problema: Vamos a crear una tabla llamada "libros". En primer lugar vamos a eliminar la tabla "libros" averiguando si existe: if object_id('libros') is not null drop table libros; Para almacenar informacin de los libros de una librera necesitamos los siguientes campos: -titulo, cadena de caracteres de 20 de longitud, -autor, cadena de caracteres de 15 de longitud, -editorial, caracteres de 10 de longitud, -precio, valor numrico con decimales y -cantidad, valor numrico entero. Al crear la tabla, entonces, elegimos el tipo de dato ms adecuado para cada campo: 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 numricos, no colocamos entre parntesis la longitud. Vemos la estructura de la tabla: sp_columns libros;

Aparece la siguiente informacin: 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); Insert into libros (titulo,autor,editorial,precio,cantidad) Values ('Matematica estas ahi','Paenza','Siglo XXI',18.8,200); Note que al ingresar valores numricos (float e integer) no se utilizan comillas y para el separador de decimales se usa el caracter punto(.). Veamos los registros cargados: Select * from libros; Veamos lo que sucede si intentamos ingresar para el campo "titulo" una cadena de ms de 20 caracteres: Insert into libros (titulo,autor,editorial,precio,cantidad) 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: Insert into libros (titulo,autor,editorial,precio,cantidad) Values ('Alicia en el pais','Lewis Carroll','Atlantida',10,200); Veamos los registros cargados: Select * from libros; If object_id('libros') is not null Drop table libros;

Create table libros ( Titulo varchar(20), Autor varchar(15), Editorial varchar(10), Precio float, Cantidad integer ); sp_columns libros; Insert Values Insert Values Select Insert Values Insert Values Select into libros (titulo,autor,editorial,precio,cantidad) ('El aleph','Borges','Emece',25.50,100); into libros (titulo,autor,editorial,precio,cantidad) ('Matematica estas ahi','Paenza','Siglo XXI',18.8,200); * from libros; into libros (titulo,autor,editorial,precio,cantidad) ('Alicia en el pais de las maravillas','Lewis Carroll','Atlantida',10,200); into libros (titulo,autor,editorial,precio,cantidad) ('Alicia en el pais','Lewis Carroll','Atlantida',10,200); * from libros;

Primer problema: Un videoclub que alquila pelculas en video almacena la informacin de sus pelculas en una tabla llamada "peliculas"; para cada pelcula necesita los siguientes datos: 1234nombre, cadena de caracteres de 20 de longitud, actor, cadena de caracteres de 20 de longitud, duracin, valor numrico entero. cantidad de copias: valor entero.

1- Elimine la tabla, si existe: If object_id('peliculas')is not null Drop table peliculas; 2- Cree la tabla eligiendo el tipo de dato adecuado para cada campo: Create table pelculas ( Nombre varchar(20), Actor varchar(20), Duracion integer, Cantidad integer ); 3- Vea la estructura de la tabla: 4- Ingrese los siguientes registros: Insert into peliculas (nombre, actor, duracion, cantidad) Values ('Mision imposible','Tom Cruise',128,3);

Insert Values Insert Values Insert Values

into peliculas (nombre, actor, duracion, cantidad) ('Mision imposible 2','Tom Cruise',130,2); into peliculas (nombre, actor, duracion, cantidad) ('Mujer bonita','Julia Roberts',118,3); into peliculas (nombre, actor, duracion, cantidad) ('Elsa y Fred','China Zorrilla',110,2);

5- Muestre todos los registros. Ver solucin

If object_id('peliculas')is not null Drop table peliculas; Create table pelculas ( Nombre varchar(20), Actor varchar(20), Duracion integer, Cantidad integer ); sp_columns peliculas;

insert values insert values insert values insert values

into peliculas (nombre, actor, duracion, cantidad) ('Mision imposible','Tom Cruise',128,3); into peliculas (nombre, actor, duracion, cantidad) ('Mision imposible 2','Tom Cruise',130,2); into peliculas (nombre, actor, duracion, cantidad) ('Mujer bonita','Julia Roberts',118,3); into peliculas (nombre, actor, duracion, cantidad) ('Elsa y Fred','China Zorrilla',110,2);

select *from peliculas;

Tema

5 - Recuperar algunos campos (select)

Hemos aprendido cmo ver todos los registros de una tabla, empleando la instruccin "select". La sintaxis bsica 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 separndolos por comas: Select titulo,autor from libros; La lista de campos luego del "select" selecciona los datos correspondientes a los campos nombrados. En el ejemplo anterior seleccionamos los campos "titulo" y "autor" de la tabla "libros", mostrando todos los registros. Los datos aparecen ordenados segn la lista de seleccin, en dicha lista los nombres de los campos se separan con comas.

Problema: Trabajamos con la tabla "libros" que almacena los datos de los libros de una librera. Eliminamos la tabla, si existe: if object_id('libros') is not null 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; Ingresamos algunos registros: insert into libros (titulo,autor,editorial,precio,cantidad) values ('El aleph','Borges','Emece',25.50,100); insert into libros (titulo,autor,editorial,precio,cantidad) values ('Alicia en el pais de las maravillas','Lewis Carroll','Atlantida',10,200); insert into libros (titulo,autor,editorial,precio,cantidad) values ('Matematica estas ahi','Paenza','Siglo XXI',18.8,200); Veamos todos los campos la tabla: select *from libros; Veamos solamente el ttulo, autor y editorial de todos los libros especificando los nombres de los campos separados por comas:

select Con la select Veamos select

titulo,autor,editorial from libros; siguiente sentencia seleccionamos los ttulos y precios de todos los libros: titulo,precio from libros; solamente la editorial y la cantidad de libros tipeamos: editorial,cantidad from libros;

if object_id('libros') is not null drop table libros; create table libros ( titulo varchar(40), autor varchar(30), editorial varchar(15), precio float, cantidad integer ); sp_columns libros; insert values insert values insert values into libros (titulo,autor,editorial,precio,cantidad) ('El aleph','Borges','Emece',25.50,100); into libros (titulo,autor,editorial,precio,cantidad) ('Alicia en el pais de las maravillas','Lewis Carroll','Atlantida',10,200); into libros (titulo,autor,editorial,precio,cantidad) ('Matematica estas ahi','Paenza','Siglo XXI',18.8,200);

select *from libros; select titulo,autor,editorial from libros; select titulo,precio from libros; select editorial,cantidad from libros; Primer problema: Un videoclub que alquila pelculas en video almacena la informacin de sus pelculas en alquiler en una tabla llamada "peliculas". 1- Elimine la tabla, si existe: if object_id('peliculas') is not null drop table peliculas; 2- Cree la tabla: create table pelculas ( 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);

insert values insert values insert values

into peliculas (titulo, actor, duracion, cantidad) ('Mision imposible 2','Tom Cruise',190,2); into peliculas (titulo, actor, duracion, cantidad) ('Mujer bonita','Julia Roberts',118,3); into peliculas (titulo, actor, duracion, cantidad) ('Elsa y Fred','China Zorrilla',110,2);

5- Realice un "select" mostrando solamente el ttulo y actor de todas las pelculas 6- Muestre el ttulo y duracin de todas las peliculas 7- Muestre el ttulo y la cantidad de copias

Ver solucin

if object_id('peliculas') is not null drop table peliculas; create table pelculas ( titulo varchar(20), actor varchar(20), duracion integer, cantidad integer ); sp_columns peliculas; insert into peliculas (titulo, actor, duracion, cantidad) values ('Mision imposible','Tom Cruise',180,3); insert into peliculas (titulo, actor, duracion, cantidad) values ('Mision imposible 2','Tom Cruise',190,2); insert into peliculas (titulo, actor, duracion, cantidad) values ('Mujer bonita','Julia Roberts',118,3); insert into peliculas (titulo, actor, duracion, cantidad) values ('Elsa y Fred','China Zorrilla',110,2); select titulo,actor from peliculas; select titulo,duracion from peliculas; select titulo,cantidad from peliculas;

Tema 6 - Recuperar algunos registros (where)

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

Para las condiciones se utilizan operadores relacionales (tema que trataremos ms adelante en detalle). El signo igual(=) es un operador relacional. Para la siguiente seleccin de registros especificamos una condicin que solicita los usuarios cuya clave es igual a "River": select nombre,clave from usuarios where clave='River'; Si ningn registro cumple la condicin establecida con el "where", no aparecer ningn registro. Entonces, con "where" establecemos condiciones para recuperar algunos registros. Para recuperar algunos campos de algunos registros combinamos en la consulta la lista de campos y la clusula "where": select nombre from usuarios where clave='River';

En la consulta anterior solicitamos el nombre de todos los usuarios cuya clave sea igual a "River".

Problema: Trabajamos con la tabla "usuarios" que consta de 2 campos: nombre de usuario y clave. Eliminamos la tabla, si existe: if object_id('usuarios') is not null drop table usuarios;

Creamos la tabla: create table usuarios ( nombre varchar(30), clave varchar(10) ); Vemos la estructura de la tabla: sp_columns usuarios; Ingresamos algunos registros: insert values insert values insert values insert values into usuarios (nombre, clave) ('Marcelo','Boca'); into usuarios (nombre, clave) ('JuanPerez','Juancito'); into usuarios (nombre, clave) ('Susana','River'); into usuarios (nombre, clave) ('Luis','River');

Realizamos una consulta especificando una condicin, queremos ver el usuario cuyo nombre es "Leonardo": select *from usuarios where nombre='Leonardo'; Queremos ver el nombre de los usuarios cuya clave es "River": select nombre from usuarios where clave='River'; Realizamos un "select" de los nombres de los usuarios cuya clave es "Santi": select nombre from usuarios where clave='Santi'; No se muestra ningn registro ya que ninguno cumple la condicin. if object_id('usuarios') is not null drop table usuarios; create table usuarios ( nombre varchar(30), clave varchar(10) ); 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'); select *from usuarios where nombre='Leonardo'; select nombre from usuarios where clave='River'; select nombre from usuarios where clave='Santi';

Primer problema: Trabaje con la tabla "agenda" en la que registra los datos de sus amigos. 1- Elimine "agenda", si existe: if object_id('agenda') is not null drop table agenda; 2- Cree la tabla, con los siguientes campos: 1234apellido (cadena de 30), nombre (cadena de 20), domicilio (cadena de 30) telefono (cadena de 11).

3- Visualice la estructura de la tabla "agenda". 4- Ingrese los siguientes registros: Acosta, Ana, Colon 123, 4234567; Bustamante, Betina, Avellaneda 135, 4458787; Lopez, Hector, Salta 545, 4887788; Lopez, Luis, Urquiza 333, 4545454; Lopez, Marisa, Urquiza 333, 4545454. 5- Seleccione todos los registros de la tabla 6- Seleccione el registro cuyo nombre sea "Marisa" (1 registro) 7- Seleccione los nombres y domicilios de quienes tengan apellido igual a "Lopez" (3 registros) 8- Muestre el nombre de quienes tengan el telfono "4545454" (2 registros)

Ver solucin if object_id('agenda') is not null drop table agenda; create table agenda ( apellido varchar(30), nombre varchar(20),

domicilio varchar(30), telefono varchar(11) ); sp_columns agenda; insert into agenda(apellido,nombre,domicilio,telefono) ('Acosta', 'Ana', 'Colon 123', '4234567'); insert into agenda(apellido,nombre,domicilio,telefono) ('Bustamante', 'Betina', 'Avellaneda 135', '4458787'); insert into agenda(apellido,nombre,domicilio,telefono) ('Lopez', 'Hector', 'Salta 545', '4887788'); insert into agenda(apellido,nombre,domicilio,telefono) ('Lopez', 'Luis', 'Urquiza 333', '4545454'); insert into agenda(apellido,nombre,domicilio,telefono) ('Lopez', 'Marisa', 'Urquiza 333', '4545454'); select *from agenda; select *from agenda where nombre='Marisa'; select nombre,domicilio from agenda where apellido='Lopez'; select nombre from agenda where telefono='4545454'; values values values values values

Tema 7 - Operadores relacionales

Estos son smbolos que permiten realizar operaciones matemticas, concatenar cadenas, hacer comparaciones. SQL Server tiene 4 tipos de operadores: 1234relacionales (o de comparacin) aritmticos de concatenacin lgicos.

Por ahora veremos solamente los primeros. Los operadores relacionales (o de comparacin) nos permiten comparar dos expresiones, que pueden ser variables, valores de campos, etc. Hemos aprendido a especificar condiciones de igualdad para seleccionar registros de una tabla; por ejemplo: select *from libros where autor='Borges';

Utilizamos el operador relacional de igualdad. Los operadores relacionales vinculan un campo con un valor para que SQL Server compare cada registro (el campo especificado) con el valor dado. Los operadores relacionales son los siguientes: = <> > < >= <= igual distinto mayor menor mayor o igual menor o igual

Podemos seleccionar los registros cuyo autor sea diferente de "Borges", para ello usamos la condicin: select * from libros where autor<>'Borges'; Podemos comparar valores numricos. Por ejemplo, queremos precios de los libros cuyo precio sea mayor a 20 pesos: mostrar los ttulos y

select titulo, precio from libros where precio>20; Queremos seleccionar los libros cuyo precio sea menor o igual a 30: select *from libros where precio<=30; Los operadores relacionales comparan valores del mismo tipo. Se emplean para comprobar si un campo cumple con una condicin.

No son los nicos, existen otros que veremos mas adelante.

Problema: Trabajamos con la tabla "libros" de una librera. Eliminamos la tabla "libros", si existe: if object_id('libros') is not null 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); insert into libros (titulo,autor,editorial,precio) values ('Martin Fierro','Jose Hernandez','Emece',16.00); insert into libros (titulo,autor,editorial,precio) values ('Aprenda PHP','Mario Molina','Emece',35.40); insert into libros (titulo,autor,editorial,precio) 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, slo el ttulo y precio: select titulo,precio from libros where precio>20; Note que el valor con el cual comparamos el campo "precio", como es numrico (float), no se coloca entre comillas. Los libros cuyo precio es menor o igual a 20 pesos no aparece en la seleccin.

Recuperamos aquellos libros cuyo precio es menor o igual a 30: select *from libros where precio<=30; if object_id('libros') is not null drop table libros;

create table libros ( titulo varchar(30), autor varchar(30), editorial varchar(15), precio float ); insert values insert values insert values insert values into libros (titulo,autor,editorial,precio) ('El aleph','Borges','Emece',24.50); into libros (titulo,autor,editorial,precio) ('Martin Fierro','Jose Hernandez','Emece',16.00); into libros (titulo,autor,editorial,precio) ('Aprenda PHP','Mario Molina','Emece',35.40); into libros (titulo,autor,editorial,precio) ('Cervantes y el quijote','Borges','Paidos',50.90);

select *from libros where autor<>'Borges'; select titulo,precio from libros where precio>20; select *from libros where precio<=30;

Primer problema: Un comercio que vende artculos de computacin registra los datos de sus artculos en una tabla con ese nombre. 1- Elimine "articulos", si existe: if object_id('articulos') is not null drop table articulos; 2- Cree la tabla, con la siguiente estructura: create table articulos( codigo integer, nombre varchar(20), descripcion varchar(30), precio float, cantidad integer ); 3- Vea la estructura de la tabla (sp_columns). 4- Ingrese algunos registros: insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (1,'impresora','Epson Stylus C45',400.80,20);

insert values insert values insert values insert values

into articulos (codigo, nombre, descripcion, (2,'impresora','Epson Stylus C85',500,30); into articulos (codigo, nombre, descripcion, (3,'monitor','Samsung 14',800,10); into articulos (codigo, nombre, descripcion, (4,'teclado','ingles Biswal',100,50); into articulos (codigo, nombre, descripcion, (5,'teclado','espaol Biswal',90,50);

precio,cantidad) precio,cantidad) precio,cantidad) precio,cantidad)

5- Seleccione los datos de las impresoras (2 registros) 6- Seleccione los artculos cuyo precio sea mayor o igual a 400 (3 registros) 7- Seleccione el cdigo y nombre de los artculos cuya cantidad sea menor a 30 (2 registros) 8- Selecciones el nombre y descripcin de los artculos que NO cuesten $100 (4 registros)

Ver solucin if object_id('articulos') is not null drop table articulos; create table articulos ( codigo integer, nombre varchar(20), descripcion varchar(30), precio float, cantidad integer );

sp_columns articulos;

insert values insert values insert values insert values insert values

into articulos (codigo, nombre, descripcion, precio,cantidad) (1,'impresora','Epson Stylus C45',400.80,20); into articulos (codigo, nombre, descripcion, precio,cantidad) (2,'impresora','Epson Stylus C85',500,30); into articulos (codigo, nombre, descripcion, precio,cantidad) (3,'monitor','Samsung 14',800,10); into articulos (codigo, nombre, descripcion, precio,cantidad) (4,'teclado','ingles Biswal',100,50); into articulos (codigo, nombre, descripcion, precio,cantidad) (5,'teclado','espaol Biswal',90,50);

select *from articulos where nombre='impresora'; select *from articulos where precio>=400; select codigo,nombre

from articulos where cantidad<30;

select nombre, descripcion from articulos where precio<>100;

Tema 8 - Borrar registros (delete)

Para eliminar los registros de una tabla usamos el comando "delete": delete from usuarios; Muestra un mensaje indicando la cantidad de registros que ha eliminado. Si no queremos eliminar todos los registros, sino solamente algunos, debemos indicar cul o cules, para ello utilizamos el comando "delete" junto con la clausula "where" con la cual establecemos la condicin que deben cumplir los registros a borrar. Por ejemplo, queremos eliminar aquel registro cuyo nombre de usuario es "Marcelo": delete from usuarios where nombre='Marcelo'; Si solicitamos el borrado de un registro que no existe, es decir, ningn registro cumple con la condicin especificada, ningn registro ser eliminado. Tenga en cuenta que si no colocamos una condicin, se eliminan todos los registros de la tabla nombrada.

Problema: Trabajamos con la tabla "usuarios". Eliminamos la tabla "usuarios", si existe: if object_id('usuarios') is not null drop table usuarios; 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'; Veamos el contenido de la tabla: select * from usuarios; Como ningn registro cumple con la condicin no se borran registros. Eliminamos todos los registros cuya clave es 'Boca': delete from usuarios where clave='Boca'; Veamos el contenido de la tabla: select * from usuarios; Eliminemos todos los registros: delete from usuarios; Veamos el contenido de la tabla: select * from usuarios; No hay registros. if object_id('usuarios') is not null drop table usuarios; create table usuarios ( nombre varchar(30), clave varchar(10) ); insert into usuarios (nombre,clave) values insert values insert values insert values select delete ('Marcelo','River'); into usuarios (nombre,clave) ('Susana','chapita'); into usuarios (nombre,clave) ('CarlosFuentes','Boca'); into usuarios (nombre,clave) ('FedericoLopez','Boca'); *from usuarios; from usuarios

where nombre='Marcelo'; select * from usuarios; delete from usuarios where nombre='Marcelo'; select * from usuarios; delete from usuarios where clave='Boca'; select * from usuarios; delete from usuarios; select * from usuarios; Primer problema: Trabaje con la tabla "agenda" que registra la informacin referente a sus amigos. 1- Elimine la tabla si existe: if object_id('agenda') is not null drop table agenda; 2- Cree la tabla con los siguientes campos: 1- apellido (cadena de 30), 22- nombre (cadena de 20), 3- domicilio (cadena de 30) 4- telefono (cadena de 11): create table agenda ( apellido varchar(30), nombre varchar(20), domicilio varchar(30), telefono varchar(11) ); 3- Ingrese los siguientes registros (insert into): Alvarez,Alberto,Colon 123,4234567, Juarez,Juan,Avellaneda 135,4458787, Lopez,Maria,Urquiza 333,4545454, Lopez,Jose,Urquiza 333,4545454, Salas,Susana,Gral. Paz 1234,4123456. 4- Elimine el registro cuyo nombre sea "Juan" (1 registro afectado) 5- Elimine los registros cuyo nmero telefnico sea igual a "4545454" (2 registros afectados): 6- Muestre la tabla. 7- Elimine todos los registros (2 registros afectados): 8- Muestre la tabla. Ver solucin

if object_id('agenda') is not null drop table agenda; create table agenda ( apellido varchar(30),

nombre varchar(20), domicilio varchar(30), telefono varchar(11) );

insert into agenda (apellido,nombre,domicilio,telefono) values('Alvarez','Alberto','Colon 123','4234567'); insert into agenda (apellido,nombre,domicilio,telefono) values('Juarez','Juan','Avellaneda 135','4458787'); insert into agenda (apellido,nombre,domicilio,telefono) values('Lopez','Maria','Urquiza 333','4545454'); insert into agenda (apellido,nombre,domicilio,telefono) values('Lopez','Jose','Urquiza 333','4545454'); insert into agenda (apellido,nombre,domicilio,telefono) values('Salas','Susana','Gral. Paz 1234','4123456');

delete from agenda where nombre='Juan'; delete from agenda where telefono='4545454'; select * from agenda; delete from agenda; select * from agenda;

Tema 9- Actualizar registros (update)

Decimos que actualizamos un registro cuando modificamos alguno de sus valores. Para modificar uno o varios datos de uno o varios registros utilizamos "update" (actualizar). Por ejemplo, en nuestra tabla "usuarios", queremos cambiar los valores de todas las claves, por "RealMadrid":

update usuarios set clave='RealMadrid'; Utilizamos "update" junto al nombre de la tabla y "set" junto con el campo a modificar y su nuevo valor. El cambio afectar a todos los registros. Podemos modificar algunos registros, para ello debemos establecer condiciones de seleccin con "where". Por ejemplo, queremos cambiar el valor correspondiente a la clave de nuestro usuario llamado "Federicolopez", queremos como nueva clave "Boca", necesitamos una condicin "where" que afecte solamente a este registro: update usuarios set clave='Boca' where nombre='Federicolopez'; Si Microsoft SQL Server no encuentra registros que cumplan con la condicin del "where", no se modifica ninguno. Las condiciones no son obligatorias, pero si omitimos la clusula "where", la actualizacin afectar a todos los registros. Tambin podemos actualizar varios campos en una sola instruccin: update usuarios set nombre='Marceloduarte', clave='Marce' 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. Trabajamos con la tabla "usuarios". Eliminamos la tabla si existe: if object_id('usuarios') is not null drop table usuarios; Creamos la tabla: create table usuarios ( nombre varchar(20), clave varchar(10) ); Ingresamos algunos registros:

insert into usuarios (nombre,clave)

values insert values insert values insert values

('Marcelo','River'); into usuarios (nombre,clave) ('Susana','chapita'); into usuarios (nombre,clave) ('Carlosfuentes','Boca'); into usuarios (nombre,clave) ('Federicolopez','Boca');

Cambiaremos los valores de todas las claves, por la cadena "RealMadrid": update usuarios set clave='RealMadrid'; El cambio afect a todos los registros, vemoslo: select *from usuarios; Necesitamos cambiar el valor de la clave del usuario llamado "Federicolopez" por "Boca": update usuarios set clave='Boca' where nombre='Federicolopez'; Verifiquemos que la actualizacin se realiz: select *from usuarios; Vimos que si Microsoft SQL Server no encuentra registros que cumplan con la condicin no se modifican registros: update usuarios set clave='payaso' where nombre='JuanaJuarez'; Si vemos la tabla veremos que no a cambiado: select *from usuarios; Para actualizar varios campos en una sola instruccin empleamos: update usuarios set nombre='Marceloduarte', clave='Marce' where nombre='Marcelo'; Si vemos la tabla: select *from usuarios; if object_id('usuarios') is not null drop table usuarios; create table usuarios ( nombre varchar(20), clave varchar(10) ); insert into usuarios (nombre,clave) values insert values insert values insert values ('Marcelo','River'); into usuarios (nombre,clave) ('Susana','chapita'); into usuarios (nombre,clave) ('Carlosfuentes','Boca'); into usuarios (nombre,clave) ('Federicolopez','Boca');

update usuarios set clave='RealMadrid'; select *from usuarios; update usuarios set clave='Boca' where nombre='Federicolopez'; select *from usuarios; update usuarios set clave='payaso' where nombre='JuanaJuarez'; select *from usuarios; update usuarios set nombre='Marceloduarte', clave='Marce' where nombre='Marcelo'; select *from usuarios; Primer problema: Trabaje con la tabla "agenda" que almacena los datos de sus amigos. 1- Elimine la tabla si existe: if object_id('agenda') is not null drop table agenda; 2- Cree la tabla: create table agenda ( apellido varchar(30), nombre varchar(20), domicilio varchar(30), telefono varchar(11) ); 3- Ingrese los siguientes registros (1 registro actualizado): insert values insert values insert values insert values insert values into agenda (apellido,nombre,domicilio,telefono) ('Acosta','Alberto','Colon 123','4234567'); into agenda (apellido,nombre,domicilio,telefono) ('Juarez','Juan','Avellaneda 135','4458787'); into agenda (apellido,nombre,domicilio,telefono) ('Lopez','Maria','Urquiza 333','4545454'); into agenda (apellido,nombre,domicilio,telefono) ('Lopez','Jose','Urquiza 333','4545454'); into agenda (apellido,nombre,domicilio,telefono) ('Suarez','Susana','Gral. Paz 1234','4123456');

4- Modifique el registro cuyo nombre sea "Juan" por "Juan Jose" (1 registro afectado) 5- Actualice los registros cuyo nmero telefnico sea igual a "4545454" por "4445566" (2 registros afectados) 6- Actualice los registros que tengan en el campo "nombre" el valor "Juan" por "Juan Jose" (ningn registro afectado porque ninguno cumple con la condicin del "where")

7 - Luego de cada actualizacin ejecute un select que muestre todos los registros de la tabla.

Ver solucin

if object_id('agenda') is not null drop table agenda; create table agenda ( apellido varchar(30), nombre varchar(20), domicilio varchar(30), telefono varchar(11) ); insert values insert values insert values insert values insert values into agenda (apellido,nombre,domicilio,telefono) ('Acosta','Alberto','Colon 123','4234567'); into agenda (apellido,nombre,domicilio,telefono) ('Juarez','Juan','Avellaneda 135','4458787'); into agenda (apellido,nombre,domicilio,telefono) ('Lopez','Maria','Urquiza 333','4545454'); into agenda (apellido,nombre,domicilio,telefono) ('Lopez','Jose','Urquiza 333','4545454'); into agenda (apellido,nombre,domicilio,telefono) ('Suarez','Susana','Gral. Paz 1234','4123456');

select * from agenda; update agenda set nombre='Juan Jose' where nombre='Juan'; select * from agenda; update agenda set telefono='4445566' where telefono='4545454'; select * from agenda; update agenda set nombre='Juan Jose' where nombre='Juan'; select * from agenda;

Tema 10 -Comentarios
Para aclarar algunas instrucciones, en ocasiones, necesitamos agregar comentarios. Es posible ingresar comentarios en la lnea de comandos, es decir, un texto que no se ejecuta; para ello se emplean dos guiones (--) al comienzo de la lnea: select * from libros --mostramos los registros de libros; en la lnea anterior, todo lo que est luego de los guiones (hacia la derecha) no se ejecuta. Para agregar varias lneas de comentarios, se coloca una barra seguida de un asterisco (/*) al comienzo del bloque de comentario y al finalizarlo, un asterisco seguido de una barra (*/). select titulo, autor /*mostramos ttulos y nombres de los autores*/ from libros; todo lo que est entre los smbolos "/*" y "*/" no se ejecuta.

Problema: Trabajamos con la tabla "libros" que almacena los datos de los libros de una librera. Eliminamos la tabla, si existe: if object_id('libros') is not null drop table libros; Creamos la tabla: create table libros ( titulo varchar(30), autor varchar(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 ttulo y autor de todos los libros y agregamos un bloque de comentarios: select titulo, autor /*mostramos ttulos y nombres de los autores*/ from libros;

Note que lo que est entre los smbolos no se ejecuta. if object_id('libros') is not null drop table libros; create table libros ( titulo varchar(30), autor varchar(20), editorial varchar(15) ); insert into libros (titulo,autor,editorial) values ('El aleph','Borges','Emece');

select * from libros --mostramos los registros de libros; select titulo, autor /*mostramos ttulos y nombres de los autores*/ from libros;

Tema 11 - Valores null (is null)

"null" significa "dato desconocido" o "valor inexistente". No es lo mismo que un valor "0", una cadena vaca o una cadena literal "null". A veces, puede desconocerse o no existir el dato correspondiente a algn campo de un registro. En estos casos decimos que el campo puede contener valores nulos.Por ejemplo, en nuestra tabla de libros, podemos tener valores nulos en el campo "precio" porque es posible que para algunos libros no le hayamos establecido el precio para la venta. En contraposicin, tenemos campos que no pueden estar vacos jams.Veamos un ejemplo. Tenemos nuestra tabla "libros". El campo "titulo" no debera estar vaco nunca, igualmente el campo "autor". Para ello, al crear la tabla, debemos especificar que dichos campos no admitan valores nulos: 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 definicin del campo. En el ejemplo anterior, los campos "editorial" y "precio" si admiten valores nulos. Cuando colocamos "null" estamos diciendo que admite valores nulos (caso del campo "editorial"); por defecto, es decir, si no lo aclaramos, los campos permiten valores nulos (caso del campo "precio"). Si ingresamos los datos de un libro, para el cual an no hemos definido el precio podemos colocar "null" para mostrar que no tiene precio: insert into libros (titulo,autor,editorial,precio) values('El aleph','Borges','Emece',null); Note que el valor "null" no es una cadena de caracteres, no se coloca entre comillas. Entonces, si un campo acepta valores nulos, podemos ingresar "null" cuando no conocemos el valor. Tambin podemos colocar "null" en el campo "editorial" si desconocemos el nombre de la editorial a la cual pertenece el libro que vamos a ingresar: insert into libros (titulo,autor,editorial,precio) values('Alicia en el pais','Lewis Carroll',null,25); Si intentamos ingresar el valor "null" en campos que no admiten valores nulos (como "titulo" o "autor"), SQL Server no lo permite, muestra un mensaje y la insercin no se realiza; por ejemplo: insert into libros (titulo,autor,editorial,precio) values(null,'Borges','Siglo XXI',25); Para ver cules campos admiten valores nulos y cules no, podemos emplear el procedimiento almacenado "sp_columns" junto al nombre de la tabla. Nos muestra mucha

informacin, en la columna "IS_NULLABLE" vemos que muestra "NO" en los campos que no permiten valores nulos y "YES" en los campos que si los permiten. Para recuperar los registros que contengan el valor "null" en algn campo, no podemos utilizar los operadores relacionales vistos anteriormente: = (igual) y <> (distinto); debemos utilizar los operadores "is null" (es igual a null) y "is not null" (no es null): 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 vaca. Entonces, para que un campo no permita valores nulos debemos especificarlo luego de definir el campo, agregando "not null". Por defecto, los campos permiten valores nulos, pero podemos especificarlo igualmente agregando "null". Problema: Trabajamos con la tabla "libros" de una librera. Eliminamos la tabla "libros", si existe: if object_id('libros') is not null drop table libros; Creamos la tabla especificando que los campos "titulo" y "autor" no admitan valores nulos: create table libros ( titulo varchar(30) not null, autor varchar(30) not null, editorial varchar(15) null, precio float ); Los campos "editorial" y "precio" si permiten valores nulos; el primero, porque lo especificamos colocando "null" en la definicin del campo, el segundo lo asume por defecto. Agregamos un registro a la tabla con valor nulo para el campo "precio": insert into libros (titulo,autor,editorial,precio) values('El aleph','Borges','Emece',null);

Recuerde que el valor "null" no es una cadena de caracteres, por lo tanto no se coloca entre comillas. Ingresamos otro registro, con valor nulo para el campo "editorial", campo que admite valores "null": insert into libros (titulo,autor,editorial,precio) values('Alicia en el pais','Lewis Carroll',null,0); Veamos lo que sucede si intentamos ingresar el valor "null" en campos que no lo admiten, como "titulo": insert into libros (titulo,autor,editorial,precio) values(null,'Borges','Siglo XXI',25); aparece un mensaje y la sentencia no se ejecuta. Para ver cules campos admiten valores nulos y cules no, empleamos el procedimiento almacenado "sp_columns": sp_columns libros; nos muestra muchas columnas, una de ellas tiene el encabezado "IS_NULLABLE", vemos que aparece "NO" en los campos que no permiten valores nulos y "YES" en los campos que si los permiten. Dijimos que el valor "null" no es lo mismo que una cadena vaca. Vamos a ingresar un registro con cadena vaca para el campo "editorial": insert into libros (titulo,autor,editorial,precio) values('Uno','Richard Bach','',18.50); Ingresamos otro registro, ahora cargamos una cadena vaca en el campo "titulo": insert into libros (titulo,autor,editorial,precio) values('','Richard Bach','Planeta',22); Veamos todos los regiustros ingresados: select *from libros; Recuperemos los registros que contengan el valor "null" en el campo "precio": 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 (desconocido); con la segunda, los libros cuyo precio es 0. Recuperemos los libros cuyo nombre de editorial es "null": select *from libros where editorial is null; Ahora veamos los libros cuya editorial almacena una cadena vaca: select *from libros es igual a "null"

where editorial=''; Para recuperar los libros cuyo precio no sea nulo tipeamos: select *from libros where precio is not null; if object_id('libros') is not null drop table libros; create table libros ( titulo varchar(30) not null, autor varchar(30) not null, editorial varchar(15) null, precio float ); insert into libros (titulo,autor,editorial,precio) values('El aleph','Borges','Emece',null); insert into libros (titulo,autor,editorial,precio) values('Alicia en el pais','Lewis Carroll',null,0); insert into libros (titulo,autor,editorial,precio) values(null,'Borges','Siglo XXI',25); sp_columns libros; insert into libros (titulo,autor,editorial,precio) values('Uno','Richard Bach','',18.50); insert into libros (titulo,autor,editorial,precio) values('','Richard Bach','Planeta',22); select *from libros; select *from libros where precio is null; select *from libros where precio=0; select *from libros where editorial is null; select *from libros where editorial=''; select *from libros where precio is not null;

Primer problema: Una farmacia guarda informacin referente a sus medicamentos en una tabla llamada "medicamentos". 1- Elimine la tabla, si existe: 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); insert into medicamentos (codigo,nombre,laboratorio,precio,cantidad) values(3,'Buscapina','Roche',null,200); 5- Vea todos los registros: select *from medicamentos; 6- Ingrese un laboratorio: registro con valor "0" para el precio y cadena vaca para el

insert into medicamentos (codigo,nombre, laboratorio,precio,cantidad) values(4,'Bayaspirina','',0,150); 7- Ingrese un registro con valor "0" para el cdigo y cantidad y cadena vaca para el nombre: insert into medicamentos (codigo,nombre,laboratorio,precio,cantidad) 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): insert into medicamentos (codigo,nombre,laboratorio,precio,cantidad) values(null,'Amoxidal jarabe','Bayer',25,120); 10- Recupere los registros que contengan valor "null" en el campo "laboratorio", luego los que tengan una cadena vaca en el mismo campo. Note que el resultado es diferente. 11- Recupere los registros que contengan valor "null" en el campo "precio", luego los que tengan el valor 0 en el mismo campo. Note que el resultado es distinto. 12- Recupere los registros cuyo laboratorio no contenga una cadena vaca, luego los que sean distintos de "null". Note que la salida de la primera sentencia no muestra los registros con cadenas vacas y tampoco los que tienen valor nulo; el resultado de la segunda sentencia muestra los registros con valor para el campo laboratorio (incluso cadena vaca). 13- Recupere los registros cuyo precio sea distinto de 0, luego los que sean distintos de "null": Note que la salida de la primera sentencia no muestra los registros con valor 0 y tampoco los que tienen valor nulo; el resultado de la segunda sentencia muestra los registros con valor para el campo precio (incluso el valor 0).

Ver solucin

if object_id('medicamentos') is not null drop table medicamentos; create table medicamentos ( codigo integer not null, nombre varchar(20) not null, laboratorio varchar(20), precio float, cantidad integer not null ); sp_columns medicamentos;

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); insert into medicamentos (codigo,nombre,laboratorio,precio,cantidad) values(3,'Buscapina','Roche',null,200); select *from medicamentos; insert into medicamentos (codigo,nombre, laboratorio,precio,cantidad)

values(4,'Bayaspirina','',0,150); insert into medicamentos (codigo,nombre,laboratorio,precio,cantidad) values(0,'','Bayer',15.60,0); select *from medicamentos; insert into medicamentos (codigo,nombre,laboratorio,precio,cantidad) values(null,'Amoxidal jarabe','Bayer',25,120); select *from medicamentos where laboratorio is null; select *from medicamentos where laboratorio=''; select *from medicamentos where precio is null; select *from medicamentos where precio=0; select *from medicamentos where laboratorio<>''; select *from medicamentos where laboratorio is not null; select *from medicamentos where precio<>0; select *from medicamentos where precio is not null;

Tema 12- Clave primaria

Una clave primaria es un campo (o varios) que identifica un solo registro (fila) en una tabla. Para un valor del campo clave existe solamente un registro. Veamos un ejemplo, si tenemos una tabla con datos de personas, el nmero de documento puede establecerse como clave primaria, es un valor que no se repite; puede haber personas con igual apellido y nombre, incluso el mismo domicilio (padre e hijo por ejemplo), pero su documento ser siempre distinto. Si tenemos la tabla "usuarios", el nombre de cada usuario puede establecerse como clave primaria, es un valor que no se repite; puede haber usuarios con igual clave, pero su nombre de usuario ser siempre diferente. Podemos establecer que un campo sea clave primaria al momento de crear la tabla o luego que ha sido creada. Vamos a aprender a establecerla al crear la tabla. Hay 2 maneras de hacerlo, por ahora veremos la sintaxis ms sencilla. Tenemos nuestra tabla "usuarios" definida con 2 campos ("nombre" y "clave"). La sintaxis bsica y general es la siguiente:
create table NOMBRETABLA ( CAMPO TIPO, ... primary key (NOMBRECAMPO) );

En el siguiente ejemplo definimos una clave primaria, para nuestra tabla "usuarios" para asegurarnos que cada usuario tendr un nombre diferente y nico:

create table usuarios( nombre varchar(20), clave varchar(10), primary key(nombre) ); Lo que hacemos agregar luego de la definicin de cada campo, "primary key" y entre parntesis, el nombre del campo que ser clave primaria. Una tabla slo puede tener una clave primaria. Cualquier campo (de cualquier tipo) puede ser clave primaria, debe cumplir como requisito, que sus valores no se repitan ni sean nulos. Por ello, al definir un campo como clave primaria, automticamente SQL Server lo convierte a "not null". Luego de haber establecido un campo como clave primaria, al ingresar los registros, SQL Server controla que los valores para el campo establecido como clave primaria no estn repetidos en la tabla; si estuviesen repetidos, muestra un mensaje y la insercin no se realiza. Es decir, si en nuestra tabla "usuarios" ya existe un usuario con nombre "juanperez" e intentamos ingresar un nuevo usuario con nombre "juanperez", aparece un mensaje y la instruccin "insert" no se ejecuta. Igualmente, si realizamos una actualizacin, SQL Server controla que los valores para el campo establecido como clave primaria no estn repetidos en la tabla, si lo estuviese, aparece un mensaje indicando que se viola la clave primaria y la actualizacin no se realiza.

Problema: Trabajamos con la tabla "usuarios". Eliminamos la tabla, si existe: if object_id('usuarios') is not null drop table usuarios; Creamos la tabla definiendo el campo "nombre" como clave primaria: create table usuarios( nombre varchar(20), clave varchar(10), primary key(nombre) ); Al campo "nombre" no lo definimos "not null", pero primaria, SQL Server lo convierte en "not null", "IS_NULLABLE" aparece "NO": sp_columns usuarios; Ingresamos algunos registros: insert into usuarios (nombre, clave) values ('juanperez','Boca'); insert into usuarios (nombre, clave) values ('raulgarcia','River'); Recordemos que cuando un campo es clave primaria, sus Intentamos ingresar un valor de clave primaria existente: valores no se repiten. al establecerse como clave veamos que en la columna

insert into usuarios (nombre, clave) values ('juanperez','payaso'); aparece un mensaje de error y la sentencia no se ejecuta. Cuando un campo es clave primaria, sus valores no pueden ingresar el valor "null" en el campo clave primaria: insert into usuarios (nombre, clave) values (null,'payaso'); aparece un mensaje de error y la sentencia no se ejecuta. Si realizamos alguna actualizacin, SQL Server controla que los valores para el campo establecido como clave primaria no estn repetidos en la tabla. Intentemos actualizar el nombre de un usuario colocando un nombre existente: update usuarios set nombre='juanperez' where nombre='raulgarcia'; aparece un mensaje indicando que se viola la clave primaria y la actualizacin no se realiza.

ser

nulos.

Intentamos

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

create table usuarios( nombre varchar(20), clave varchar(10), primary key(nombre) ); sp_columns usuarios; insert values insert values into usuarios (nombre, clave) ('juanperez','Boca'); into usuarios (nombre, clave) ('raulgarcia','River');

insert into usuarios (nombre, clave) values ('juanperez','payaso'); insert into usuarios (nombre, clave) values (null,'payaso'); update usuarios set nombre='juanperez' where nombre='raulgarcia';

Primer problema: Trabaje con la tabla "libros" de una librera. 1- Elimine la tabla si existe: if object_id('libros') is not null drop table libros; 2- Crela "codigo": con los siguientes campos, estableciendo como clave primaria el campo

create table libros( codigo int not null, titulo varchar(40) not null, autor varchar(20), editorial varchar(15), primary key(codigo) ); 3- Ingrese los siguientes registros: insert values insert values insert values into libros (codigo,titulo,autor,editorial) (1,'El aleph','Borges','Emece'); into libros (codigo,titulo,autor,editorial) (2,'Martin Fierro','Jose Hernandez','Planeta'); into libros (codigo,titulo,autor,editorial) (3,'Aprenda PHP','Mario Molina','Nuevo Siglo');

4- Ingrese un registro con cdigo repetido (aparece un mensaje de error) 5- Intente ingresar el valor "null" en el campo "codigo" 6- Intente actualizar el cdigo del libro "Martin Fierro" a "1" (mensaje de error)

Ver solucin if object_id('libros') is not null drop table libros; 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 insert values insert values (1,'El aleph','Borges','Emece'); into libros (codigo,titulo,autor,editorial) (2,'Martin Fierro','Jose Hernandez','Planeta'); into libros (codigo,titulo,autor,editorial) (3,'Aprenda PHP','Mario Molina','Nuevo Siglo');

insert into libros (codigo,titulo,autor,editorial) values (2,'Alicia en el pais de las maravillas','Lewis Carroll','Planeta'); insert into libros (codigo,titulo,autor,editorial) values (null,'Alicia en el pais de las maravillas','Lewis Carroll','Planeta'); update libros set codigo=1 where titulo='Martin Fierro';

Tema 13- Campo con atributo Identity

Un campo numrico puede tener un atributo extra "identity". Los valores de un campo con este atributo genera valores secuenciales que se inician en 1 y se incrementan en 1 automticamente. Se utiliza generalmente en campos correspondientes a cdigos de identificacin para generar valores nicos para cada nuevo registro que se inserta. Slo puede haber un campo "identity" por tabla. Para que un campo pueda establecerse como "identity", ste debe ser entero (tambin puede ser de un subtipo de entero o decimal con escala 0, tipos que estudiaremos posteriormente).Para que un campo genere sus valores automticamente, debemos agregar el atributo "identity" luego de su definicin 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 automticamente tomando el ltimo valor como referencia, o 1 si es el primero. Para ingresar registros omitimos el campo definido como "identity", por ejemplo: insert into libros (titulo,autor,editorial,precio) values('El aleph','Borges','Emece',23); Este primer registro ingresado guardar el valor 1 en el campo correspondiente al cdigo. Si continuamos ingresando registros, el cdigo (dato que no ingresamos) se cargar automticamente siguiendo la secuencia de utoincremento. 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". Problema:

Trabajamos con la tabla "libros" de una librera. Eliminamos la tabla "libros", si existe: if object_id('libros') is not null drop table libros; Creamos la tabla especificando que el campos "codigo" genere valores secuenciales comenzando en 1 e incrementndose en 1 automticamente: create table libros( codigo int identity, titulo varchar(40) not null, autor varchar(30), editorial varchar(15), precio float ); Ingresamos algunos registros, recordando que si un campo tiene el atributo "identity" debemos omitirlo en la insercin: insert into libros (titulo,autor,editorial,precio) values('El aleph','Borges','Emece',23); Veamos cmo se almacen: select *from libros; Este primer registro ingresado guarda el valor 1 en el campo correspondiente al cdigo. Continuemos ingresando registros: insert into libros (titulo,autor,editorial,precio) values('Uno','Richard Bach','Planeta',18); insert into libros (titulo,autor,editorial,precio) values('Aprenda PHP','Mario Molina','Siglo XXI',45.60); insert into libros (titulo,autor,editorial,precio) values('Alicia en el pais de maravillas','Lewis Carroll','Paidos',15.50); Veamos cmo se almacenaron: select *from libros; el cdigo (dato que no ingresamos) se carg automticamente siguiendo la secuencia de autoincremento. Intentemos ingresar un valor para el campo "codigo": insert into libros (codigo,titulo,autor,editorial,precio) values(5,'Martin Fierro','Jose Hernandez','Paidos',25); generar un mensaje de error. Un campo "identity" tampoco puede ser actualizado. Intentemos cambiar el valor de cdigo de un registro: update libros set codigo=9 where titulo='Uno'; aparece un mensaje de error. Vamos a ver la estructura de la tabla ejecutando el siguiente procedimiento almacenado: sp_columns libros;

Note que en el campo "codigo", en la columna "TYPE_NAME" aparece "int identity" y en la columna IS_NULLABLE" aparece "NO", porque un campo "identity" automticamente se convierte en "not null". En el campo "titulo", en la columna "IS_NULLABLE" aparece "NO" porque explcitamente indicamos que el campo fuera "not null". Eliminemos el ltimo registro: delete from libros where autor='Lewis Carroll'; Ingresamos un quinto registro y luego vemos que en el campo cdigo se guard el valor secuencial sin considerar que el valor "4" ya no existe: insert into libros (titulo, autor, editorial, precio) values('Martin Fierro','Jose Hernandez','Paidos',25); select *from libros; if object_id('libros') is not null drop table libros;

create table libros( codigo int identity, titulo varchar(40) not null, autor varchar(30), editorial varchar(15), precio float ); insert into libros (titulo,autor,editorial,precio) values('El aleph','Borges','Emece',23); select *from libros; insert into libros (titulo,autor,editorial,precio) values('Uno','Richard Bach','Planeta',18); insert into libros (titulo,autor,editorial,precio) values('Aprenda PHP','Mario Molina','Siglo XXI',45.60); insert into libros (titulo,autor,editorial,precio) values('Alicia en el pais de maravillas','Lewis Carroll','Paidos',15.50); select *from libros; insert into libros (codigo,titulo,autor,editorial,precio) values(5,'Martin Fierro','Jose Hernandez','Paidos',25); update libros set codigo=9 where titulo='Uno'; sp_columns libros; delete from libros where autor='Lewis Carroll'; insert into libros (titulo, autor, editorial, precio) values('Martin Fierro','Jose Hernandez','Paidos',25); select *from libros;

Primer problema: Una farmacia guarda informacin referente a sus medicamentos en una tabla llamada "medicamentos". 1- Elimine la tabla,si existe: if object_id('medicamentos') is not null drop table medicamentos; 2- Cree la tabla automticamente: con un campo "codigo" que genere valores secuenciales

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;

4- Ingrese los siguientes registros: insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Sertal','Roche',5.2,100); insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Buscapina','Roche',4.10,200); insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Amoxidal 500','Bayer',15.60,100); 5- Verifique que SQL Server gener valores para el campo "cdigo" de modo automtico: select *from medicamentos; 6- Intente ingresar un registro con un valor para el campo "codigo" 7- Intente actualizar un valor de cdigo (aparece un mensaje de error) 8- Elimine el registro con codigo "3" (1 registro eliminado) 9- Ingrese un nuevo registro: insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Amoxilina 500','Bayer',15.60,100); 10- Seleccione todos los registros para ver qu valor guard SQL Server en el campo cdigo: select *from medicamentos;

Ver solucin if object_id('medicamentos') is not null drop table medicamentos; create table medicamentos( codigo int identity, nombre varchar(20) not null,

laboratorio varchar(20), precio float, cantidad integer ); sp_columns medicamentos; insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Sertal','Roche',5.2,100); insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Buscapina','Roche',4.10,200); insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Amoxidal 500','Bayer',15.60,100);

select *from medicamentos; insert into medicamentos (codigo,nombre, laboratorio,precio,cantidad) values(4,'Amoxilina 500','Bayer',15.60,100); update medicamentos set codigo=5 where nombre='Bayaspirina'; delete from medicamentos where codigo=3; insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Amoxilina 500','Bayer',15.60,100); select *from medicamentos;

Otras caractersticas 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 comenzarn en "100" y se incrementarn de 2 en 2; es decir, el primer registro ingresado tendr el valor "100", los siguientes "102", "104", "106", etc. La funcin "ident_seed()" retorna el valor de inicio del campo "identity" de la tabla que nombramos: select ident_seed('libros'); La funcin "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 explcitamente un valor. Para permitir ingresar un valor en un campo de identidad se debe activar la opcin "identity_insert": set identity_insert libros on; Es decir, podemos ingresar valor en un campo "identity" seteando la opcin "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 repeticin de valores; por ello hay que tener cuidado al explicitar un valor porque se puede ingresar un valor repetido. Para desactivar la opcin "identity_insert" tipeamos: set identity_insert libros off; Problema: Trabajamos con la tabla "libros" de una librera. Eliminamos la tabla "libros", si existe: if object_id('libros') is not null drop table libros;

Creamos la tabla especificando que el campos "codigo" genere valores secuenciales comenzando en 100 e incrementndose en 2 automticamente: create table libros( codigo int identity(100,2), titulo varchar(20), autor varchar(30), precio float ); Ingresamos algunos registros, recordando que si un campo tiene el atributo "identity" debemos omitirlo en la insercin: insert into libros (titulo,autor,precio) values('El aleph','Borges',23); insert into libros (titulo,autor,precio) values('Uno','Richard Bach',18); insert into libros (titulo,autor,precio)

values('Aprenda PHP','Mario Molina',45.60); Veamos cmo se almacenaron: select *from libros; el cdigo (dato que no ingresamos) se carg automticamente, inicindose en 100 y siguiendo la secuencia de autoincremento (2). Para saber cul es el valor de inicio del campo "identity" de la tabla "libros" tipeamos: select ident_seed('libros'); retorna "2". Si intentamos ingresar un valor para el campo "codigo": insert into libros (codigo,titulo,autor,precio) values(106,'Martin Fierro','Jose Hernandez',25); generar un mensaje de error. Para permitir ingresar un valor "identity_insert": set identity_insert libros on;

en

un

campo

de

identidad

activamos

la

opcin

Recordemos que si "identity_insert" explicitar un valor:

est

en

ON,

la

instruccin

"insert"

DEBE

insert into libros (codigo,titulo,autor) values (100,'Matematica estas ahi','Paenza'); Note que ingresamos un valor de cdigo que ya existe; esto est permitido porque el atributo "identity" no implica unicidad. Ingresamos otro registro: insert into libros (codigo,titulo,autor) values (1,'Ilusiones','Richard Bach'); Note que ingresamos un valor de cdigo menor al valor de inicio de la secuencia, est permitido. 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) values ('Uno','Richard Bach'); Para desactivar la opcin "identity_insert" tipeamos: set identity_insert libros off; Intentemos ingresar un valor para el campo "codigo": insert into libros (codigo,titulo,autor) values (300,'Uno','Richard Bach'); aparece un mensaje de error. if object_id('libros') is not null drop table libros; create table libros (

codigo int identity(100,2), titulo varchar(20), autor varchar(30), precio float );

insert into libros (titulo,autor,precio) values('El aleph','Borges',23); insert into libros (titulo,autor,precio) values('Uno','Richard Bach',18); insert into libros (titulo,autor,precio) values('Aprenda PHP','Mario Molina',45.60); select *from libros; select ident_seed('libros'); insert into libros (codigo,titulo,autor,precio) values(106,'Martin Fierro','Jose Hernandez',25); set identity_insert libros on; insert into libros (codigo,titulo,autor) values (100,'Matematica estas ahi','Paenza'); insert into libros (codigo,titulo,autor) values (1,'Ilusiones','Richard Bach'); insert into libros (titulo,autor) values ('Uno','Richard Bach'); set identity_insert libros off; insert into libros (codigo,titulo,autor) values (300,'Uno','Richard Bach');

Primer problema: Una farmacia guarda informacin referente a sus medicamentos en una tabla llamada "medicamentos". 1- Elimine la tabla,si existe: if object_id('medicamentos') is not null drop table medicamentos; 2- Cree la tabla con un campo "codigo" que genere valores secuenciales automticamente comenzando en 10 e incrementndose en 1: create table medicamentos( codigo integer identity(10,1), nombre varchar(20) not null, laboratorio varchar(20), precio float,

cantidad integer ); 3- Ingrese los siguientes registros: insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Sertal','Roche',5.2,100); insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Buscapina','Roche',4.10,200); insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Amoxidal 500','Bayer',15.60,100);

4- Verifique que SQL Server gener valores para el campo "cdigo" de modo automtico: select *from medicamentos; 5- Intente ingresar un registro con un valor para el campo "codigo". 6- Setee la opcin "identity_insert" en "on" 7- Ingrese un nuevo registro sin valor para el campo "codigo" (no lo permite): insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Amoxilina 500','Bayer',15.60,100); 8- Ingrese un nuevo registro con valor para el campo "codigo" repetido. 9- Use la funcin "ident_seed()" "identity" de la tabla "medicamentos" para averiguar el valor de inicio del campo

10- Emplee la funcin "ident_incr()" para saber cul es el valor de incremento del campo "identity" de "medicamentos"

Ver solucin if object_id('medicamentos') is not null drop table medicamentos; create table medicamentos( codigo integer identity(10,1), nombre varchar(20) not null, laboratorio varchar(20), precio float, cantidad integer ); insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Sertal','Roche',5.2,100); insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Buscapina','Roche',4.10,200); insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Amoxidal 500','Bayer',15.60,100);

select *from medicamentos; insert into medicamentos (codigo,nombre, laboratorio,precio,cantidad) values(4,'Amoxilina 500','Bayer',15.60,100); set identity_insert medicamentos on; insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Amoxilina 500','Bayer',15.60,100); insert into medicamentos (codigo,nombre, laboratorio,precio,cantidad) values(10,'Amoxilina 500','Bayer',15.60,100); select ident_seed('medicamentos'); select ident_incr('medicamentos');

Tema 14- Truncate table

Aprendimos que para borrar todos los registro de una tabla se usa "delete" sin condicin "where". Tambin 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" vaca 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 vaca. La diferencia con "delete" es la velocidad, es ms rpido "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, contina con la secuencia teniendo en cuenta el valor mayor que se haba 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 ms alto de ese campo es "2", si borramos todos los registros con "delete" y luego ingresamos un registro, ste guardar el valor de cdigo "3"; si en cambio, vaciamos la tabla con "truncate table", al ingresar un nuevo registro el valor del cdigo se iniciar en 1 nuevamente.

Problema: Trabajamos con la tabla "libros" que almacena los datos de los libros de una librera. Eliminamos la tabla, si existe: if object_id('libros') is not null drop table libros; Creamos la tabla: create table libros( codigo int identity, titulo varchar(30), autor varchar(20), editorial varchar(15), precio float ); Agregamos algunos registros: insert values insert values into libros (titulo,autor,editorial,precio) ('El aleph','Borges','Emece',25.60); into libros (titulo,autor,editorial,precio) ('Uno','Richard Bach','Planeta',18);

Seleccionamos todos los registros: select *from libros;

Truncamos la tabla: truncate table libros; Ingresamos nuevamente algunos registros: insert into libros (titulo,autor,editorial,precio) values ('El aleph','Borges','Emece',25.60); insert into libros (titulo,autor,editorial,precio) values ('Uno','Richard Bach','Planeta',18); Si seleccionamos todos los registros vemos que la secuencia se reinici en 1: select *from libros; Eliminemos todos los registros con "delete": delete from libros; Ingresamos nuevamente algunos registros: insert values insert values into libros (titulo,autor,editorial,precio) ('El aleph','Borges','Emece',25.60); into libros (titulo,autor,editorial,precio) ('Uno','Richard Bach','Planeta',18);

Seleccionamos todos los registros y vemos que la secuencia continu: select *from libros; if object_id('libros') is not null drop table libros; create table libros( codigo int identity, titulo varchar(30), autor varchar(20), editorial varchar(15), precio float ); insert values insert values into libros (titulo,autor,editorial,precio) ('El aleph','Borges','Emece',25.60); into libros (titulo,autor,editorial,precio) ('Uno','Richard Bach','Planeta',18);

select *from libros; truncate table libros; insert values insert values into libros (titulo,autor,editorial,precio) ('El aleph','Borges','Emece',25.60); into libros (titulo,autor,editorial,precio) ('Uno','Richard Bach','Planeta',18);

select *from libros; delete from libros; insert into libros (titulo,autor,editorial,precio) values ('El aleph','Borges','Emece',25.60);

insert into libros (titulo,autor,editorial,precio) values ('Uno','Richard Bach','Planeta',18); select *from libros;

Tema 15- 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 ms precisos, segn el caso. El tipo de dato especificado en la definicin 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 ms tipos, incluso, subtipos. Los valores que podemos guardar son: TEXTO: Para almacenar texto usamos cadenas de caracteres. Las cadenas se colocan entre comillas simples. Podemos almacenar letras, smbolos y dgitos con los que no se realizan operaciones matemticas, por ejemplo, cdigos de identificacin, nmeros de documentos, nmeros telefnicos. SQL Server ofrece los siguientes tipos: char, nchar, varchar, nvarchar, text y ntext.

NUMEROS: Existe variedad de tipos numricos 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. 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 prximas. Entonces, cuando creamos una tabla y definir sus campos debemos elegir el tipo de dato ms preciso. Por ejemplo, si necesitamos almacenar nombres usamos texto; si un campo numrico almacenar solamente valores enteros el tipo "integer" es ms adecuado que, por ejemplo un "float"; si necesitamos almacenar precios, lo ms lgico es utilizar el tipo "money".

A continuacin analizaremos en detalle cada tipo de datos bsicos.

Tipos de datos (texto)

Ya explicamos que al crear una tabla debemos elegir la estructura adecuada, esto es, definir los campos y sus tipos ms precisos, segn el caso.Para almacenar TEXTO usamos cadenas de caracteres. Las cadenas se colocan entre comillas simples. Podemos almacenar letras, smbolos y dgitos con los que no se realizan operaciones matemticas, por ejemplo, cdigos de identificacin, nmeros de documentos, nmeros telefnicos.

Tenemos los siguientes tipos: varchar(x): define una cadena de caracteres de longitud variable en la cual determinamos el mximo de caracteres con el argumento "x" que va entre parntesis. Si se omite el argumento coloca 1 por defecto. Su rango va de 1 a 8000 caracteres.

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 ingls. text: guarda datos binarios de longitud variable, puede contener hasta 2000000000 caracteres. No admite argumento para especificar su longitud. 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. 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. 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 usarn los 3 primeros. Si intentamos almacenar en un campo una cadena de caracteres de mayor longitud que la definida, aparece un mensaje indicando tal situacin 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 numrico (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 hubisemos tipeado '12345', igualmente, si ingresamos el valor 23.56, lo convierte a '23.56'. Si el valor numrico, 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 segn el caso, el ms preciso.Para almacenar cadenas que varan en su longitud, es decir, no todos los registros tendrn 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 varan en su longitud, es decir, todos los registros tendrn la misma longitud en un campo determinado, se emplea "char". Por ejemplo, definimos un campo "codigo" que constar de 5 caracteres, todos los registros tendrn un cdigo de 5 caracteres, ni ms 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

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. Eliminamos la tabla "visitantes", si existe: if object_id('visitantes') is not null drop table visitantes; Creamos con la siguiente estructura: create table visitantes( nombre varchar(30), edad integer, sexo char(1), domicilio varchar(30), ciudad varchar(20), telefono varchar(11) ); Los campos "nombre", "domicilio" y "ciudad" almacenarn valores cuya longitud vara, por ello elegimos el tipo "varchar" y le damos a cada uno una longitud mxima estimando su tamao. El campo "sexo" se define de tipo "char", porque necesitamos solamente 1 caracter "f" o "m", que siempre ser fijo. El campo "telefono" tambin se define como varchar porque no todos los nmeros telefnicos tienen la misma longitud.

Intentamos ingresar una cadena de mayor longitud que la definida: insert into visitantes (nombre,edad,sexo,domicilio,ciudad,telefono) values ('Juan Juarez',32,'masc','Avellaneda 789','Cordoba','4234567'); aparece un mensaje de error y la sentencia no se ejecuta Ingresamos un nmero telefnico olvidando las comillas, es decir, numrico: insert into visitantes (nombre,edad,sexo,domicilio,ciudad,telefono) values ('Marcela Morales',43,'f','Colon 456','Cordoba',4567890); lo convierte a cadena, vemoslo: select *from visitantes; if object_id('visitantes') is not null drop table visitantes; create table visitants( nombre varchar(30), edad integer, sexo char(1), domicilio varchar(30), ciudad varchar(20), telefono varchar(11) como un valor

); insert into visitantes (nombre,edad,sexo,domicilio,ciudad,telefono) values ('Juan Juarez',32,'masc','Avellaneda 789','Cordoba','4234567'); insert into visitantes (nombre,edad,sexo,domicilio,ciudad,telefono) values ('Marcela Morales',43,'f','Colon 456','Cordoba',4567890); select *from visitantes; 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 ao, necesitamos 4 caracteres fijos. 3- Ingrese los siguientes registros: 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 ao 1990: select *from autos where modelo='1990'; Ver solucin

if object_id('autos') is not null drop table autos; create table autos( patente char(6), marca varchar(20), modelo char(4), precio float, primary key (patente) ); 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); select *from autos where modelo='1990';

Tema 16- Tipo de dato (numrico)

Ya explicamos que al crear una tabla debemos elegir la estructura adecuada, esto es, definir los campos y sus tipos ms precisos, segn 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 numricos 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 dgitos 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, tambin los bytes que ocupa. Se utiliza el punto como separador de decimales. Si ingresamos un valor con ms decimales que los permitidos, redondea al ms 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 numricos 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 slo 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 numricos: - si intentamos ingresar un valor fuera de rango, no lo permite. - si ingresamos una cadena, SQL Server intenta convertirla a valor numrico, si dicha cadena consta solamente de dgitos, la conversin 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 numrico, 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 numrico 12.22 y la ingresa; si intentamos ingresar la cadena '1234.56', la convierte al valor numrico 1234.56, pero como el mximo 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 conversin y muestra un mensaje de error. Es importante elegir el tipo de dato adecuado segn el caso, el ms preciso. Por ejemplo, si un campo numrico almacenar valores positivos menores a 255, el tipo "int" no es el ms 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".

Tipo Bytes de almacenamiento _______________________________________ int 4 smallint 2 tinyint 1 bigint 8 decimal 2 a 17 float 4 u 8 real 4 u 8 money 8 smallmoney 4 _________________________________________

Problema: Trabajamos con la tabla "libros" de una librera. Eliminamos la tabla, si existe: if object_id('libros') is not null drop table libros; Creamos la tabla con la siguiente estructura: create table libros( codigo smallint identity, titulo varchar(40) not null, autor varchar(30), editorial varchar(15), precio smallmoney, cantidad tinyint ); Note que definimos el campo "codigo" de tipo "smallint", esto es porque estimamos que no tendremos ms de 30000 libros. Si necesitramos un rango mayor podemos emplear "int".Como en el campo "precio" no almacenaremos valores mayores a 200000, definimos el campo de tipo "smallmoney".Tambin podemos definirlo de tipo "decimal(5,2)" porque el mximo precio no superar los 999.99. El tipo "float" no es el ms adecuado para representar precios porque no es exacto y muestra muchos decimales innecesarios. Como los valores para el campo "cantidad" no superarn los 255, definimos el campo de tipo "tinyint". Si estimamos que tendremos ms cantidad de libros podemos emplear "smallint" que tiene un rango mayor; no es adecuado usar int (cuyo rango llega hasta

4000 millones aprox.), porque insercin de datos numricos.

ocuparamos

ms

espacio

(4

bytes).Analicemos

la

Intentemos ingresar un valor fuera del rango definido, una cantidad que supera el rango del tipo "tinyint", el valor 260: insert into libros (titulo,autor,editorial,precio,cantidad) values('El aleph','Borges','Emece',25.60,260); aparece un mensaje de error y la insercin no se ejecuta. Intentamos ingresar un precio que supera el rango del tipo "smallmoney", el valor 250000: insert into libros (titulo,autor,editorial,precio,cantidad) values('El aleph','Borges','Emece',250000,100); aparece un mensaje de error y la instruccin no se ejecuta. Intentamos ingresar una cadena que SQL Server no pueda convertir a valor numrico en el campo "precio" (error): insert into libros (titulo,autor,editorial,precio,cantidad) values('Uno','Richard Bach','Planeta','a50.30',100); Ingresamos una cadena en el campo "cantidad": insert into libros (titulo,autor,editorial,precio,cantidad) values('Uno','Richard Bach','Planeta',50.30,'100'); lo convierte a valor numrico. if object_id('libros') is not null drop table libros; create table libros( codigo smallint identity, titulo varchar(40) not null, autor varchar(30), editorial varchar(15), precio smallmoney, cantidad tinyint ); insert into libros (titulo,autor,editorial,precio,cantidad) values('El aleph','Borges','Emece',25.60,260); insert into libros (titulo,autor,editorial,precio,cantidad) values('El aleph','Borges','Emece',250000,100); insert into libros (titulo,autor,editorial,precio,cantidad) values('Uno','Richard Bach','Planeta','a50.30',100); insert into libros (titulo,autor,editorial,precio,cantidad) values('Uno','Richard Bach','Planeta',50.30,'100'); select * from libros; Primer problema: Un banco tiene registrados las cuentas corrientes de sus clientes en una tabla llamada "cuentas".

La tabla contiene estos datos: Nmero 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: - Nmero 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. 3- Ingrese los siguientes registros: insert into cuentas(numero,documento,nombre,saldo) values('1234','25666777','Pedro Perez',500000.60); insert into cuentas(numero,documento,nombre,saldo) values('2234','27888999','Juan Lopez',-250000); insert into cuentas(numero,documento,nombre,saldo) values('3344','27888999','Juan Lopez',4000.50); insert into cuentas(numero,documento,nombre,saldo) values('3346','32111222','Susana Molina',1000); Note que hay dos cuentas, con distinto nmero de cuenta, de la misma persona. 4- Seleccione todos los registros cuyo saldo sea mayor a "4000" (2 registros) 5- Muestre el nmero 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 nmero es igual o mayor a "3000" (2 registros): select *from cuentas where numero>=3000; Ver solucin if object_id('cuentas') is not null drop table cuentas; create table cuentas( numero int not null, documento char(8), nombre varchar(30), saldo money,

primary key (numero) ); insert into cuentas(numero,documento,nombre,saldo) values('1234','25666777','Pedro Perez',500000.60); insert into cuentas(numero,documento,nombre,saldo) values('2234','27888999','Juan Lopez',-250000); insert into cuentas(numero,documento,nombre,saldo) values('3344','27888999','Juan Lopez',4000.50); insert into cuentas(numero,documento,nombre,saldo) values('3346','32111222','Susana Molina',1000); select *from cuentas where saldo<4000; select numero,saldo from cuentas where nombre='Juan Lopez'; select *from cuentas where saldo<0; select *from cuentas where numero>=3000;

Tema 17- Tipo de dato (fecha y hora)

Ya explicamos que al crear una tabla debemos elegir la estructura adecuada, esto es, definir los campos y sus tipos ms precisos, segn 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 ao) empleamos "set dateformat". Estos son los formatos: -mdy: 4/15/96 (mes y da con 1 2 dgitos y ao con 2 4 dgitos), -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 "da-mes-ao", tipeamos: set dateformat dmy; El formato por defecto es "mdy". Todos los valores de tipo "datetime" se muestran en formato "ao-mes-da 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' (ao de 2 dgitos), 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. Tipo Bytes de almacenamiento __________________________________ datetime 8 smalldatetime 4 __________________________________

Problema: Una empresa almacena los datos de sus empleados en una tabla "empleados". Eliminamos la tabla, si existe: if object_id('empleados') is not null drop table 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 da, mes y ao: set dateformat dmy; Ingresamos algunos registros: 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 dgitos correspondientes al ao; en el tercero empleamos la barra ('/') como separador y en el cuarto empleamos como separador el punto ('.') y colocamos un slo dgito en la part del da y el mes.Recuperamos los registros:

select *from empleados; Note que el formato de visualizacin 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; if object_id('empleados') is not null drop table empleados; create table empleados( nombre varchar(20), documento char(8), fechaingreso datetime );

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'); select select update select delete select *from empleados; *from empleados where fechaingreso<'01-01-1985'; empleados set nombre='Maria Carla Juarez' where fechaingreso='20.5.83'; *from empleados; from empleados where fechaingreso<>'20/05/1983'; *from empleados;

Primer problema: Una facultad almacena los datos de sus alumnos en una tabla denominada "alumnos". 1- Elimine la tabla, si existe: if object_id('alumnos') is not null drop table alumnos; 2- Cree la tabla eligiendo el tipo de dato adecuado para cada campo: 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 "dames-ao": set dateformat 'dmy'; 4- Ingrese un alumno empleando distintos separadores para las fechas: insert into alumnos values('Gonzalez','Ana','22222222','Colon 123','10-081990','15/02/1972'); 5- Ingrese otro alumno empleando solamente un dgito para da y mes y 2 para el ao: insert into alumnos values('Juarez','Bernardo','25555555','Sucre 456','03-031991','15/02/1972'); 6- Ingrese un alumnos empleando 2 dgitos para el ao 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-151990',null); aparece un mensaje de error porque lo lee con el formato da, mes y ao 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-ao". 12- Ingrese el registro del punto 7. Ver solucin

if object_id('alumnos') is not null drop table alumnos; create table alumnos( apellido varchar(30), nombre varchar(30), documento char(8), domicilio varchar(30), fechaingreso datetime, fechanacimiento datetime ); set dateformat 'dmy'; insert into alumnos 1990','15/02/1972'); values('Gonzalez','Ana','22222222','Colon 123','10-08-

insert into alumnos values('Juarez','Bernardo','25555555','Sucre 456','03-031991','15/02/1972'); insert into alumnos values('Perez','Laura','26666666','Bulnes 345','03-03-91',null); insert into alumnos values('Lopez','Carlos','27777777','Sarmiento 1254','03-151990',null); select *from alumnos where fechaingreso<'1-1-91'; select *from alumnos where fechanacimiento is null; insert into alumnos values('Rosas','Romina','28888888','Avellaneda 487','03151990',null); set dateformat 'mdy'; insert into alumnos values('Lopez','Carlos','27777777','Sarmiento 1254','03-151990',null);

Tema 18- 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'); Tambin 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 ms (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 clusula "default" (tema que veremos a continuacin). Problema: Trabajamos con la tabla "libros" que almacena los datos de los libros de una librera. Eliminamos la tabla, si existe: if object_id('libros') is not null drop table libros; Creamos la tabla: create table libros ( codigo int identity, titulo varchar(40) not null, autor varchar(30), editorial varchar(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 insercin no se realiza. Veamos cmo SQL Server almacen los registros: select *from libros; if object_id('libros') is not null drop table libros; create table libros ( codigo int identity, titulo varchar(40) not null, autor varchar(30), editorial varchar(15) ); insert into libros values ('Uno','Richard Bach','Planeta'); insert into libros (titulo, autor) values ('El aleph','Borges'); insert into libros (autor,editorial) values ('Lewis Carroll','Planeta'); select *from libros;

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

Ver solucin if object_id('cuentas') is not null drop table cuentas; create table cuentas ( numero int identity, documento char(8) not null, nombre varchar(30), saldo money ); insert into cuentas values (1,'25666777','Juan Perez',2500.50); insert into cuentas values ('25666777','Juan Perez',2500.50); insert into cuentas (documento,saldo) values ('28999777',-5500); insert into cuentas (numero,documento,nombre,saldo) values (5,'28999777','Luis Lopez',34000); insert into cuentas (numero,documento,nombre) values (3344,'28999777','Luis Lopez',34000); insert into cuentas (nombre, saldo) values ('Luis Lopez',34000); select *from libros;

Tema 19- 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 automaticamente "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 invlido. 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 explcitamente con la clusula "default". Para todos los tipos, excepto los declarados "identity", se pueden explicitar valores por defecto con la clusula "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 clusula "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. Tambin 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 predetermiandos para cada uno de sus campos. Entonces, la clusula "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" tomarn 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 clusula "default"; - si permite valores nulos y no tiene clusula "default", almacenar "null"; - si est declarado explcitamente "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 clusula "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 slo 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.

Problema: Trabajamos con la tabla "libros" de una librera. Eliminamos la tabla, si existe: if object_id('libros') is not null drop table libros; Creamos la tabla definiendo un valor por defecto para el campo "autor" y otro para el campo "cantidad": create table libros ( codigo int identity, titulo varchar(40), autor varchar(30) not null default 'Desconocido', editorial varchar(20), precio decimal(5,2), cantidad tinyint default 0 ); Ingresamos un registro omitiendo los valores para el campo "autor" y "cantidad": insert into libros (titulo,editorial,precio) values('Java en 10 minutos','Paidos',50.40); SQL Server ingresar el registro con el siguiente valor de la secuencia en "codigo", con el ttulo, editorial y precio ingresados, en "autor" colocar "Desconocido" y en cantidad "0": select *from libros; Si ingresamos un registro sin valor para el campo "precio", que admite valores nulos, se ingresar "null" en ese campo:

insert into libros (titulo,editorial) values('Aprenda PHP','Siglo XXI'); select *from libros; Visualicemos la estructura de la tabla: sp_columns libros; La columna "COLUMN_DEF", muestra el valor por defecto de cada campo. Podemos emplear "default" para dar el valor por defecto a algunos campos: insert into libros (titulo,autor,precio,cantidad) values ('El gato con botas',default,default,100); select *from libros; Como todos los campos de "libros" tienen valores predeterminados, podemos tipear: insert into libros default values; select *from libros; La sentencia anterior almacenar un registro con los valores predetermiandos para cada uno de sus campos. Que un campo tenga valor por defecto no significa que no admita valores nulos, puede o no admitirlos. Podemos ingresar el valor "null" en el campo "cantidad": insert into libros (titulo,autor,cantidad) values ('Alicia en el pais de las maravillas','Lewis Carroll',null); if object_id('libros') is not null drop table libros; 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 ); insert into libros (titulo,editorial,precio) values('Java en 10 minutos','Paidos',50.40); select *from libros; insert into libros (titulo,editorial) values('Aprenda PHP','Siglo XXI'); select *from libros; sp_columns libros;

insert into libros (titulo,autor,precio,cantidad) values ('El gato con botas',default,default,100);

select *from libros; insert into libros default values; select *from libros; insert into libros (titulo,autor,cantidad) values ('Alicia en el pais de las maravillas','Lewis Carroll',null);

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; 2- Cree la tabla con la siguiente estructura: 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 informacin de las columnas "COLUMN_DEF" y "IS_NULLABLE": sp_columns visitantes; 5- Ingrese algunos registros sin especificar valores para algunos campos para ver cmo opera la clusula "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".

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

create table visitants ( 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) ); sp_columns visitantes; insert values insert values select into visitantes (nombre, domicilio, montocompra) ('Susana Molina','Colon 123',59.80); into visitantes (nombre, edad, ciudad, mail) ('Marcos Torres',29,'Carlos Paz','marcostorres@hotmail.com'); *from visitantes;

insert into visitantes values ('Marcelo Morales',38,default,default,default,'4255232','marcelomorales@hotmail.com',default); insert into visitantes default values; select *from visitantes; Columnas calculadas (operadores aritmticos y de concatenacin)

Aprendimos que los operadores son smbolos que permiten realizar distintos tipos de operaciones. Dijimos que SQL Server tiene 4 tipos de operadores: 1) relacionales o de comparacin (los vimos), 2) lgicos (lo veremos ms adelante, 3) aritmticos y 4) de concatenacin. Los operadores aritmticos permiten realizar clculos con valores numricos. Son: multiplicacin (*), divisin (/) y mdulo (%) (el resto de dividir nmeros enteros), suma (+) y resta (-). Es posible obtener salidas en las cuales una columna sea el resultado de un clculo y no un campo de una tabla. Si queremos ver los ttulos, 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 ttulo podemos multiplicar el precio por la cantidad por cada ttulo, pero tambin podemos hacer que SQL Server realice el clculo 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 clculos: select titulo,precio, precio-(precio*0.1) from libros; Tambin podemos actualizar los datos empleando operadores aritmticos: update libros set precio=precio-(precio*0.1); Todas las operaciones matemticas retornan "null" en caso de error. Ejemplo: select 5/0; Los operadores de concatenacin: permite concatenar cadenas, el ms (+). Para concatenar el ttulo, el autor y la editorial de cada libro usamos el operador de concatenacin ("+"): select titulo+'-'+autor+'-'+editorial from libros; Note que concatenamos adems unos guiones para separar los campos. Trabajamos con la tabla "libros" de una librera. 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) ); Ingresamos algunos registros: insert into libros (titulo,autor,editorial,precio) values('El aleph','Borges','Emece',25); insert into libros values('Java en 10 minutos','Mario Molina','Siglo XXI',50.40,100); insert into libros (titulo,autor,editorial,precio,cantidad) 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); select *from libros; Queremos una columna con el ttulo, el autor y la editorial de cada libro: select titulo+'-'+autor+'-'+editorial from libros; if object_id ('libros') is not null drop table libros; 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) ); insert into libros (titulo,autor,editorial,precio) values('El aleph','Borges','Emece',25); insert into libros values('Java en 10 minutos','Mario Molina','Siglo XXI',50.40,100); insert into libros (titulo,autor,editorial,precio,cantidad) values('Alicia en el pais de las maravillas','Lewis Carroll','Emece',15,50); select titulo, precio,cantidad, precio*cantidad from libros; select titulo,precio, precio-(precio*0.1) from libros; update libros set precio=precio-(precio*0.1); select *from libros; select titulo+'-'+autor+'-'+editorial from libros;

Tema 20- Crear un Alias

Una manera de hacer ms 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 informacin 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 ms de una palabra, es necesario colocarla entre comillas simples: select nombre as 'Nombre y apellido', domicilio,telefono from agenda; Un alias puede contener hasta 128 caracteres. Tambin se puede crear un columnas calculadas. La palabra clave "as" es opcional en algunos casos, pero es conveniente Entonces, un "alias" se usa como nombre de un campo o de una expresin. casos, son opcionales, sirven para hacer ms comprensible el resultado; casos, que veremos ms adelante, son obligatorios. Trabajamos con nuestra tabla "agenda". Eliminamos la tabla si existe: if object_id('agenda') is not null drop table agenda; Creamos la tabla: create table agenda ( nombre varchar(30), domicilio varchar(30), telefono varchar(11) ); Ingresamos algunos registros: 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); alias para usarla. En estos en otros

Mostramos la informacin con el encabezado "NombreYApellido" para el campo "nombre":

select nombre as NombreYApellido, domicilio,telefono from agenda; Mostramos la informacin con el encabezado "Nombre y apellido" para el campo "nombre", necesitamos emplear comillas: select nombre as 'Nombre y apellido', domicilio,telefono from agenda; La palabra clave "as" es opcional, podemos obviarla: select nombre 'Nombre y apellido', domicilio,telefono from agenda;

if object_id('agenda') is not null drop table agenda; 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); select nombre as NombreYApellido, domicilio,telefono from agenda; select nombre as 'Nombre y apellido', domicilio,telefono from agenda;

select nombre 'Nombre y apellido', domicilio,telefono from agenda;

Tema 21 - Fuciones
Una funcin es un conjunto de sentencias que operan como una unidad lgica. Una funcin tiene un nombre, retorna un parmetro de salida y opcionalmente acepta parmetros 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 configuracin: retornan informacin referida a la configuracin. Ejemplo: select @@version; retorna la fecha, versin y tipo de procesador de SQL Server. - de cursores: retornan informacin sobre el estado de un cursor. - de fecha y hora: operan con valores "datetime" y "smalldatetime". Reciben un parmetro de tipo fecha y hora y retornan un valor de cadena, numrico o de fecha y hora. - matemticas: realizan operaciones numricas, geomtricas y trigonomtricas. - de metadatos: informan sobre las bases de datos y los objetos. - de seguridad: devuelven informacin referente a usuarios y funciones. - de cadena: operan con valores "char", "varchar", "nchar", "nvarchar", "binary" y "varbinary" y devuelven un valor de cadena o numrico. - del sistema: informan sobre opciones, objetos y configuraciones del sistema. Ejemplo: select user_name(); - estadsticas del sistema: retornan informacin referente al rendimiento del sistema. - texto e imagen: realizan operaciones con valor de entrada de tipo text o image y retornan informacin 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 expresin en una sentencia "select". Estudiaremos algunas de ellas.

Tema 22- 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 posicin 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 nmeros a caracteres; el primer parmetro indica el valor numrico a convertir, el segundo la longitud del resultado (debe ser mayor o igual a la parte entera del nmero ms 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 ingls. Ejemplo: se convierte el 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 numrico "123.456" a cadena: select str(123.456); retorna '123'; select str(123.456,3); retorna '123'; Si el segundo parmetro es menor a la parte entera del nmero, devuelve asteriscos (*). Ejemplo: select str(123.456,2,3); retorna "**". - stuff(cadena1,inicio,cantidad,cadena2): inserta la cadena enviada como cuarto argumento, en la posicin indicada en el segundo argumento, reemplazando la cantidad de caracteres indicada por el tercer argumento en la cadena que es primer parmetro. Stuff significa rellenar en ingls. Ejemplo: select stuff('abcde',3,2,'opqrs'); retorna "abopqrse". Es decir, coloca en la posicin 2 la cadena "opqrs" y reemplaza 2 caracteres de la primer cadena. Los argumentos numricos 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 carcter. valor numrico "123.456" a cadena, especificando 7 de

- len(cadena): retorna la longitud de la cadena enviada como argumento. "len" viene de length, que significa longitud en ingls. Ejemplo: select len('Hola'); devuelve 4. - char(x): retorna un caracter en cdigo 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 minsculas. lower significa reducir en ingls. Ejemplo:

select lower('HOLA ESTUDIAnte'); retorna "hola estudiante". -upper(cadena): retornan la cadena con todos los caracteres en maysculas. 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 posicin de comienzo (de la primera ocurrencia) del patrn 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 posicin donde comienza la subcadena en la cadena, comenzando la bsqueda desde la posicin indicada por "inicio". Si el tercer argumento no se coloca, la bsqueda 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: Trabajamos con la tabla "libros" de una librera. 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) ); Ingresamos algunos registros: insert into libros (titulo,autor,editorial,precio) values('El aleph','Borges','Emece',25); insert into libros values('Java en 10 minutos','Mario Molina','Siglo XXI',50.40,100); insert into libros (titulo,autor,editorial,precio,cantidad) values('Alicia en el pais de las maravillas','Lewis Carroll','Emece',15,50); Mostramos slo los 12 primeros caracteres de los ttulos de los libros y sus autores, empleando la funcin "substring()": select substring(titulo,1,12) as titulo from libros; Mostramos slo los 12 primeros caracteres de los ttulos de los libros y sus autores, ahora empleando la funcin "left()": select left(titulo,12) as titulo from libros; Mostramos los ttulos de los libros y sus precios convirtiendo este ltimo a cadena de caracteres con un solo decimal, empleando la funcin "str": select titulo, str(precio,6,1) from libros; Mostramos los ttulos 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 ttulos, autores y editoriales de todos libros, al ltimo campo lo queremos en maysculas: select titulo, autor, upper(editorial) from libros; if object_id ('libros') is not null drop table libros; 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) ); insert into libros (titulo,autor,editorial,precio) values('El aleph','Borges','Emece',25);

insert into libros values('Java en 10 minutos','Mario Molina','Siglo XXI',50.40,100); insert into libros (titulo,autor,editorial,precio,cantidad) values('Alicia en el pais de las maravillas','Lewis Carroll','Emece',15,50); select substring(titulo,1,12) as titulo from libros; select left(titulo,12) as titulo from libros; select titulo, str(precio,6,1) from libros; select titulo, str(precio) from libros; select titulo, autor, upper(editorial) from libros;