SQL Server 2000

82
El curso brinda un concepto teórico corto, luego un problema resuelto que invito a ejecutar, modificar y jugar con el mismo. Por último, y lo más importante, una serie de ejercicios propuestos que nos permitirá saber si podemos aplicar el concepto. La única herramienta que necesitamos inicialmente es este sitio ya que podrá ejecutar todos los problemas como son la creación de tablas, insert, delete, update, definición de índices y restricciones, creación y ejecución de procedimientos almacenados, vistas, subconsultas, creación de trigger etc. La única restricción es que todos los visitantes de este sitio comparten la misma base de datos llamada: wi520641_sqlserverya (este nombre un poco singular se debe a que las empresas de hosting es la que lo define) Siempre que lancemos un comando SQL en el sitio www.sqlserverya.com.ar estaremos accediendo a la base de datos wi520641_sqlserverya. Una base de datos almacena su información en tablas. Una tabla es una estructura de datos que organiza los datos en columnas y filas; cada columna es un campo (o atributo) y cada fila, un registro. La intersección de una columna con una fila, contiene un dato específico, un solo valor. Cada registro contiene un dato por cada columna de la tabla. Cada campo (columna) debe tener un nombre. El nombre del campo hace referencia a la información que almacenará. Cada campo (columna) también debe definir el tipo de dato que almacenará. Las tablas forman parte de una base de datos. Nosotros trabajaremos con la base de datos llamada wi520641_sqlserverya (este nombre se debe a que las empresas de hosting es la que lo define), que ya he creado en el servidor sqlserverya.com.ar.

Transcript of SQL Server 2000

Page 1: SQL Server 2000

El curso brinda un concepto teórico corto, luego un problema resuelto que invito a ejecutar, modificar y jugar con el mismo. Por último, y lo más importante, una serie de ejercicios propuestos que nos permitirá saber si podemos aplicar el concepto.

La única herramienta que necesitamos inicialmente es este sitio ya que podrá ejecutar todos los problemas como son la creación de tablas, insert, delete, update, definición de índices y restricciones, creación y ejecución de procedimientos almacenados, vistas, subconsultas, creación de trigger etc.

La única restricción es que todos los visitantes de este sitio comparten la misma base de datos llamada: wi520641_sqlserverya (este nombre un poco singular se debe a que las empresas de hosting es la que lo define)

Siempre que lancemos un comando SQL en el sitio www.sqlserverya.com.ar estaremos accediendo a la base de datos wi520641_sqlserverya.

Una base de datos almacena su información en tablas.

Una tabla es una estructura de datos que organiza los datos en columnas y filas; cada columna es un campo (o atributo) y cada fila, un registro. La intersección de una columna con una fila, contiene un dato específico, un solo valor.

Cada registro contiene un dato por cada columna de la tabla.Cada campo (columna) debe tener un nombre. El nombre del campo hace referencia a la información que almacenará.Cada campo (columna) también debe definir el tipo de dato que almacenará.

Las tablas forman parte de una base de datos.

Nosotros trabajaremos con la base de datos llamada wi520641_sqlserverya (este nombre se debe a que las empresas de hosting es la que lo define), que ya he creado en el servidor sqlserverya.com.ar.

Para ver las tablas existentes creadas por los usuarios en una base de datos usamos el procedimiento almacenado "sp_tables @table_owner='dbo';":

sp_tables @table_owner='dbo';

El parámetro @table_owner='dbo' indica que solo muestre las tablas de usuarios y no las que crea el SQL Server para administración interna.

Finalizamos cada comando con un punto y coma.

Al crear una tabla debemos resolver qué campos (columnas) tendrá y que tipo de datos almacenarán cada uno de ellos, es decir, su estructura.

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

create table NOMBRETABLA( NOMBRECAMPO1 TIPODEDATO, ...

Page 2: SQL Server 2000

NOMBRECAMPON TIPODEDATO );

La tabla debe ser definida con un nombre que la identifique y con el cual accederemos a ella.

Creamos una tabla llamada "usuarios" y entre paréntesis definimos los campos y sus tipos:

create table usuarios ( nombre varchar(30), clave varchar(10) );

Cada campo con su tipo debe separarse con comas de los siguientes, excepto el último.

Cuando se crea una tabla debemos indicar su nombre y definir al menos un campo con su tipo de dato. En esta tabla "usuarios" definimos 2 campos:

nombre: que contendrá una cadena de caracteres de 30 caracteres de longitud, que almacenará el nombre de usuario y

clave: otra cadena de caracteres de 10 de longitud, que guardará la clave de cada usuario.

Cada usuario ocupará un registro de esta tabla, con su respectivo nombre y clave.

Para nombres de tablas, se puede utilizar cualquier caracter permitido para nombres de directorios, el primero debe ser un caracter alfabético y no puede contener espacios. La longitud máxima es de 128 caracteres.

Si intentamos crear una tabla con un nombre ya existente (existe otra tabla con ese nombre), mostrará un mensaje indicando que ya hay un objeto llamado 'usuarios' en la base de datos y la sentencia no se ejecutará. Esto es muy importante ya que cuando haga los ejercicios en este sitio puede haber otra persona que haya creado una tabla con el nombre que usted especifique.

Para ver la estructura de una tabla usamos el procedimiento almacenado "sp_columns" junto al nombre de la tabla:

sp_columns usuarios;

aparece mucha información que no analizaremos en detalle, como el nombre de la tabla, su propietario, los campos, el tipo de dato de cada campo, su longitud, etc.:

...COLUMN_NAME TYPE_NAME LENGHT_______________________________________ nombre varchar 30 clave varchar 10

Para eliminar una tabla usamos "drop table" junto al nombre de la tabla a eliminar:

drop table usuarios;

Page 3: SQL Server 2000

Si intentamos eliminar una tabla que no existe, aparece un mensaje de error indicando tal situación y la sentencia no se ejecuta. Para evitar este mensaje podemos agregar a la instrucción lo siguiente:

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

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

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

2- Intente crear una tabla llamada "/agenda": create table /agenda( apellido varchar(30), nombre varchar(20), domicilio varchar(30), telefono varchar(11) );aparece un mensaje de error porque usamos un caracter inválido ("/") para el nombre.

3- Cree una tabla llamada "agenda", debe tener los siguientes campos: apellido, varchar(30); nombre, varchar(20); domicilio, varchar (30) y telefono, varchar(11): create table agenda( apellido varchar(30), nombre varchar(20), domicilio varchar(30), telefono varchar(11) );

4- Intente crearla nuevamente. Aparece mensaje de error.

5- Visualice las tablas existentes (sp_tables @table_owner='dbo').

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

7- Elimine la tabla.

8- Intente eliminar la tabla, sin controlar si existe. Debe aparecer un mensaje de error.

Ver solución

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

Page 4: SQL Server 2000

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;

Un registro es una fila de la tabla que contiene los datos propiamente dichos. Cada registro tiene un dato por cada columna (campo). Nuestra tabla "usuarios" consta de 2 campos, "nombre" y "clave".

Al ingresar los datos de cada registro debe tenerse en cuenta la cantidad y el orden de los campos.

La sintaxis básica y general es la siguiente:

insert into NOMBRETABLA (NOMBRECAMPO1, ..., NOMBRECAMPOn) values (VALORCAMPO1, ..., VALORCAMPOn);

Usamos "insert into", luego el nombre de la tabla, detallamos los nombres de los campos entre paréntesis y separados por comas y luego de la cláusula "values" colocamos los valores para cada campo, también entre paréntesis y separados por comas.

Para agregar un registro a la tabla tipeamos:

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

Note que los datos ingresados, como corresponden a cadenas de caracteres se colocan entre comillas simples.

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

select * from usuarios;

Page 5: SQL Server 2000

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

Es importante ingresar los valores en el mismo orden en que se nombran los campos:

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

En el ejemplo anterior se nombra primero el campo "clave" y luego el campo "nombre" por eso, los valores también se colocan en ese orden.

Si ingresamos los datos en un orden distinto al orden en que se nombraron los campos, no aparece un mensaje de error y los datos se guardan de modo incorrecto.

En el siguiente ejemplo se colocan los valores en distinto orden en que se nombran los campos, el valor de la clave (la cadena "Boca") se guardará en el campo "nombre" y el valor del nombre (la cadena "Luis") en el campo "clave":

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

Primer problema: Trabaje con la tabla "agenda" que almacena información de sus amigos.1- Elimine la tabla "agenda", si existe: if object_id('agenda') is not null drop table agenda;

2- Cree una tabla llamada "agenda". Debe tener los siguientes campos: apellido (cadena de 30), nombre (cadena de 20), domicilio (cadena de 30) y telefono (cadena de 11):

3- Visualice las tablas existentes para verificar la creación de "agenda" (sp_tables @table_owner='dbo').

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

5- Ingrese los siguientes registros: insert into agenda (apellido, nombre, domicilio, telefono) values ('Moreno','Alberto','Colon 123','4234567'); insert into agenda (apellido,nombre, domicilio, telefono) values ('Torres','Juan','Avellaneda 135','4458787');

6- Seleccione todos los registros de la tabla: select * from agenda;

7- Elimine la tabla "agenda": drop table agenda;

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

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

create table agenda( apellido varchar(30),

Page 6: SQL Server 2000

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

sp_tables @table_owner='dbo';

sp_columns agenda;

insert into agenda (apellido, nombre, domicilio, telefono) values ('Moreno','Alberto','Colon 123','4234567'); insert into agenda (apellido,nombre, domicilio, telefono) values ('Torres','Juan','Avellaneda 135','4458787');

select * from agenda;

drop table agenda;

drop table agenda;----------------------------

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 información que no analizaremos en detalle, como el nombre de la tabla, su propietario, los campos y sus tipos de datos, su longitud, etc.:

Page 7: SQL Server 2000

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

RESP:

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

Page 8: SQL Server 2000

clave varchar(10)

);

drop table usuarios;

sp_tables @table_owner='dbo';

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 información que puede guardar un campo: caracteres, números, etc.

Estos son algunos tipos de datos básicos de SQL Server (posteriormente veremos otros):

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

integer: se usa para guardar valores numéricos enteros, de -2000000000 a 2000000000 aprox. Definimos campos de este tipo cuando queremos representar, por ejemplo, cantidades.

float: se usa para almacenar valores numéricos con decimales. Se utiliza como separador el punto (.). Definimos campos de este tipo para precios, por ejemplo.

Antes de crear una tabla debemos pensar en sus campos y optar por el tipo de dato adecuado para cada uno de ellos.Por ejemplo, si en un campo almacenaremos números enteros, el tipo "float" sería una mala elección; si vamos a guardar precios, el tipo "float" es más adecuado, no así "integer" que no tiene decimales. Otro ejemplo, si en un campo vamos a guardar un número telefónico o un número de documento, usamos "varchar", no "integer" porque si bien son dígitos, con ellos no realizamos operaciones matemáticas.

Primer problema: Un videoclub que alquila películas en video almacena la información de sus películas en una tabla

Page 9: SQL Server 2000

llamada "peliculas"; para cada película necesita los siguientes datos: -nombre, cadena de caracteres de 20 de longitud, -actor, cadena de caracteres de 20 de longitud, -duración, valor numérico entero. -cantidad de copias: valor entero.

1- Elimine la tabla, si existe: if object_id('peliculas')is not null drop table peliculas;

2- Cree la tabla eligiendo el tipo de dato adecuado para cada campo: create table peliculas( nombre varchar(20), actor varchar(20), duracion integer, cantidad integer );

3- Vea la estructura de la tabla:

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

5- Muestre todos los registros.

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 into peliculas (nombre, actor, duracion, cantidad) values ('Mision imposible','Tom Cruise',128,3); insert into peliculas (nombre, actor, duracion, cantidad) values ('Mision imposible 2','Tom Cruise',130,2); insert into peliculas (nombre, actor, duracion, cantidad) values ('Mujer bonita','Julia Roberts',118,3); insert into peliculas (nombre, actor, duracion, cantidad) values ('Elsa y Fred','China Zorrilla',110,2);

select *from peliculas;Problema:

Page 10: SQL Server 2000

Vamos a crear una tabla llamada "libros". En primer lugar vamos a eliminar la tabla "libros" averiguando si existe:

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

Para almacenar información de los libros de una librería necesitamos los siguientes campos:

-titulo, cadena de caracteres de 20 de longitud, -autor, cadena de caracteres de 15 de longitud, -editorial, caracteres de 10 de longitud, -precio, valor numérico con decimales y -cantidad, valor numérico entero.

Al crear la tabla, entonces, elegimos el tipo de dato más adecuado para cada campo:

create table libros( titulo varchar(20), autor varchar(15), editorial varchar(10), precio float, cantidad integer );

Note que al especificar el tipo de dato de los campos numéricos, no colocamos entre paréntesis la longitud.

Vemos la estructura de la tabla:

sp_columns libros;

Aparece la siguiente información:

...COLUMN_NAME TYPE_NAME LENGHT_______________________________________ titulo varchar 20 autor varchar 15 editorial varchar 10 precio float 8 cantidad int 4

Ingresamos algunos registros:

insert into libros (titulo,autor,editorial,precio,cantidad) values ('El aleph','Borges','Emece',25.50,100); insert into libros (titulo,autor,editorial,precio,cantidad) values ('Matematica estas ahi','Paenza','Siglo XXI',18.8,200);

Note que al ingresar valores numéricos (float e integer) no se utilizan comillas y para el separador de decimales se usa el caracter punto(.).

Veamos los registros cargados:

select * from libros;

Page 11: SQL Server 2000

Veamos lo que sucede si intentamos ingresar para el campo "titulo" una cadena de más 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 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);

select * from libros;

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 ('Alicia en el pais','Lewis Carroll','Atlantida',10,200);

select * from libros;Final del formulario

Hemos aprendido cómo ver todos los registros de una tabla, empleando la instrucción "select".

La sintaxis básica y general es la siguiente:

select * from NOMBRETABLA;

El asterisco (*) indica que se seleccionan todos los campos de la tabla.

Podemos especificar el nombre de los campos que queremos ver separándolos por comas:

Page 12: SQL Server 2000

select titulo,autor from libros;

La lista de campos luego del "select" selecciona los datos correspondientes a los campos nombrados. En el ejemplo anterior seleccionamos los campos "titulo" y "autor" de la tabla "libros", mostrando todos los registros. Los datos aparecen ordenados según la lista de selección, en dicha lista los nombres de los campos se separan con comas.

Primer problema: Un videoclub que alquila películas en video almacena la información de sus películas 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 peliculas( titulo varchar(20), actor varchar(20), duracion integer, cantidad integer );

3- Vea la estructura de la tabla (sp_columns).

4- Ingrese alos siguientes registros: insert into peliculas (titulo, actor, duracion, cantidad) values ('Mision imposible','Tom Cruise',180,3); 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);

5- Realice un "select" mostrando solamente el título y actor de todas las películas

6- Muestre el título y duración de todas las peliculas

7- Muestre el título y la cantidad de copias

Ver solución

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

create table peliculas( titulo varchar(20), actor varchar(20), duracion integer, cantidad integer );

sp_columns peliculas;

insert into peliculas (titulo, actor, duracion, cantidad)

Page 13: SQL Server 2000

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;

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

create table peliculas( 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;

Segundo problema: Una empresa almacena los datos de sus empleados en una tabla llamada "empleados".

1- Elimine la tabla, si existe: if object_id('empleados') is not null drop table empleados;

2- Cree la tabla: create table empleados( nombre varchar(20), documento varchar(8), sexo varchar(1), domicilio varchar(30),

Page 14: SQL Server 2000

sueldobasico float );

3- Vea la estructura de la tabla: sp_columns empleados;

4- Ingrese algunos registros: insert into empleados (nombre, documento, sexo, domicilio, sueldobasico) values ('Juan Juarez','22333444','m','Sarmiento 123',500); insert into empleados (nombre, documento, sexo, domicilio, sueldobasico) values ('Ana Acosta','27888999','f','Colon 134',700); insert into empleados (nombre, documento, sexo, domicilio, sueldobasico) values ('Carlos Caseres','31222333','m','Urquiza 479',850);

5- Muestre todos los datos de los empleados

6- Muestre el nombre, documento y domicilio de los empleados

7- Realice un "select" mostrando el documento, sexo y sueldo básico de todos los empleados

RESP:if object_id('empleados') is not null drop table empleados;

create table empleados( nombre varchar(20), documento varchar(8), sexo varchar(1), domicilio varchar(30), sueldobasico float );

sp_columns empleados;

insert into empleados (nombre, documento, sexo, domicilio, sueldobasico) values ('Juan Juarez','22333444','m','Sarmiento 123',500); insert into empleados (nombre, documento, sexo, domicilio, sueldobasico) values ('Ana Acosta','27888999','f','Colon 134',700); insert into empleados (nombre, documento, sexo, domicilio, sueldobasico) values ('Carlos Caseres','31222333','m','Urquiza 479',850);

select *from empleados;

select nombre,documento,domicilio from empleados;

select documento,sexo,sueldobasico from empleados;

Hemos aprendido a seleccionar algunos campos de una tabla.También es posible recuperar algunos registros.

Existe una cláusula, "where" con la cual podemos especificar condiciones para una consulta "select". Es decir, podemos recuperar algunos registros, sólo los que cumplan

Page 15: SQL Server 2000

con ciertas condiciones indicadas con la cláusula "where". Por ejemplo, queremos ver el usuario cuyo nombre es "Marcelo", para ello utilizamos "where" y luego de ella, la condición:

select nombre, clave from usuarios where nombre='Marcelo';

La sintaxis básica y general es la siguiente:

select NOMBRECAMPO1, ..., NOMBRECAMPOn from NOMBRETABLA where CONDICION;

Para las condiciones se utilizan operadores relacionales (tema que trataremos más adelante en detalle). El signo igual(=) es un operador relacional.Para la siguiente selección de registros especificamos una condición que solicita los usuarios cuya clave es igual a "River":

select nombre,clave from usuarios where clave='River';

Si ningún registro cumple la condición establecida con el "where", no aparecerá ningún registro.

Entonces, con "where" establecemos condiciones para recuperar algunos registros.

Para recuperar algunos campos de algunos registros combinamos en la consulta la lista de campos y la cláusula "where":

select nombre from usuarios where clave='River';

En la consulta anterior solicitamos el nombre de todos los usuarios cuya clave sea igual a "River" 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: apellido (cadena de 30), nombre (cadena de 20), domicilio (cadena de 30) y telefono (cadena de 11).

3- Visualice la estructura de la tabla "agenda".

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.

Page 16: SQL Server 2000

5- Seleccione todos los registros de la tabla

6- Seleccione el registro cuyo nombre sea "Marisa" (1 registro)

7- Seleccione los nombres y domicilios de quienes tengan apellido igual a "Lopez" (3 registros)

8- Muestre el nombre de quienes tengan el teléfono "4545454" (2 registros)

Ver solución

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) values ('Acosta', 'Ana', 'Colon 123', '4234567');

insert into agenda(apellido,nombre,domicilio,telefono) values ('Bustamante', 'Betina', 'Avellaneda 135', '4458787');

insert into agenda(apellido,nombre,domicilio,telefono) values ('Lopez', 'Hector', 'Salta 545', '4887788'); insert into agenda(apellido,nombre,domicilio,telefono) values ('Lopez', 'Luis', 'Urquiza 333', '4545454'); insert into agenda(apellido,nombre,domicilio,telefono) values ('Lopez', 'Marisa', 'Urquiza 333', '4545454');

select *from agenda;

select *from agenda where nombre='Marisa';

select nombre,domicilio from agenda where apellido='Lopez';

select nombre from agenda where telefono='4545454';

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

Page 17: SQL Server 2000

sp_columns agenda;

insert into agenda(apellido,nombre,domicilio,telefono) values ('Acosta', 'Ana', 'Colon 123', '4234567');

insert into agenda(apellido,nombre,domicilio,telefono) values ('Bustamante', 'Betina', 'Avellaneda 135', '4458787');

insert into agenda(apellido,nombre,domicilio,telefono) values ('Lopez', 'Hector', 'Salta 545', '4887788'); insert into agenda(apellido,nombre,domicilio,telefono) values ('Lopez', 'Luis', 'Urquiza 333', '4545454'); insert into agenda(apellido,nombre,domicilio,telefono) values ('Lopez', 'Marisa', 'Urquiza 333', '4545454');

select *from agenda;

select *from agenda where nombre='Marisa';

select nombre,domicilio from agenda where apellido='Lopez';

select nombre from agenda where telefono='4545454';

Segundo problema: Trabaje con la tabla "libros" de una librería que guarda información referente a sus libros disponibles para la venta.

1- Elimine la tabla si existe.

2- Cree la tabla "libros". Debe tener la siguiente estructura: create table libros ( titulo varchar(20), autor varchar(30), editorial varchar(15));

3- Visualice la estructura de la tabla "libros".

4- Ingrese los siguientes registros: El aleph,Borges,Emece; Martin Fierro,Jose Hernandez,Emece; Martin Fierro,Jose Hernandez,Planeta; Aprenda PHP,Mario Molina,Siglo XXI;

5- Seleccione los registros cuyo autor sea "Borges" (1 registro)

6- Seleccione los títulos de los libros cuya editorial sea "Emece" (2 registros)

7- Seleccione los nombres de las editoriales de los libros cuyo titulo sea "Martin Fierro" (2 registros). if object_id('libros') is not null drop table libros;

Page 18: SQL Server 2000

create table libros ( titulo varchar(20), autor varchar(30), editorial varchar(15) );

sp_columns libros;

insert into libros(titulo,autor,editorial) values ('El aleph','Borges','Emece'); insert into libros(titulo,autor,editorial) values ('Martin Fierro','Jose Hernandez','Emece'); insert into libros(titulo,autor,editorial) values ('Martin Fierro','Jose Hernandez','Planeta'); insert into libros(titulo,autor,editorial) values ('Aprenda PHP','Mario Molina','Siglo XXI');

select *from libros where autor='Borges';

select titulo from libros where editorial='Emece';

select editorial from libros where titulo='Martin Fierro';

Los operadores son símbolos que permiten realizar operaciones matemáticas, concatenar cadenas, hacer comparaciones.

SQL Server tiene 4 tipos de operadores:

1. relacionales (o de comparación)2. aritméticos3. de concatenación4. lógicos.

Por ahora veremos solamente los primeros.

Los operadores relacionales (o de comparación) nos permiten comparar dos expresiones, que pueden ser variables, valores de campos, etc.

Hemos aprendido a especificar condiciones de igualdad para seleccionar registros de una tabla; por ejemplo:

select *from libros where autor='Borges';

Utilizamos el operador relacional de igualdad.

Los operadores relacionales vinculan un campo con un valor para que SQL Server compare cada registro (el campo especificado) con el valor dado.

Los operadores relacionales son los siguientes:

= igual

Page 19: SQL Server 2000

<> distinto> mayor< menor>= mayor o igual<= menor o igual

Podemos seleccionar los registros cuyo autor sea diferente de "Borges", para ello usamos la condición:

select * from libros where autor<>'Borges';

Podemos comparar valores numéricos. Por ejemplo, queremos mostrar los títulos y precios de los libros cuyo precio sea mayor a 20 pesos:

select titulo, precio from libros where precio>20;

Queremos seleccionar los libros cuyo precio sea menor o igual a 30:

select *from libros where precio<=30;

Los operadores relacionales comparan valores del mismo tipo. Se emplean para comprobar si un campo cumple con una condición.

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

Primer problema: Un comercio que vende artículos de computación registra los datos de sus artículos en una tabla con ese nombre.

1- Elimine "articulos", si existe: if object_id('articulos') is not null drop table articulos;

2- Cree la tabla, con la siguiente estructura: create table articulos( codigo integer, nombre varchar(20), descripcion varchar(30), precio float, cantidad integer );

3- Vea la estructura de la tabla (sp_columns).

4- Ingrese algunos registros: insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (1,'impresora','Epson Stylus C45',400.80,20); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (2,'impresora','Epson Stylus C85',500,30); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (3,'monitor','Samsung 14',800,10); insert into articulos (codigo, nombre, descripcion, precio,cantidad)

Page 20: SQL Server 2000

values (4,'teclado','ingles Biswal',100,50); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (5,'teclado','español Biswal',90,50);

5- Seleccione los datos de las impresoras (2 registros)

6- Seleccione los artículos cuyo precio sea mayor o igual a 400 (3 registros)

7- Seleccione el código y nombre de los artículos cuya cantidad sea menor a 30 (2 registros)

8- Selecciones el nombre y descripción de los artículos que NO cuesten $100 (4 registros)

Ver solución

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 into articulos (codigo, nombre, descripcion, precio,cantidad) values (1,'impresora','Epson Stylus C45',400.80,20); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (2,'impresora','Epson Stylus C85',500,30); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (3,'monitor','Samsung 14',800,10); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (4,'teclado','ingles Biswal',100,50); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (5,'teclado','español 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;

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

Page 21: SQL Server 2000

create table articulos( codigo integer, nombre varchar(20), descripcion varchar(30), precio float, cantidad integer );

sp_columns articulos;

insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (1,'impresora','Epson Stylus C45',400.80,20); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (2,'impresora','Epson Stylus C85',500,30); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (3,'monitor','Samsung 14',800,10); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (4,'teclado','ingles Biswal',100,50); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (5,'teclado','español 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;

Segundo problema: Un video club que alquila películas en video almacena la información de sus películas en alquiler en una tabla denominada "peliculas".

1- Elimine la tabla, si existe.

2- Cree la tabla eligiendo el tipo de dato adecuado para cada campo: create table peliculas( titulo varchar(20), actor varchar(20), duracion integer, cantidad integer );

3- Ingrese los siguientes registros: insert into peliculas (titulo, actor, duracion, cantidad) values ('Mision imposible','Tom Cruise',120,3); insert into peliculas (titulo, actor, duracion, cantidad) values ('Mision imposible 2','Tom Cruise',180,4);

Page 22: SQL Server 2000

insert into peliculas (titulo, actor, duracion, cantidad) values ('Mujer bonita','Julia R.',90,1); insert into peliculas (titulo, actor, duracion, cantidad) values ('Elsa y Fred','China Zorrilla',80,2);

4- Seleccione las películas cuya duración no supere los 90 minutos (2 registros)

5- Seleccione el título de todas las películas en las que el actor NO sea "Tom Cruise" (2 registros)

6- Muestre todos los campos, excepto "duracion", de todas las películas de las que haya más de 2 copias (2 registros)if object_id('peliculas') is not null drop table peliculas;

create table peliculas( titulo varchar(20), actor varchar(20), duracion integer, cantidad integer );

insert into peliculas (titulo, actor, duracion, cantidad) values ('Mision imposible','Tom Cruise',120,3); insert into peliculas (titulo, actor, duracion, cantidad) values ('Mision imposible 2','Tom Cruise',180,4); insert into peliculas (titulo, actor, duracion, cantidad) values ('Mujer bonita','Julia R.',90,1); insert into peliculas (titulo, actor, duracion, cantidad) values ('Elsa y Fred','China Zorrilla',80,2);

select *from peliculas where duracion<=90;

select *from peliculas where actor<>'Tom Cruise';

select titulo,actor,cantidad from peliculas where cantidad >2;

Para eliminar los registros de una tabla usamos el comando "delete":

delete from usuarios;

Muestra un mensaje indicando la cantidad de registros que ha eliminado.

Si no queremos eliminar todos los registros, sino solamente algunos, debemos indicar cuál o cuáles, para ello utilizamos el comando "delete" junto con la clausula "where" con la cual establecemos la condición que deben cumplir los registros a borrar.

Por ejemplo, queremos eliminar aquel registro cuyo nombre de usuario es "Marcelo":

delete from usuarios where nombre='Marcelo';

Page 23: SQL Server 2000

Si solicitamos el borrado de un registro que no existe, es decir, ningún registro cumple con la condición especificada, ningún registro será eliminado.

Tenga en cuenta que si no colocamos una condición, se eliminan todos los registros de la tabla nombrada.

Primer problema: Trabaje con la tabla "agenda" que registra la información 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: apellido (cadena de 30), nombre (cadena de 20), domicilio (cadena de 30) y telefono (cadena de 11): create table agenda( apellido varchar(30), nombre varchar(20), 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 número telefónico sea igual a "4545454" (2 registros afectados):

6- Muestre la tabla.

7- Elimine todos los registros (2 registros afectados):

8- Muestre la tabla.

Ver solución

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)

Page 24: SQL Server 2000

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;

Segundo problema: Un comercio que vende artículos de computación registra los datos de sus artículos en una tabla con ese nombre.

1- Elimine "articulos", si existe: if object_id('articulos') is not null drop table articulos;

2- Cree la tabla, con la siguiente estructura: create table articulos( codigo integer, nombre varchar(20), descripcion varchar(30), precio float, cantidad integer );

3- Vea la estructura de la tabla.

4- Ingrese algunos registros: insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (1,'impresora','Epson Stylus C45',400.80,20); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (2,'impresora','Epson Stylus C85',500,30); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (3,'monitor','Samsung 14',800,10); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (4,'teclado','ingles Biswal',100,50); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (5,'teclado','español Biswal',90,50);

5- Elimine los artículos cuyo precio sea mayor o igual a 500 (2 registros) delete from articulos where precio>=500;

Page 25: SQL Server 2000

7- Elimine todas las impresoras (1 registro) delete from articulos where nombre='impresora';

8- Elimine todos los artículos cuyo código sea diferente a 4 (1 registro) delete from articulos where codigo<>4;

9- Mostrar la tabla después que borra cada registro.

Ver solución

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 into articulos (codigo, nombre, descripcion, precio,cantidad) values (1,'impresora','Epson Stylus C45',400.80,20); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (2,'impresora','Epson Stylus C85',500,30); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (3,'monitor','Samsung 14',800,10); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (4,'teclado','ingles Biswal',100,50); insert into articulos (codigo, nombre, descripcion, precio,cantidad) values (5,'teclado','español Biswal',90,50);

delete from articulos where precio>=500;

select * from articulos;

delete from articulos where nombre='impresora';

select * from articulos;

delete from articulos where codigo<>4;

select * from articulos;

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

Page 26: SQL Server 2000

Por ejemplo, en nuestra tabla "usuarios", queremos cambiar los valores de todas las claves, por "RealMadrid":

update usuarios set clave='RealMadrid';

Utilizamos "update" junto al nombre de la tabla y "set" junto con el campo a modificar y su nuevo valor.

El cambio afectará a todos los registros.

Podemos modificar algunos registros, para ello debemos establecer condiciones de selección con "where".Por ejemplo, queremos cambiar el valor correspondiente a la clave de nuestro usuario llamado "Federicolopez", queremos como nueva clave "Boca", necesitamos una condición "where" que afecte solamente a este registro:

update usuarios set clave='Boca' where nombre='Federicolopez';

Si Microsoft SQL Server no encuentra registros que cumplan con la condición del "where", no se modifica ninguno.

Las condiciones no son obligatorias, pero si omitimos la cláusula "where", la actualización afectará a todos los registros.

También podemos actualizar varios campos en una sola instrucción:

update usuarios set nombre='Marceloduarte', clave='Marce' where nombre='Marcelo';

Para ello colocamos "update", el nombre de la tabla, "set" junto al nombre del campo y el nuevo valor y separado por coma, el otro nombre del campo con su nuevo valor.

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 into agenda (apellido,nombre,domicilio,telefono) values ('Acosta','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');

Page 27: SQL Server 2000

insert into agenda (apellido,nombre,domicilio,telefono) values ('Lopez','Jose','Urquiza 333','4545454'); insert into agenda (apellido,nombre,domicilio,telefono) values ('Suarez','Susana','Gral. Paz 1234','4123456');

4- Modifique el registro cuyo nombre sea "Juan" por "Juan Jose" (1 registro afectado)

5- Actualice los registros cuyo número telefónico sea igual a "4545454" por "4445566" (2 registros afectados)

6- Actualice los registros que tengan en el campo "nombre" el valor "Juan" por "Juan Jose" (ningún registro afectado porque ninguno cumple con la condición del "where")

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

Ver solución

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 ('Acosta','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 ('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;

Page 28: SQL Server 2000

 

Segundo problema: Trabaje con la tabla "libros" de una librería.

1- Elimine la tabla si existe: if object_id('libros') is not null drop table libros;

2- Créela con los siguientes campos: titulo (cadena de 30 caracteres de longitud), autor (cadena de 20), editorial (cadena de 15) y precio (float): create table libros ( titulo varchar(30), autor varchar(20), editorial varchar(15), precio float );

3- Ingrese los siguientes registros: insert into libros (titulo, autor, editorial, precio) values ('El aleph','Borges','Emece',25.00); insert into libros (titulo, autor, editorial, precio) values ('Martin Fierro','Jose Hernandez','Planeta',35.50); insert into libros (titulo, autor, editorial, precio) values ('Aprenda PHP','Mario Molina','Emece',45.50); insert into libros (titulo, autor, editorial, precio) values ('Cervantes y el quijote','Borges','Emece',25); insert into libros (titulo, autor, editorial, precio) values ('Matematica estas ahi','Paenza','Siglo XXI',15);

4- Muestre todos los registros (5 registros): select *from libros;

5- Modifique los registros cuyo autor sea igual a "Paenza", por "Adrian Paenza" (1 registro afectado) update libros set autor='Adrian Paenza' where autor='Paenza';

6- Nuevamente, modifique los registros cuyo autor sea igual a "Paenza", por "Adrian Paenza" (ningún registro afectado porque ninguno cumple la condición) update libros set autor='Adrian Paenza' where autor='Paenza';

7- Actualice el precio del libro de "Mario Molina" a 27 pesos (1 registro afectado): update libros set precio=27 where autor='Mario Molina';

8- Actualice el valor del campo "editorial" por "Emece S.A.", para todos los registros cuya editorial sea igual a "Emece" (3 registros afectados): update libros set editorial='Emece S.A.' where editorial='Emece';

Page 29: SQL Server 2000

9 - Luego de cada actualización ejecute un select que mustre todos los registros de la tabla.

V if object_id('libros') is not null drop table libros;

create table libros ( titulo varchar(30), autor varchar(20), editorial varchar(15), precio float );

insert into libros (titulo, autor, editorial, precio) values ('El aleph','Borges','Emece',25.00); insert into libros (titulo, autor, editorial, precio) values ('Martin Fierro','Jose Hernandez','Planeta',35.50); insert into libros (titulo, autor, editorial, precio) values ('Aprenda PHP','Mario Molina','Emece',45.50); insert into libros (titulo, autor, editorial, precio) values ('Cervantes y el quijote','Borges','Emece',25); insert into libros (titulo, autor, editorial, precio) values ('Matematica estas ahi','Paenza','Siglo XXI',15);

select * from libros;

update libros set autor='Adrian Paenza' where autor='Paenza';

select * from libros;

update libros set autor='Adrian Paenza' where autor='Paenza';

select * from libros;

update libros set precio=27 where autor='Mario Molina';

select * from libros;

update libros set editorial='Emece S.A.' where editorial='Emece';

select * from libros;

Para aclarar algunas instrucciones, en ocasiones, necesitamos agregar comentarios.Es posible ingresar comentarios en la línea de comandos, es decir, un texto que no se ejecuta; para ello se emplean dos guiones (--) al comienzo de la línea:

select * from libros --mostramos los registros de libros;

en la línea anterior, todo lo que está luego de los guiones (hacia la derecha) no se ejecuta.

Para agregar varias líneas de comentarios, se coloca una barra seguida de un asterisco (/*) al comienzo del bloque de comentario y al finalizarlo, un asterisco seguido de una barra (*/).

Page 30: SQL Server 2000

select titulo, autor /*mostramos títulos y nombres de los autores*/ from libros;

todo lo que está entre los símbolos "/*" y "*/" no se ejecuta.

Problema:

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

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

Creamos la tabla:

create table libros( titulo varchar(30), autor varchar(20), editorial varchar(15) );

Agregamos un registro:

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

Mostramos todos los libros y agregamos un comentario de linea:

select * from libros --mostramos los registros de libros;

vamos a mostrar el título y autor de todos los libros y agregamos un bloque de comentarios:

select titulo, autor /*mostramos títulos y nombres de los autores*/ from libros;

Note que lo que está entre los símbolos no se ejecuta.

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');

Page 31: SQL Server 2000

select * from libros --mostramos los registros de libros;

select titulo, autor /*mostramos títulos y nombres de los autores*/ from libros;

"null" significa "dato desconocido" o "valor inexistente". No es lo mismo que un valor "0", una cadena vacía o una cadena literal "null".

A veces, puede desconocerse o no existir el dato correspondiente a algún campo de un registro. En estos casos decimos que el campo puede contener valores nulos.

Por ejemplo, en nuestra tabla de libros, podemos tener valores nulos en el campo "precio" porque es posible que para algunos libros no le hayamos establecido el precio para la venta.

En contraposición, tenemos campos que no pueden estar vacíos jamás.

Veamos un ejemplo. Tenemos nuestra tabla "libros". El campo "titulo" no debería estar vacío nunca, igualmente el campo "autor". Para ello, al crear la tabla, debemos especificar que dichos campos no admitan valores nulos:

create table libros( titulo varchar(30) not null, autor varchar(20) not null, editorial varchar(15) null, precio float );

Para especificar que un campo no admita valores nulos, debemos colocar "not null" luego de la definición del campo.En el ejemplo anterior, los campos "editorial" y "precio" si admiten valores nulos.Cuando colocamos "null" estamos diciendo que admite valores nulos (caso del campo "editorial"); por defecto, es decir, si no lo aclaramos, los campos permiten valores nulos (caso del campo "precio").

Si ingresamos los datos de un libro, para el cual aún no hemos definido el precio podemos colocar "null" para mostrar que no tiene precio:

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.

También podemos colocar "null" en el campo "editorial" si desconocemos el nombre de la editorial a la cual pertenece el libro que vamos a ingresar:

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

Page 32: SQL Server 2000

values('Alicia en el pais','Lewis Carroll',null,25);

Si intentamos ingresar el valor "null" en campos que no admiten valores nulos (como "titulo" o "autor"), SQL Server no lo permite, muestra un mensaje y la inserción no se realiza; por ejemplo:

insert into libros (titulo,autor,editorial,precio) values(null,'Borges','Siglo XXI',25);

Para ver cuáles campos admiten valores nulos y cuáles no, podemos emplear el procedimiento almacenado "sp_columns" junto al nombre de la tabla. Nos muestra mucha información, en la columna "IS_NULLABLE" vemos que muestra "NO" en los campos que no permiten valores nulos y "YES" en los campos que si los permiten.

Para recuperar los registros que contengan el valor "null" en algún campo, no podemos utilizar los operadores relacionales vistos anteriormente: = (igual) y <> (distinto); debemos utilizar los operadores "is null" (es igual a null) y "is not null" (no es null):

select * from libros where precio is null;

La sentencia anterior tendrá una salida diferente a la siguiente:

select * from libros where precio=0;

Con la primera sentencia veremos los libros cuyo precio es igual a "null" (desconocido); con la segunda, los libros cuyo precio es 0.

Igualmente para campos de tipo cadena, las siguientes sentencias "select" no retornan los mismos registros:

select * from libros where editorial is null; select * from libros where editorial='';

Con la primera sentencia veremos los libros cuya editorial es igual a "null", con la segunda, los libros cuya editorial guarda una cadena vacía.

Entonces, para que un campo no permita valores nulos debemos especificarlo luego de definir el campo, agregando "not null". Por defecto, los campos permiten valores nulos, pero podemos especificarlo igualmente agregando "null".

Primer problema: Una farmacia guarda información referente a sus medicamentos en una tabla llamada "medicamentos".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),

Page 33: SQL Server 2000

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 registro con valor "0" para el precio y cadena vacía para el laboratorio: insert into medicamentos (codigo,nombre, laboratorio,precio,cantidad) values(4,'Bayaspirina','',0,150);

7- Ingrese un registro con valor "0" para el código y cantidad y cadena vacía para el nombre: 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 vacía en el mismo campo. Note que el resultado es diferente.

11- Recupere los registros que contengan valor "null" en el campo "precio", luego los que tengan el valor 0 en el mismo campo. Note que el resultado es distinto.

12- Recupere los registros cuyo laboratorio no contenga una cadena vacía, luego los que sean distintos de "null".Note que la salida de la primera sentencia no muestra los registros con cadenas vacías y tampoco los que tienen valor nulo; el resultado de la segunda sentencia muestra los registros con valor para el campo laboratorio (incluso cadena vacía).

13- Recupere los registros cuyo precio sea distinto de 0, luego los que sean distintos de "null":

Page 34: SQL Server 2000

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 solución

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;

Page 35: SQL Server 2000

select *from medicamentos where precio is not null;

 

Segundo problema: Trabaje con la tabla que almacena los datos sobre películas, llamada "peliculas".1- Elimine la tabla si existe: if object_id('peliculas') is not null drop table peliculas;

2- Créela con la siguiente estructura: create table peliculas( codigo int not null, titulo varchar(40) not null, actor varchar(20), duracion int );

3- Visualice la estructura de la tabla sp_columns peliculas;note que el campo "codigo" y "titulo", en la columna "IS_NULLABLE" muestra "NO" y los otros campos "YES".

4- Ingrese los siguientes registros: insert into peliculas (codigo,titulo,actor,duracion) values(1,'Mision imposible','Tom Cruise',120); insert into peliculas (codigo,titulo,actor,duracion) values(2,'Harry Potter y la piedra filosofal',null,180); insert into peliculas (codigo,titulo,actor,duracion) values(3,'Harry Potter y la camara secreta','Daniel R.',null); insert into peliculas (codigo,titulo,actor,duracion) values(0,'Mision imposible 2','',150); insert into peliculas (codigo,titulo,actor,duracion) values(4,'','L. Di Caprio',220); insert into peliculas (codigo,titulo,actor,duracion) values(5,'Mujer bonita','R. Gere-J. Roberts',0);

5- Recupere todos los registros para ver cómo SQL Server los almacenó: select *from peliculas;

6- Intente ingresar un registro con valor nulo para campos que no lo admiten (aparece un mensaje de error): insert into peliculas (codigo,titulo,actor,duracion) values(null,'Mujer bonita','R. Gere-J. Roberts',190);

7- Muestre los registros con valor nulo en el campo "actor" y luego los que guardan una cadena vacía (note que la salida es distinta) (1 registro)

8- Modifique los registros que tengan valor de duración desconocido (nulo) por "120" (1 registro actualizado)

Page 36: SQL Server 2000

9- Coloque 'Desconocido' en el campo "actor" en los registros que tengan una cadena vacía en dicho campo (1 registro afectado)

10- Muestre todos los registros. Note que el cambio anterior no afectó a los registros con valor nulo en el campo "actor".

11- Elimine los registros cuyo título sea una cadena vacía (1 registro)

Ver soluciónif object_id('peliculas') is not null drop table peliculas;

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

sp_columns peliculas;

insert into peliculas (codigo,titulo,actor,duracion) values(1,'Mision imposible','Tom Cruise',120); insert into peliculas (codigo,titulo,actor,duracion) values(2,'Harry Potter y la piedra filosofal',null,180); insert into peliculas (codigo,titulo,actor,duracion) values(3,'Harry Potter y la camara secreta','Daniel R.',null); insert into peliculas (codigo,titulo,actor,duracion) values(0,'Mision imposible 2','',150); insert into peliculas (codigo,titulo,actor,duracion) values(4,'','L. Di Caprio',220); insert into peliculas (codigo,titulo,actor,duracion) values(5,'Mujer bonita','R. Gere-J. Roberts',0);

select *from peliculas;

insert into peliculas (codigo,titulo,actor,duracion) values(null,'Mujer bonita','R. Gere-J. Roberts',190);

select * from peliculas where actor is null;

update peliculas set duracion=120 where duracion is null;

update peliculas set actor='Desconocido' where actor='';

select * from peliculas;

delete from peliculas where titulo='';

select * from peliculas;

Page 37: SQL Server 2000

Una clave primaria es un campo (o varios) que identifica un solo registro (fila) en una tabla.Para un valor del campo clave existe solamente un registro.

Veamos un ejemplo, si tenemos una tabla con datos de personas, el número de documento puede establecerse como clave primaria, es un valor que no se repite; puede haber personas con igual apellido y nombre, incluso el mismo domicilio (padre e hijo por ejemplo), pero su documento será siempre distinto.

Si tenemos la tabla "usuarios", el nombre de cada usuario puede establecerse como clave primaria, es un valor que no se repite; puede haber usuarios con igual clave, pero su nombre de usuario será siempre diferente.

Podemos establecer que un campo sea clave primaria al momento de crear la tabla o luego que ha sido creada. Vamos a aprender a establecerla al crear la tabla. Hay 2 maneras de hacerlo, por ahora veremos la sintaxis más sencilla.

Tenemos nuestra tabla "usuarios" definida con 2 campos ("nombre" y "clave").La sintaxis básica 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 definición de cada campo, "primary key" y entre paréntesis, el nombre del campo que será clave primaria.

Una tabla sólo puede tener una clave primaria. Cualquier campo (de cualquier tipo) puede ser clave primaria, debe cumplir como requisito, que sus valores no se repitan ni sean nulos. Por ello, al definir un campo como clave primaria, automáticamente SQL Server lo convierte a "not null".

Luego de haber establecido un campo como clave primaria, al ingresar los registros, SQL Server controla que los valores para el campo establecido como clave primaria no estén repetidos en la tabla; si estuviesen repetidos, muestra un mensaje y la inserción no se realiza. Es decir, si en nuestra tabla "usuarios" ya existe un usuario con nombre "juanperez" e intentamos ingresar un nuevo usuario con nombre "juanperez", aparece un mensaje y la instrucción "insert" no se ejecuta.

Igualmente, si realizamos una actualización, SQL Server controla que los valores para el campo establecido como clave primaria no estén repetidos en la tabla, si lo estuviese,

Page 38: SQL Server 2000

aparece un mensaje indicando que se viola la clave primaria y la actualización no se realiza.

Primer problema: Trabaje con la tabla "libros" de una librería.1- Elimine la tabla si existe: if object_id('libros') is not null drop table libros;

2- Créela con los siguientes campos, estableciendo como clave primaria el campo "codigo": create table libros( codigo int not null, titulo varchar(40) not null, autor varchar(20), editorial varchar(15), primary key(codigo) );

3- Ingrese los siguientes registros: insert into libros (codigo,titulo,autor,editorial) values (1,'El aleph','Borges','Emece'); insert into libros (codigo,titulo,autor,editorial) values (2,'Martin Fierro','Jose Hernandez','Planeta'); insert into libros (codigo,titulo,autor,editorial) values (3,'Aprenda PHP','Mario Molina','Nuevo Siglo');

4- Ingrese un registro con código repetido (aparece un mensaje de error)

5- Intente ingresar el valor "null" en el campo "codigo"

6- Intente actualizar el código del libro "Martin Fierro" a "1" (mensaje de error)

Ver solución

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 (1,'El aleph','Borges','Emece'); insert into libros (codigo,titulo,autor,editorial) values (2,'Martin Fierro','Jose Hernandez','Planeta'); insert into libros (codigo,titulo,autor,editorial) values (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)

Page 39: SQL Server 2000

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

update libros set codigo=1 where titulo='Martin Fierro';

 

Segundo problema: Un instituto de enseñanza almacena los datos de sus estudiantes en una tabla llamada "alumnos".1- Elimine la tabla "alumnos" si existe: if object_id('alumnos') is not null drop table alumnos;

2- Cree la tabla con la siguiente estructura intentando establecer 2 campos como clave primaria, el campo "documento" y "legajo" (no lo permite): create table alumnos( legajo varchar(4) not null, documento varchar(8), nombre varchar(30), domicilio varchar(30), primary key(documento), primary key(legajo) );

3- Cree la tabla estableciendo como clave primaria el campo "documento": create table alumnos( legajo varchar(4) not null, documento varchar(8), nombre varchar(30), domicilio varchar(30), primary key(documento) );

4- Verifique que el campo "documento" no admite valores nulos: sp_columns alumnos;

5- Ingrese los siguientes registros: insert into alumnos (legajo,documento,nombre,domicilio) values('A233','22345345','Perez Mariana','Colon 234'); insert into alumnos (legajo,documento,nombre,domicilio) values('A567','23545345','Morales Marcos','Avellaneda 348');

6- Intente ingresar un alumno con número de documento existente (no lo permite)

7- Intente ingresar un alumno con documento nulo (no lo permite)

Ver soluciónif object_id('alumnos') is not null drop table alumnos;

create table alumnos( legajo varchar(4) not null,

Page 40: SQL Server 2000

documento varchar(8), nombre varchar(30), domicilio varchar(30), primary key(documento), primary key(legajo) );

create table alumnos( legajo varchar(4) not null, documento varchar(8), nombre varchar(30), domicilio varchar(30), primary key(documento) );

sp_columns alumnos;

insert into alumnos (legajo,documento,nombre,domicilio) values('A233','22345345','Perez Mariana','Colon 234'); insert into alumnos (legajo,documento,nombre,domicilio) values('A567','23545345','Morales Marcos','Avellaneda 348');

insert into alumnos (legajo,documento,nombre,domicilio) values('A642','23545345','Gonzalez Analia','Caseros 444');

insert into alumnos (legajo,documento,nombre,domicilio) values('A685',null,'Miranda Carmen','Uspallata 999');

Un campo numérico 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 automáticamente.

Se utiliza generalmente en campos correspondientes a códigos de identificación para generar valores únicos para cada nuevo registro que se inserta.

Sólo puede haber un campo "identity" por tabla.

Para que un campo pueda establecerse como "identity", éste debe ser entero (también puede ser de un subtipo de entero o decimal con escala 0, tipos que estudiaremos posteriormente).

Para que un campo genere sus valores automáticamente, debemos agregar el atributo "identity" luego de su definición al crear la tabla:

create table libros( codigo int identity, titulo varchar(40) not null, autor varchar(30), editorial varchar(15), precio float );

Cuando un campo tiene el atributo "identity" no se puede ingresar valor para él, porque se inserta automáticamente tomando el último valor como referencia, o 1 si es el primero.

Page 41: SQL Server 2000

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 código.

Si continuamos ingresando registros, el código (dato que no ingresamos) se cargará automáticamente siguiendo la secuencia de autoincremento.

No está permitido ingresar el valor correspondiente al campo "identity", por ejemplo:

insert into libros (codigo,titulo,autor,editorial,precio) values(5,'Martin Fierro','Jose Hernandez','Paidos',25);

generará un mensaje de error.

"identity" permite indicar el valor de inicio de la secuencia y el incremento, pero lo veremos posteriormente.

Un campo definido como "identity" generalmente se establece como clave primaria.

Un campo "identity" no es editable, es decir, no se puede ingresar un valor ni actualizarlo.

Un campo de identidad no permite valores nulos, aunque no se indique especificamente. Si ejecutamos el procedimiento "sp_columns()" veremos que en el campo "codigo" en la columna "TYPE_NAME" aparece "int identity" y en la columna "IS_NULLABLE" aparece "NO".

Los valores secuenciales de un campo "identity" se generan tomando como referencia el último valor ingresado; si se elimina el último registro ingresado (por ejemplo 3) y luego se inserta otro registro, SQL Server seguirá la secuencia, es decir, colocará el valor "4".

Primer problema: Una farmacia guarda información 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 automáticamente: create table medicamentos( codigo int identity, nombre varchar(20) not null, laboratorio varchar(20), precio float, cantidad integer );

3- Visualice la estructura de la tabla "medicamentos":

Page 42: SQL Server 2000

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 "código" de modo automático: select *from medicamentos;

6- Intente ingresar un registro con un valor para el campo "codigo"

7- Intente actualizar un valor de código (aparece un mensaje de error)

8- Elimine el registro con codigo "3" (1 registro eliminado)

9- Ingrese un nuevo registro: 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 código: select *from medicamentos;

Ver solución

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;

Page 43: SQL Server 2000

insert into medicamentos (nombre, laboratorio,precio,cantidad) values('Amoxilina 500','Bayer',15.60,100);

select *from medicamentos;

 

Segundo problema: Un videoclub almacena información sobre sus películas en una tabla llamada "peliculas".1- Elimine la tabla si existe: if object_id('peliculas') is not null drop table peliculas;

2- Créela definiendo un campo "codigo" autoincrementable y como clave primaria: create table peliculas( codigo int identity, titulo varchar(40), actor varchar(20), duracion int, primary key(codigo) );

3- Ejecute el procedimiento almacenado para visualizar la estructura de la tabla: sp_columns peliculas;

4- Ingrese los siguientes registros: insert into peliculas (titulo,actor,duracion) values('Mision imposible','Tom Cruise',120); insert into peliculas (titulo,actor,duracion) values('Harry Potter y la piedra filosofal','Daniel R.',180); insert into peliculas (titulo,actor,duracion) values('Harry Potter y la camara secreta','Daniel R.',190); insert into peliculas (titulo,actor,duracion) values('Mision imposible 2','Tom Cruise',120); insert into peliculas (titulo,actor,duracion) values('La vida es bella','zzz',220);

5- Seleccione todos los registros y verifique la carga automática de los códigos: select *from peliculas;

6- Intente actualizar el codigo de una película (aparece un mensaje de error)

7- Elimine la película "La vida es bella".

8- Ingrese un nuevo registro.

9- Visualice los registros para ver el valor almacenado en codigo (valor 7): select *from peliculas;

Page 44: SQL Server 2000

Ver soluciónif object_id('peliculas') is not null drop table peliculas;

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

sp_columns peliculas;

insert into peliculas (titulo,actor,duracion) values('Mision imposible','Tom Cruise',120); insert into peliculas (titulo,actor,duracion) values('Harry Potter y la piedra filosofal','Daniel R.',180); insert into peliculas (titulo,actor,duracion) values('Harry Potter y la camara secreta','Daniel R.',190); insert into peliculas (titulo,actor,duracion) values('Mision imposible 2','Tom Cruise',120); insert into peliculas (titulo,actor,duracion) values('La vida es bella','zzz',220);

select *from peliculas;

update peliculas set codigo=7 where codigo=4;

delete from peliculas where titulo='La vida es bella';

insert into peliculas (titulo,actor,duracion) values('Elsa y Fred','China Zorrilla',90);

select *from peliculas;

El atributo "identity" permite indicar el valor de inicio de la secuencia y el incremento, para ello usamos la siguiente sintaxis:

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

Los valores comenzarán en "100" y se incrementarán de 2 en 2; es decir, el primer registro ingresado tendrá el valor "100", los siguientes "102", "104", "106", etc.

La función "ident_seed()" retorna el valor de inicio del campo "identity" de la tabla que nombramos:

select ident_seed('libros');

Page 45: SQL Server 2000

La función "ident_incr()" retorna el valor de incremento del campo "identity" de la tabla nombrada:

select ident_incr('libros');

Hemos visto que en un campo declarado "identity" no puede ingresarse explícitamente un valor.Para permitir ingresar un valor en un campo de identidad se debe activar la opción "identity_insert":

set identity_insert libros on;

Es decir, podemos ingresar valor en un campo "identity" seteando la opción "identity_insert" en "on".

Cuando "identity_insert" está en ON, las instrucciones "insert" deben explicitar un valor:

insert into libros (codigo,titulo) values (5,'Alicia en el pais de las maravillas');

Si no se coloca un valor para el campo de identidad, la sentencia no se ejecuta y aparece un mensaje de error:

insert into libros (titulo,autor, editorial) values ('Matematica estas ahi','Paenza','Paidos');

El atributo "identity" no implica unicidad, es decir, permite repetición de valores; por ello hay que tener cuidado al explicitar un valor porque se puede ingresar un valor repetido.

Para desactivar la opción "identity_insert" tipeamos:

set identity_insert libros off;

Primer problema: Una farmacia guarda información 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 automáticamente: create table medicamentos( codigo int identity, nombre varchar(20) not null, laboratorio varchar(20), precio float, cantidad integer );

3- Visualice la estructura de la tabla "medicamentos": sp_columns medicamentos;

4- Ingrese los siguientes registros:

Page 46: SQL Server 2000

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 "código" de modo automático: select *from medicamentos;

6- Intente ingresar un registro con un valor para el campo "codigo"

7- Intente actualizar un valor de código (aparece un mensaje de error)

8- Elimine el registro con codigo "3" (1 registro eliminado)

9- Ingrese un nuevo registro: 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 código: select *from medicamentos;

Ver solución

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

Page 47: SQL Server 2000

select *from medicamentos;

 

Segundo problema: Un videoclub almacena información sobre sus películas en una tabla llamada "peliculas".1- Elimine la tabla si existe: if object_id('peliculas') is not null drop table peliculas;

2- Créela definiendo un campo "codigo" autoincrementable y como clave primaria: create table peliculas( codigo int identity, titulo varchar(40), actor varchar(20), duracion int, primary key(codigo) );

3- Ejecute el procedimiento almacenado para visualizar la estructura de la tabla: sp_columns peliculas;

4- Ingrese los siguientes registros: insert into peliculas (titulo,actor,duracion) values('Mision imposible','Tom Cruise',120); insert into peliculas (titulo,actor,duracion) values('Harry Potter y la piedra filosofal','Daniel R.',180); insert into peliculas (titulo,actor,duracion) values('Harry Potter y la camara secreta','Daniel R.',190); insert into peliculas (titulo,actor,duracion) values('Mision imposible 2','Tom Cruise',120); insert into peliculas (titulo,actor,duracion) values('La vida es bella','zzz',220);

5- Seleccione todos los registros y verifique la carga automática de los códigos: select *from peliculas;

6- Intente actualizar el codigo de una película (aparece un mensaje de error)

7- Elimine la película "La vida es bella".

Page 48: SQL Server 2000

8- Ingrese un nuevo registro.

9- Visualice los registros para ver el valor almacenado en codigo (valor 7): select *from peliculas;

Ver soluciónif object_id('peliculas') is not null drop table peliculas;

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

sp_columns peliculas;

insert into peliculas (titulo,actor,duracion) values('Mision imposible','Tom Cruise',120); insert into peliculas (titulo,actor,duracion) values('Harry Potter y la piedra filosofal','Daniel R.',180); insert into peliculas (titulo,actor,duracion) values('Harry Potter y la camara secreta','Daniel R.',190); insert into peliculas (titulo,actor,duracion) values('Mision imposible 2','Tom Cruise',120); insert into peliculas (titulo,actor,duracion) values('La vida es bella','zzz',220);

select *from peliculas;

update peliculas set codigo=7 where codigo=4;

delete from peliculas where titulo='La vida es bella';

insert into peliculas (titulo,actor,duracion) values('Elsa y Fred','China Zorrilla',90);

select *from peliculas;

Aprendimos que para borrar todos los registro de una tabla se usa "delete" sin condición "where".También podemos eliminar todos los registros de una tabla con "truncate table".Por ejemplo, queremos vaciar la tabla "libros", usamos:

truncate table libros;

La sentencia "truncate table" vacía la tabla (elimina todos los registros) y conserva la estructura de la tabla.

La diferencia con "drop table" es que esta sentencia borra la tabla, "truncate table" la vacía.

Page 49: SQL Server 2000

La diferencia con "delete" es la velocidad, es más rápido "truncate table" que "delete" (se nota cuando la cantidad de registros es muy grande) ya que éste borra los registros uno a uno.

Otra diferencia es la siguiente: cuando la tabla tiene un campo "identity", si borramos todos los registros con "delete" y luego ingresamos un registro, al cargarse el valor en el campo de identidad, continúa con la secuencia teniendo en cuenta el valor mayor que se había guardado; si usamos "truncate table" para borrar todos los registros, al ingresar otra vez un registro, la secuencia del campo de identidad vuelve a iniciarse en 1.

Por ejemplo, tenemos la tabla "libros" con el campo "codigo" definido "identity", y el valor más alto de ese campo es "2", si borramos todos los registros con "delete" y luego ingresamos un registro, éste guardará el valor de código "3"; si en cambio, vaciamos la tabla con "truncate table", al ingresar un nuevo registro el valor del código se iniciará en 1 nuevamente.

Primer problema: Un instituto de enseñanza almacena los datos de sus estudiantes en una tabla llamada "alumnos".1- Elimine la tabla "alumnos" si existe: if object_id('alumnos') is not null drop table alumnos;

2- Cree la tabla con la siguiente estructura: create table alumnos( legajo int identity, documento varchar(8), nombre varchar(30), domicilio varchar(30) );

3- Ingrese los siguientes registros y muéstrelos para ver la secuencia de códigos: insert into alumnos (documento,nombre,domicilio) values('22345345','Perez Mariana','Colon 234'); insert into alumnos (documento,nombre,domicilio) values('23545345','Morales Marcos','Avellaneda 348'); insert into alumnos (documento,nombre,domicilio) values('24356345','Gonzalez Analia','Caseros 444'); insert into alumnos (documento,nombre,domicilio) values('25666777','Torres Ramiro','Dinamarca 209');

4- Elimine todos los registros con "delete".

5- Ingrese los siguientes registros y selecciónelos para ver cómo SQL Server generó los códigos: insert into alumnos (documento,nombre,domicilio) values('22345345','Perez Mariana','Colon 234'); insert into alumnos (documento,nombre,domicilio) values('23545345','Morales Marcos','Avellaneda 348'); insert into alumnos (documento,nombre,domicilio) values('24356345','Gonzalez Analia','Caseros 444'); insert into alumnos (documento,nombre,domicilio) values('25666777','Torres Ramiro','Dinamarca 209'); select *from alumnos;

6- Elimine todos los registros con "truncate table".

Page 50: SQL Server 2000

7- Ingrese los siguientes registros y muestre todos los registros para ver que SQL Server reinició la secuencia del campo "identity": insert into alumnos (documento,nombre,domicilio) values('22345345','Perez Mariana','Colon 234'); insert into alumnos (documento,nombre,domicilio) values('23545345','Morales Marcos','Avellaneda 348'); insert into alumnos (documento,nombre,domicilio) values('24356345','Gonzalez Analia','Caseros 444'); insert into alumnos (documento,nombre,domicilio) values('25666777','Torres Ramiro','Dinamarca 209'); select *from alumnos;

Ver solución

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

create table alumnos( legajo int identity, documento varchar(8), nombre varchar(30), domicilio varchar(30) );

insert into alumnos (documento,nombre,domicilio) values('22345345','Perez Mariana','Colon 234'); insert into alumnos (documento,nombre,domicilio) values('23545345','Morales Marcos','Avellaneda 348'); insert into alumnos (documento,nombre,domicilio) values('24356345','Gonzalez Analia','Caseros 444'); insert into alumnos (documento,nombre,domicilio) values('25666777','Torres Ramiro','Dinamarca 209');

delete from alumnos;

insert into alumnos (documento,nombre,domicilio) values('22345345','Perez Mariana','Colon 234'); insert into alumnos (documento,nombre,domicilio) values('23545345','Morales Marcos','Avellaneda 348'); insert into alumnos (documento,nombre,domicilio) values('24356345','Gonzalez Analia','Caseros 444'); insert into alumnos (documento,nombre,domicilio) values('25666777','Torres Ramiro','Dinamarca 209'); select *from alumnos;

truncate table alumnos;

insert into alumnos (documento,nombre,domicilio) values('22345345','Perez Mariana','Colon 234'); insert into alumnos (documento,nombre,domicilio) values('23545345','Morales Marcos','Avellaneda 348'); insert into alumnos (documento,nombre,domicilio) values('24356345','Gonzalez Analia','Caseros 444'); insert into alumnos (documento,nombre,domicilio) values('25666777','Torres Ramiro','Dinamarca 209'); select *from alumnos;

Page 51: SQL Server 2000

 

Segundo problema: Un comercio que vende artículos de computación registra los datos de sus artículos en una tabla con ese nombre.1- Elimine "articulos", si existe: if object_id('articulos') is not null drop table articulos;

2- Cree la tabla, con la siguiente estructura: create table articulos( codigo integer identity, nombre varchar(20), descripcion varchar(30), precio float );

3- Ingrese algunos registros: insert into articulos (nombre, descripcion, precio) values ('impresora','Epson Stylus C45',400.80); insert into articulos (nombre, descripcion, precio) values ('impresora','Epson Stylus C85',500);

4- Elimine todos los registros con "truncate table".

5- Ingrese algunos registros y muéstrelos para ver que la secuencia de códigos se reinicia: insert into articulos (nombre, descripcion, precio) values ('monitor','Samsung 14',800); insert into articulos (nombre, descripcion, precio) values ('teclado','ingles Biswal',100); insert into articulos (nombre, descripcion, precio) values ('teclado','español Biswal',90); select *from articulos;

6- Elimine todos los registros con "delete".

7- Ingrese algunos registros y muéstrelos para ver que la secuencia de códigos continua: insert into articulos (nombre, descripcion, precio) values ('monitor','Samsung 14',800); insert into articulos (nombre, descripcion, precio) values ('teclado','ingles Biswal',100); insert into articulos (nombre, descripcion, precio) values ('teclado','español Biswal',90); select *from articulos;

Page 52: SQL Server 2000

Ver soluciónif object_id('articulos') is not null drop table articulos;

create table articulos( codigo integer identity, nombre varchar(20), descripcion varchar(30), precio float );

insert into articulos (nombre, descripcion, precio) values ('impresora','Epson Stylus C45',400.80); insert into articulos (nombre, descripcion, precio) values ('impresora','Epson Stylus C85',500);

truncate table articulos;

insert into articulos (nombre, descripcion, precio) values ('monitor','Samsung 14',800); insert into articulos (nombre, descripcion, precio) values ('teclado','ingles Biswal',100); insert into articulos (nombre, descripcion, precio) values ('teclado','español Biswal',90); select *from articulos;

delete from articulos;

insert into articulos (nombre, descripcion, precio) values ('monitor','Samsung 14',800); insert into articulos (nombre, descripcion, precio) values ('teclado','ingles Biswal',100); insert into articulos (nombre, descripcion, precio) values ('teclado','español Biswal',90); select *from articulos;

Ya explicamos que al crear una tabla debemos elegir la estructura adecuada, esto es, definir los campos y sus tipos más precisos, según el caso.

El tipo de dato especificado en la definición de cada campo indica los valores permitidos para cada uno de ellos.

Hasta ahora hemos visto 3 tipos de datos: varchar, integer y float. Hay más tipos, incluso, subtipos.

Los valores que podemos guardar son:

1. TEXTO: Para almacenar texto usamos cadenas de caracteres.Las cadenas se colocan entre comillas simples. Podemos almacenar letras, símbolos y dígitos con los que no se realizan operaciones matemáticas, por ejemplo, códigos de identificación, números de documentos, números telefónicos.SQL Server ofrece los siguientes tipos: char, nchar, varchar, nvarchar, text y ntext.

Page 53: SQL Server 2000

2. NUMEROS: Existe variedad de tipos numéricos para representar enteros, decimales, monedas.Para almacenar valores enteros, por ejemplo, en campos que hacen referencia a cantidades, precios, etc., usamos el tipo integer (y sus subtipos: tinyint, smallint y bigint). Para almacenar valores con decimales exactos, utilizamos: numeric o decimal (son equivalentes). Para guardar valores decimales aproximados: float y real. Para almacenar valores monetarios: money y smallmoney.

3. FECHAS y HORAS: para guardar fechas y horas SQL Server dispone de 2 tipos: datetime y smalldatetime.

Existen otros tipos de datos que analizaremos en secciones próximas.

Entonces, cuando creamos una tabla y definir sus campos debemos elegir el tipo de dato más preciso. Por ejemplo, si necesitamos almacenar nombres usamos texto; si un campo numérico almacenará solamente valores enteros el tipo "integer" es más adecuado que, por ejemplo un "float"; si necesitamos almacenar precios, lo más lógico es utilizar el tipo "money".

A continuación analizaremos en detalle cada tipo de dato básicos.

a explicamos que al crear una tabla debemos elegir la estructura adecuada, esto es, definir los campos y sus tipos más precisos, según el caso.

Para almacenar TEXTO usamos cadenas de caracteres.Las cadenas se colocan entre comillas simples.Podemos almacenar letras, símbolos y dígitos con los que no se realizan operaciones matemáticas, por ejemplo, códigos de identificación, números de documentos, números telefónicos.

Tenemos los siguientes tipos:

1. varchar(x): define una cadena de caracteres de longitud variable en la cual determinamos el máximo de caracteres con el argumento "x" que va entre paréntesis.Si se omite el argumento coloca 1 por defecto. Su rango va de 1 a 8000 caracteres.

2. char(x): define una cadena de longitud fija determinada por el argumento "x". Si se omite el argumento coloca 1 por defecto. Su rango es de 1 a 8000 caracteres.Si la longitud es invariable, es conveniente utilizar el tipo char; caso contrario, el tipo varchar.Ocupa tantos bytes como se definen con el argumento "x"."char" viene de character, que significa caracter en inglés.

3. text: guarda datos binarios de longitud variable, puede contener hasta 2000000000 caracteres. No admite argumento para especificar su longitud.

4. nvarchar(x): es similar a "varchar", excepto que permite almacenar caracteres Unicode, su rango va de 0 a 4000 caracteres porque se emplean 2 bytes por cada caracter.

Page 54: SQL Server 2000

5. nchar(x): es similar a "char" excpeto que acepta caracteres Unicode, su rango va de 0 a 4000 caracteres porque se emplean 2 bytes por cada caracter.

6. ntext: es similar a "text" excepto que permite almacenar caracteres Unicode, puede contener hasta 1000000000 caracteres. No admite argumento para especificar su longitud.

En general se usarán los 3 primeros.

Si intentamos almacenar en un campo una cadena de caracteres de mayor longitud que la definida, aparece un mensaje indicando tal situación y la sentencia no se ejecuta.

Por ejemplo, si definimos un campo de tipo varchar(10) y le asignamos la cadena 'Aprenda PHP' (11 caracteres), aparece un mensaje y la sentencia no se ejecuta.

Si ingresamos un valor numérico (omitiendo las comillas), lo convierte a cadena y lo ingresa como tal.

Por ejemplo, si en un campo definido como varchar(5) ingresamos el valor 12345, lo toma como si hubiésemos tipeado '12345', igualmente, si ingresamos el valor 23.56, lo convierte a '23.56'. Si el valor numérico, al ser convertido a cadena supera la longitud definida, aparece un mensaje de error y la sentencia no se ejecuta.

Es importante elegir el tipo de dato adecuado según el caso, el más preciso.

Para almacenar cadenas que varían en su longitud, es decir, no todos los registros tendrán la misma longitud en un campo determinado, se emplea "varchar" en lugar de "char".

Por ejemplo, en campos que guardamos nombres y apellidos, no todos los nombres y apellidos tienen la misma longitud.

Para almacenar cadenas que no varían en su longitud, es decir, todos los registros tendrán la misma longitud en un campo determinado, se emplea "char".

Por ejemplo, definimos un campo "codigo" que constará de 5 caracteres, todos los registros tendrán un código de 5 caracteres, ni más ni menos.

Para almacenar valores superiores a 8000 caracteres se debe emplear "text".

Tipo Bytes de almacenamiento_______________________________________varchar(x) 0 a 8K char(x) 0 a 8Ktext 0 a 2GB

nvarchar(x) 0 a 8Knchar(x) 0 a 8Kntext 0 a 2GB

Primer problema: Una concesionaria de autos vende autos usados y almacena los datos de los autos en una tabla llamada "autos".

Page 55: SQL Server 2000

1- Elimine la tabla "autos" si existe: if object_id('autos') is not null drop table autos;

2- Cree la tabla eligiendo el tipo de dato adecuado para cada campo, estableciendo el campo "patente" como clave primaria: create table autos( patente char(6), marca varchar(20), modelo char(4), precio float, primary key (patente) );

Hemos definido el campo "patente" de tipo "char" y no "varchar" porque la cadena de caracteres siempre tendrá la misma longitud (6 caracteres). Lo mismo sucede con el campo "modelo", en el cual almacenaremos el año, necesitamos 4 caracteres fijos.

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 año 1990: select *from autos where modelo='1990';

Ver solución

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

Page 56: SQL Server 2000

values('BCC333','Renault Megane','1998',95000); insert into autos values('BVF543','Fiat 128','1975',20000);

select *from autos where modelo='1990';

 

Segundo problema: Una empresa almacena los datos de sus clientes en una tabla llamada "clientes".1- Elimine la tabla "clientes" si existe: if object_id('clientes') is not null drop table clientes;

2- Créela eligiendo el tipo de dato más adecuado para cada campo: create table clientes( documento char(8), apellido varchar(20), nombre varchar(20), domicilio varchar(30), telefono varchar (11) );

3- Analice la definición de los campos. Se utiliza char(8) para el documento porque siempre constará de 8 caracteres. Para el número telefónico se usar "varchar" y no un tipo numérico porque si bien es un número, con él no se realizarán operaciones matemáticas.

4- Ingrese algunos registros: insert into clientes values('2233344','Perez','Juan','Sarmiento 980','4342345'); insert into clientes (documento,apellido,nombre,domicilio) values('2333344','Perez','Ana','Colon 234'); insert into clientes values('2433344','Garcia','Luis','Avellaneda 1454','4558877'); insert into clientes values('2533344','Juarez','Ana','Urquiza 444','4789900');

5- Seleccione todos los clientes de apellido "Perez" (2 registros): select *from clientes where apellido='Perez';

Ver soluciónif object_id('clientes') is not null drop table clientes;

Page 57: SQL Server 2000

create table clientes( documento char(8), apellido varchar(20), nombre varchar(20), domicilio varchar(30), telefono varchar (11) );

insert into clientes values('2233344','Perez','Juan','Sarmiento 980','4342345'); insert into clientes (documento,apellido,nombre,domicilio) values('2333344','Perez','Ana','Colon 234'); insert into clientes values('2433344','Garcia','Luis','Avellaneda 1454','4558877'); insert into clientes values('2533344','Juarez','Ana','Urquiza 444','4789900');

select *from clientes where apellido='Perez';

Ya explicamos que al crear una tabla debemos elegir la estructura adecuada, esto es, definir los campos y sus tipos más precisos, según el caso.

Para almacenar valores NUMERICOS SQL Server dispone de varios tipos.

Para almacenar valores ENTEROS, por ejemplo, en campos que hacen referencia a cantidades, usamos:

1) integer o int: su rango es de -2000000000 a 2000000000 aprox. El tipo "integer" tiene subtipos: - smallint: Puede contener hasta 5 digitos. Su rango va desde –32000 hasta 32000 aprox.- tinyint: Puede almacenar valores entre 0 y 255.- bigint: De –9000000000000000000 hasta 9000000000000000000 aprox.

Para almacenar valores numéricos EXACTOS con decimales, especificando la cantidad de cifras a la izquierda y derecha del separador decimal, utilizamos:

2) decimal o numeric (t,d): Pueden tener hasta 38 digitos, guarda un valor exacto. El primer argumento indica el total de dígitos y el segundo, la cantidad de decimales.Por ejemplo, si queremos almacenar valores entre -99.99 y 99.99 debemos definir el campo como tipo "decimal(4,2)". Si no se indica el valor del segundo argumento, por defecto es "0". Por ejemplo, si definimos "decimal(4)" se pueden guardar valores entre -9999 y 9999.

El rango depende de los argumentos, también los bytes que ocupa.Se utiliza el punto como separador de decimales.

Si ingresamos un valor con más decimales que los permitidos, redondea al más cercano; por ejemplo, si definimos "decimal(4,2)" e ingresamos el valor "12.686", guardará "12.69", redondeando hacia arriba; si ingresamos el valor "12.682", guardará "12.67", redondeando hacia abajo.

Para almacenar valores numéricos APROXIMADOS con decimales utilizamos:

Page 58: SQL Server 2000

3) float y real: De 1.79E+308 hasta 1.79E+38. Guarda valores aproximados.4) real: Desde 3.40E+308 hasta 3.40E+38. Guarda valores aproximados.

Para almacenar valores MONETARIOS empleamos:

5) money: Puede tener hasta 19 digitos y sólo 4 de ellos puede ir luego del separador decimal; entre –900000000000000.5808 aprox y 900000000000000.5807.

6) smallmoney: Entre –200000.3648 y 200000.3647 aprox.

Para todos los tipos numéricos:- si intentamos ingresar un valor fuera de rango, no lo permite. - si ingresamos una cadena, SQL Server intenta convertirla a valor numérico, si dicha cadena consta solamente de dígitos, la conversión se realiza, luego verifica si está dentro del rango, si es así, la ingresa, sino, muestra un mensaje de error y no ejecuta la sentencia. Si la cadena contiene caracteres que SQL Server no puede convertir a valor numérico, muestra un mensaje de error y la sentencia no se ejecuta.Por ejemplo, definimos un campo de tipo decimal(5,2), si ingresamos la cadena '12.22', la convierte al valor numérico 12.22 y la ingresa; si intentamos ingresar la cadena '1234.56', la convierte al valor numérico 1234.56, pero como el máximo valor permitido es 999.99, muestra un mensaje indicando que está fuera de rango. Si intentamos ingresar el valor '12y.25', SQL Server no puede realizar la conversión y muestra un mensaje de error.

Es importante elegir el tipo de dato adecuado según el caso, el más preciso. Por ejemplo, si un campo numérico almacenará valores positivos menores a 255, el tipo "int" no es el más adecuado, conviene el tipo "tinyint", de esta manera usamos el menor espacio de almacenamiento posible.Si vamos a guardar valores monetarios menores a 200000 conviene emplear "smallmoney" en lugar de "money".

Tipo Bytes de almacenamiento_______________________________________int 4smallint 2tinyint 1bigint 8

decimal 2 a 17

float 4 u 8real 4 u 8

money 8smallmoney 4

Primer problema: Un banco tiene registrados las cuentas corrientes de sus clientes en una tabla llamada "cuentas".La tabla contiene estos datos:

Número de Cuenta Documento Nombre Saldo______________________________________________________________1234 25666777 Pedro Perez 500000.602234 27888999 Juan Lopez -2500003344 27888999 Juan Lopez 4000.50

Page 59: SQL Server 2000

3346 32111222 Susana Molina 1000

1- Elimine la tabla "cuentas" si existe: if object_id('cuentas') is not null drop table cuentas;

2- Cree la tabla eligiendo el tipo de dato adecuado para almacenar los datos descriptos arriba:

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

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 número de cuenta, de la misma persona.

4- Seleccione todos los registros cuyo saldo sea mayor a "4000" (2 registros)

5- Muestre el número de cuenta y saldo de todas las cuentas cuyo propietario sea "Juan Lopez" (2 registros)

6- Muestre las cuentas con saldo negativo (1 registro)

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

Ver solución

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)

Page 60: SQL Server 2000

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;

 

Segundo problema: Una empresa almacena los datos de sus empleados en una tabla "empleados" que guarda los siguientes datos: nombre, documento, sexo, domicilio, sueldobasico.1- Elimine la tabla, si existe: if object_id('empleados') is not null drop table empleados;

2- Cree la tabla eligiendo el tipo de dato adecuado para cada campo: create table empleados( nombre varchar(30), documento char(8), sexo char(1), domicilio varchar(30), sueldobasico decimal(7,2),--máximo estimado 99999.99 cantidadhijos tinyint--no superará los 255 );

3- Ingrese algunos registros: insert into empleados (nombre,documento,sexo,domicilio,sueldobasico,cantidadhijos) values ('Juan Perez','22333444','m','Sarmiento 123',500,2); insert into empleados (nombre,documento,sexo,domicilio,sueldobasico,cantidadhijos) values ('Ana Acosta','24555666','f','Colon 134',850,0); insert into empleados (nombre,documento,sexo,domicilio,sueldobasico,cantidadhijos) values ('Bartolome Barrios','27888999','m','Urquiza 479',10000.80,4);

4- Ingrese un valor de "sueldobasico" con más decimales que los definidos (redondea los decimales al valor más cercano 800.89): insert into empleados (nombre,documento,sexo,domicilio,sueldobasico,cantidadhijos) values ('Susana Molina','29000555','f','Salta 876',800.888,3);

5- Intente ingresar un sueldo que supere los 7 dígitos (no lo permite)

Page 61: SQL Server 2000

6- Muestre todos los empleados cuyo sueldo no supere los 900 pesos (1 registro):

7- Seleccione los nombres de los empleados que tengan hijos (3 registros):

Ver soluciónif object_id('empleados') is not null drop table empleados;

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

insert into empleados (nombre,documento,sexo,domicilio,sueldobasico,cantidadhijos) values ('Juan Perez','22333444','m','Sarmiento 123',500,2); insert into empleados (nombre,documento,sexo,domicilio,sueldobasico,cantidadhijos) values ('Ana Acosta','24555666','f','Colon 134',850,0); insert into empleados (nombre,documento,sexo,domicilio,sueldobasico,cantidadhijos) values ('Bartolome Barrios','27888999','m','Urquiza 479',10000.80,4);

insert into empleados (nombre,documento,sexo,domicilio,sueldobasico,cantidadhijos) values ('Susana Molina','29000555','f','Salta 876',800.888,3);

insert into empleados (nombre,documento,sexo,domicilio,sueldobasico,cantidadhijos) values ('Marta Juarez','32444555','f','Sucre 1086',5000000,2);

select *from empleados where sueldobasico>=900;

select *from empleados where cantidadhijos>0;

Ya explicamos que al crear una tabla debemos elegir la estructura adecuada, esto es, definir los campos y sus tipos más precisos, según el caso.

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

Page 62: SQL Server 2000

SQL Server reconoce varios formatos de entrada de datos de tipo fecha. Para establecer el orden de las partes de una fecha (dia, mes y año) empleamos "set dateformat". Estos son los formatos:

-mdy: 4/15/96 (mes y día con 1 ó 2 dígitos y año con 2 ó 4 dígitos),-myd: 4/96/15,-dmy: 15/4/1996-dym: 15/96/4,-ydm: 96/15/4,-ydm: 1996/15/4,

Para ingresar una fecha con formato "día-mes-año", tipeamos:

set dateformat dmy;

El formato por defecto es "mdy".

Todos los valores de tipo "datetime" se muestran en formato "año-mes-día hora:minuto:segundo .milisegundos", independientemente del formato de ingreso que hayamos seteado.

Podemos ingresar una fecha, sin hora, en tal caso la hora se guarda como "00:00:00". Por ejemplo, si ingresamos '25-12-01' (año de 2 dígitos), lo mostrará así: '2001-12-25 00:00:00.000'.

Podemos ingresar una hora sin fecha, en tal caso, coloca la fecha "1900-01-01". Por ejemplo, si ingresamos '10:15', mostrará '1900-01-01 10:15.000'.

Podemos emplear los operadores relacionales vistos para comparar fechas.

Tipo Bytes de almacenamiento_______________________________________datetime 8smalldatetime 4

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 "día-mes-año": set dateformat 'dmy';

4- Ingrese un alumno empleando distintos separadores para las fechas:

Page 63: SQL Server 2000

insert into alumnos values('Gonzalez','Ana','22222222','Colon 123','10-08-1990','15/02/1972');

5- Ingrese otro alumno empleando solamente un dígito para día y mes y 2 para el año: insert into alumnos values('Juarez','Bernardo','25555555','Sucre 456','03-03-1991','15/02/1972');

6- Ingrese un alumnos empleando 2 dígitos para el año de la fecha de ingreso y "null" en "fechanacimiento": insert into alumnos values('Perez','Laura','26666666','Bulnes 345','03-03-91',null);

7- Intente ingresar un alumno con fecha de ingreso correspondiente a "15 de marzo de 1990" pero en orden incorrecto "03-15-90": insert into alumnos values('Lopez','Carlos','27777777','Sarmiento 1254','03-15-1990',null);aparece un mensaje de error porque lo lee con el formato día, mes y año y no reconoce el mes 15.

8- Muestre todos los alumnos que ingresaron antes del '1-1-91'.1 registro.

9- Muestre todos los alumnos que tienen "null" en "fechanacimiento": select *from alumnos where fechanacimiento is null;1 registro.

10- Intente ingresar una fecha de ingreso omitiendo los separadores: insert into alumnos values('Rosas','Romina','28888888','Avellaneda 487','03151990',null);No lo acepta.

11- Setee el formato de entrada de fechas para que acepte valores "mes-dia-año".

12- Ingrese el registro del punto 7.

Ver solución

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 values('Gonzalez','Ana','22222222','Colon 123','10-08-1990','15/02/1972');

insert into alumnos values('Juarez','Bernardo','25555555','Sucre 456','03-03-1991','15/02/1972');

Page 64: SQL Server 2000

insert into alumnos values('Perez','Laura','26666666','Bulnes 345','03-03-91',null);

insert into alumnos values('Lopez','Carlos','27777777','Sarmiento 1254','03-15-1990',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-15-1990',null);

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 día, mes y año:

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 dígitos correspondientes al año; en el tercero empleamos la barra ('/') como separador y en el cuarto empleamos como separador el punto ('.') y colocamos un sólo dígito en la part del día y el mes.

Recuperamos los registros:

select *from empleados;

Note que el formato de visualización es "y-m-d".

Mostramos los datos de los empleados cuya fecha de ingreso es anterior a '01-01-1985':

Page 65: SQL Server 2000

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 *from empleados;

select *from empleados where fechaingreso<'01-01-1985';

update empleados set nombre='Maria Carla Juarez' where fechaingreso='20.5.83';

select *from empleados;

delete from empleados where fechaingreso<>'20/05/1983';

select *from empleados;

Final del formulario