SQL SERVER

SESION 2

1 - Valores null (is null)

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

A veces, puede desconocerse o no existir el dato correspondiente a algún campo de un

registro. En estos casos decimos que el campo puede contener valores nulos.

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

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

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

create table libros(

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

Para especificar que un campo no admita valores nulos, debemos colocar "not null" luego de la
definición del campo.

En el ejemplo anterior, los campos "editorial" y "precio" si admiten valores nulos.

Cuando colocamos "null" estamos diciendo que admite valores nulos (caso del campo
"editorial"); por defecto, es decir, si no lo aclaramos, los campos permiten valores nulos (caso
del campo "precio").

Si ingresamos los datos de un libro, para el cual aún no hemos definido el precio podemos
colocar "null" para mostrar que no tiene precio:
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)
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".

Ejercicio:

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

Eliminamos la tabla "libros", si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla especificando que los campos "titulo" y "autor" no admitan valores nulos:

create table libros(

titulo varchar(30) not null,
autor varchar(30) not null,
editorial varchar(15) null,
precio float
);

Los campos "editorial" y "precio" si permiten valores nulos; el primero, porque lo especificamos colocando
"null" en la definición del campo, el segundo lo asume por defecto.

Agregamos un registro a la tabla con valor nulo para el campo "precio":

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

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

Recuerde que el valor "null" no es una cadena de caracteres, por lo tanto no se coloca entre comillas.

Ingresamos otro registro, con valor nulo para el campo "editorial", campo que admite valores "null":
 insert into libros (titulo,autor,editorial,precio)
values('Alicia en el pais','Lewis Carroll',null,0);

Veamos lo que sucede si intentamos ingresar el valor "null" en campos que no lo admiten, como "titulo":

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

values(null,'Borges','Siglo XXI',25);

aparece un mensaje y la sentencia no se ejecuta.

Para ver cuáles campos admiten valores nulos y cuáles no, empleamos el procedimiento almacenado
"sp_columns":

sp_columns libros;

nos muestra muchas columnas, una de ellas tiene el encabezado "IS_NULLABLE", vemos que aparece "NO"
en los campos que no permiten valores nulos y "YES" en los campos que si los permiten.

Dijimos que el valor "null" no es lo mismo que una cadena vacía. Vamos a ingresar un registro con cadena
vacía para el campo "editorial":

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

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

Ingresamos otro registro, ahora cargamos una cadena vacía en el campo "titulo":

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

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

Veamos todos los regiustros ingresados:

select *from libros;

Recuperemos los registros que contengan el valor "null" en el campo "precio":

select *from libros

where precio is null;

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

select *from libros

where precio=0;

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

Recuperemos los libros cuyo nombre de editorial es "null":

select *from libros

where editorial is null;

Ahora veamos los libros cuya editorial almacena una cadena vacía:

select *from libros

where editorial='';

Para recuperar los libros cuyo precio no sea nulo tipeamos:

select *from libros

 where precio is not null;

2 - Clave primaria

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

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

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

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

Tenemos nuestra tabla "usuarios" definida con 2 campos ("nombre" y "clave").

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, aparece
un mensaje indicando que se viola la clave primaria y la actualización no se realiza.
Ejercicio:

Trabajamos con la tabla "usuarios".

Eliminamos la tabla, si existe:

if object_id('usuarios') is not null

drop table usuarios;

Creamos la tabla definiendo el campo "nombre" como clave primaria:

create table usuarios(

nombre varchar(20),
clave varchar(10),
primary key(nombre)
);

Al campo "nombre" no lo definimos "not null", pero al establecerse como clave primaria, SQL Server lo
convierte en "not null", veamos que en la columna "IS_NULLABLE" aparece "NO":

sp_columns usuarios;

Ingresamos algunos registros:

insert into usuarios (nombre, clave)

values ('juanperez','Boca');
insert into usuarios (nombre, clave)
values ('raulgarcia','River');

Recordemos que cuando un campo es clave primaria, sus valores no se repiten. Intentamos ingresar un
valor de clave primaria existente:

insert into usuarios (nombre, clave)

values ('juanperez','payaso');

aparece un mensaje de error y la sentencia no se ejecuta.

Cuando un campo es clave primaria, sus valores no pueden ser nulos. Intentamos ingresar el valor "null" en
el campo clave primaria:

insert into usuarios (nombre, clave)

values (null,'payaso');

aparece un mensaje de error y la sentencia no se ejecuta.

Si realizamos alguna actualización, SQL Server controla que los valores para el campo establecido como
clave primaria no estén repetidos en la tabla. Intentemos actualizar el nombre de un usuario colocando un
nombre existente:

update usuarios set nombre='juanperez'

where nombre='raulgarcia';

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

3 - Campo con atributo Identity

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.

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

Ejercicio:

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

Eliminamos la tabla "libros", si existe:

if object_id('libros') is not null

 drop table libros;

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

create table libros(

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

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

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

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

Veamos cómo se almacenó:

select *from libros;

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

Continuemos ingresando registros:

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

values('Uno','Richard Bach','Planeta',18);
insert into libros (titulo,autor,editorial,precio)
values('Aprenda PHP','Mario Molina','Siglo XXI',45.60);
insert into libros (titulo,autor,editorial,precio)
values('Alicia en el pais de maravillas','Lewis Carroll','Paidos',15.50);

Veamos cómo se almacenaron:

select *from libros;

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

Intentemos ingresar un valor para el campo "codigo":

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

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

generará un mensaje de error.

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

update libros set codigo=9

where titulo='Uno';

aparece un mensaje de error.

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

sp_columns libros;

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

Eliminemos el último registro:

delete from libros

where autor='Lewis Carroll';

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

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

values('Martin Fierro','Jose Hernandez','Paidos',25);
select *from libros;

4 - Otras características del atributo Identity

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

Los valores comenzarán en "100" y se incrementarán de 2 en 2; es decir, el primer registro

ingresado tendrá el valor "100", los siguientes "102", "104", "106", etc.

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

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

nombrada:
select ident_incr('libros');

Hemos visto que en un campo declarado "identity" no puede ingresarse explícitamente un

valor.

Para permitir ingresar un valor en un campo de identidad se debe activar la opción

"identity_insert":
set identity_insert libros on;

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

en "on".

Cuando "identity_insert" está en ON, las instrucciones "insert" deben explicitar un valor:
insert into libros (codigo,titulo)
values (5,'Alicia en el pais de las maravillas');

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

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

El atributo "identity" no implica unicidad, es decir, permite repetición de valores; por ello hay
que tener cuidado al explicitar un valor porque se puede ingresar un valor repetido.
Para desactivar la opción "identity_insert" tipeamos:
set identity_insert libros off;

Ejercicio:

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

Eliminamos la tabla "libros", si existe:

if object_id('libros') is not null

drop table libros;

Creamos la tabla especificando que el campos "codigo" genere valores secuenciales comenzando en 100 e
incrementándose en 2 automáticamente:

create table libros(

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

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

insert into libros (titulo,autor,precio)

values('El aleph','Borges',23);
insert into libros (titulo,autor,precio)
values('Uno','Richard Bach',18);
insert into libros (titulo,autor,precio)
values('Aprenda PHP','Mario Molina',45.60);

Veamos cómo se almacenaron:

select *from libros;

el código (dato que no ingresamos) se cargó automáticamente, iniciándose en 100 y siguiendo la secuencia
de autoincremento (2).

Para saber cuál es el valor de inicio del campo "identity" de la tabla "libros" tipeamos:

select ident_seed('libros');

retorna "2".

Si intentamos ingresar un valor para el campo "codigo":

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

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

generará un mensaje de error.

Para permitir ingresar un valor en un campo de identidad activamos la opción "identity_insert":

set identity_insert libros on;

Recordemos que si "identity_insert" está en ON, la instrucción "insert" DEBE explicitar un valor:

insert into libros (codigo,titulo,autor)

values (100,'Matematica estas ahi','Paenza');
Note que ingresamos un valor de código que ya existe; esto está permitido porque el atributo "identity" no
implica unicidad.

Ingresamos otro registro:

insert into libros (codigo,titulo,autor)

values (1,'Ilusiones','Richard Bach');

Note que ingresamos un valor de código menor al valor de inicio de la secuencia, está permitido.

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

error:

insert into libros (titulo,autor)

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

Para desactivar la opción "identity_insert" tipeamos:

set identity_insert libros off;

Intentemos ingresar un valor para el campo "codigo":

insert into libros (codigo,titulo,autor)

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

aparece un mensaje de error.

5 - Truncate table

Aprendimos que para borrar todos los registro de una tabla se usa "delete" sin condición
"where".

También podemos eliminar todos los registros de una tabla con "truncate table".

Por ejemplo, queremos vaciar la tabla "libros", usamos:

truncate table libros;

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

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

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

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

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

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

if object_id('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,
titulo varchar(30),
autor varchar(20),
editorial varchar(15),
precio float
);

Agregamos algunos registros:

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

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

Seleccionamos todos los registros:

select *from libros;

Truncamos la tabla:

truncate table libros;

Ingresamos nuevamente algunos registros:

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

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

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

select *from libros;

Eliminemos todos los registros con "delete":

delete from libros;

Ingresamos nuevamente algunos registros:

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

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

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

select *from libros;

6 - Otros tipos de datos en SQL Server

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

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

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

Los valores que podemos guardar son:

1. TEXTO: Para almacenar texto usamos cadenas de caracteres.
Las cadenas se colocan entre comillas simples. Podemos almacenar letras, símbolos y
dígitos con los que no se realizan operaciones matemáticas, por ejemplo, códigos de
identificación, números de documentos, números telefónicos.
SQL Server ofrece los siguientes tipos: char, nchar, varchar, nvarchar, text y ntext.
2. NUMEROS: Existe variedad de tipos numéricos para representar enteros, decimales,
monedas.
Para almacenar valores enteros, por ejemplo, en campos que hacen referencia a
cantidades, precios, etc., usamos el tipo integer (y sus subtipos: tinyint, smallint y
bigint).
Para almacenar valores con decimales exactos, utilizamos: numeric o decimal (son
equivalentes).
Para guardar valores decimales aproximados: float y real. Para almacenar valores
monetarios: money y smallmoney.
3. FECHAS y HORAS: para guardar fechas y horas SQL Server dispone de 2 tipos:
datetime y smalldatetime.

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

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

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

7 - Tipo de dato (texto)

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 TEXTO usamos cadenas de caracteres.

Las cadenas se colocan entre comillas simples.

Podemos almacenar letras, símbolos y dígitos con los que no se realizan operaciones
matemáticas, por ejemplo, códigos de identificación, números de documentos, números
telefónicos.

Tenemos los siguientes tipos:

1. varchar(x): define una cadena de caracteres de longitud variable en la cual

determinamos el máximo de caracteres con el argumento "x" que va entre paréntesis.
Si se omite el argumento coloca 1 por defecto. Su rango va de 1 a 8000 caracteres.
2. char(x): define una cadena de longitud fija determinada por el argumento "x". Si se
omite el argumento coloca 1 por defecto. Su rango es de 1 a 8000 caracteres.
Si la longitud es invariable, es conveniente utilizar el tipo char; caso contrario, el tipo
 varchar.
Ocupa tantos bytes como se definen con el argumento "x".
"char" viene de character, que significa caracter en inglés.
3. text: guarda datos binarios de longitud variable, puede contener hasta 2000000000
caracteres. No admite argumento para especificar su longitud.
4. nvarchar(x): es similar a "varchar", excepto que permite almacenar caracteres
Unicode, su rango va de 0 a 4000 caracteres porque se emplean 2 bytes por cada
caracter.
5. nchar(x): es similar a "char" excpeto que acepta caracteres Unicode, su rango va de 0
a 4000 caracteres porque se emplean 2 bytes por cada caracter.
6. ntext: es similar a "text" excepto que permite almacenar caracteres Unicode, puede
contener hasta 1000000000 caracteres. No admite argumento para especificar su
longitud.

En general se usarán los 3 primeros.

Si intentamos almacenar en un campo una cadena de caracteres de mayor longitud que la

definida, aparece un mensaje indicando tal situación y la sentencia no se ejecuta.

Por ejemplo, si definimos un campo de tipo varchar(10) y le asignamos la cadena 'Aprenda

PHP' (11 caracteres), aparece un mensaje y la sentencia no se ejecuta.

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

como tal.

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

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

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

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

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

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

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

Tipo Bytes de almacenamiento

_______________________________________
varchar(x) 0 a 8K
char(x) 0 a 8K
text 0 a 2GB
nvarchar(x) 0 a 8K
nchar(x) 0 a 8K
ntext 0 a 2GB

Ejercicio:

Un comercio que tiene un stand en una feria registra en una tabla llamada "visitantes" algunos datos de las
personas que visitan o compran en su stand para luego enviarle publicidad de sus productos.
Eliminamos la tabla "visitantes", si existe:

if object_id('visitantes') is not null

drop table visitantes;

Creamos con la siguiente estructura:

create table visitantes(

nombre varchar(30),
edad integer,
sexo char(1),
domicilio varchar(30),
ciudad varchar(20),
telefono varchar(11)
);

Los campos "nombre", "domicilio" y "ciudad" almacenarán valores cuya longitud varía, por ello elegimos el
tipo "varchar" y le damos a cada uno una longitud máxima estimando su tamaño. El campo "sexo" se define
de tipo "char", porque necesitamos solamente 1 caracter "f" o "m", que siempre será fijo. El campo
"telefono" también se define como varchar porque no todos los números telefónicos tienen la misma
longitud.

Intentamos ingresar una cadena de mayor longitud que la definida:

insert into visitantes (nombre,edad,sexo,domicilio,ciudad,telefono)

values ('Juan Juarez',32,'masc','Avellaneda 789','Cordoba','4234567');

aparece un mensaje de error y la sentencia no se ejecuta

Ingresamos un número telefónico olvidando las comillas, es decir, como un valor numérico:

insert into visitantes (nombre,edad,sexo,domicilio,ciudad,telefono)

values ('Marcela Morales',43,'f','Colon 456','Cordoba',4567890);

lo convierte a cadena, veámoslo:

select *from visitantes;

8 - Tipo de dato (numérico)

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:

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 4
smallint 2
tinyint 1
bigint 8
decimal 2 a 17
float 4u8
real 4u8
money 8
smallmoney 4

Ejercicio:

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

Eliminamos la tabla, si existe:

if object_id('libros') is not null

drop table libros;
Creamos la tabla con la siguiente estructura:

create table libros(

codigo smallint identity,
titulo varchar(40) not null,
autor varchar(30),
editorial varchar(15),
precio smallmoney,
cantidad tinyint
);

Note que definimos el campo "codigo" de tipo "smallint", esto es porque estimamos que no tendremos más
de 30000 libros. Si necesitáramos un rango mayor podemos emplear "int".

Como en el campo "precio" no almacenaremos valores mayores a 200000, definimos el campo de tipo
"smallmoney".

También podemos definirlo de tipo "decimal(5,2)" porque el máximo precio no superará los 999.99.

El tipo "float" no es el más adecuado para representar precios porque no es exacto y muestra muchos
decimales innecesarios.

Como los valores para el campo "cantidad" no superarán los 255, definimos el campo de tipo "tinyint". Si
estimamos que tendremos más cantidad de libros podemos emplear "smallint" que tiene un rango mayor;
no es adecuado usar int (cuyo rango llega hasta 4000 millones aprox.), porque ocuparíamos más espacio (4
bytes).

Analicemos la inserción de datos numéricos.

Intentemos ingresar un valor fuera del rango definido, una cantidad que supera el rango del tipo "tinyint",
el valor 260:

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

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

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

Intentamos ingresar un precio que supera el rango del tipo "smallmoney", el valor 250000:

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

values('El aleph','Borges','Emece',250000,100);

aparece un mensaje de error y la instrucción no se ejecuta.

Intentamos ingresar una cadena que SQL Server no pueda convertir a valor numérico en el campo "precio"
(error):

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

values('Uno','Richard Bach','Planeta','a50.30',100);

Ingresamos una cadena en el campo "cantidad":

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

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

lo convierte a valor numérico.

9 - Tipo de dato (fecha y hora)

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

Para almacenar valores de tipo FECHA Y HORA SQL Server dispone de dos tipos:
1) datetime: puede almacenar valores desde 01 de enero de 1753 hasta 31 de diciembre de
9999.
2) smalldatetime: el rango va de 01 de enero de 1900 hasta 06 de junio de 2079.

Las fechas se ingresan entre comillas simples.

Para almacenar valores de tipo fecha se permiten como separadores "/", "-" y ".".

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

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

-myd: 4/96/15,
-dmy: 15/4/1996
-dym: 15/96/4,
-ydm: 96/15/4,
-ydm: 1996/15/4,

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

set dateformat dmy;

El formato por defecto es "mdy".

Todos los valores de tipo "datetime" se muestran en formato "año-mes-día

hora:minuto:segundo .milisegundos", independientemente del formato de ingreso que
hayamos seteado.

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

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

Podemos emplear los operadores relacionales vistos para comparar fechas.

Tipo Bytes de almacenamiento

_______________________________________
datetime 8
smalldatetime 4

Ejercicio:

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':

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;

10 - Ingresar algunos campos (insert into)

Hemos aprendido a ingresar registros listando todos los campos y colocando valores para
todos y cada uno de ellos luego de "values".

Si ingresamos valores para todos los campos, podemos omitir la lista de nombres de los
campos.

Por ejemplo, si tenemos creada la tabla "libros" con los campos "titulo", "autor" y "editorial",
podemos ingresar un registro de la siguiente manera:

insert into libros

 values ('Uno','Richard Bach','Planeta');
También es posible ingresar valores para algunos campos. Ingresamos valores solamente para
los campos "titulo" y "autor":
insert into libros (titulo, autor)
values ('El aleph','Borges');

SQL Server almacenará el valor "null" en el campo "editorial", para el cual no hemos
explicitado un valor.

Al ingresar registros debemos tener en cuenta:

- la lista de campos debe coincidir en cantidad y tipo de valores con la lista de valores luego de
"values". Si se listan más (o menos) campos que los valores ingresados, aparece un mensaje
de error y la sentencia no se ejecuta.
- si ingresamos valores para todos los campos podemos obviar la lista de campos.
- podemos omitir valores para los campos que NO hayan sido declarados "not null", es decir,
que permitan valores nulos (se guardará "null"); si omitimos el valor para un campo "not null",
la sentencia no se ejecuta.
- se DEBE omitir el valor para el campo"identity". Salvo que identity_insert este en on.
- se pueden omitir valores para campos declarados "not null" siempre que tengan definido un
valor por defecto con la cláusula "default" (tema que veremos a continuación).

Ejercicio:

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

if object_id('libros') is not null

drop table libros;

Creamos la tabla:

create table libros(

codigo int identity,
titulo varchar(40) not null,
autor varchar(30),
editorial varchar(15)
);

Si ingresamos valores para todos los campos, podemos omitir la lista de campos:

insert into libros

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

Podemos ingresar valores para algunos de los campos:

insert into libros (titulo, autor)

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

No podemos omitir el valor para un campo declarado "not null", como el campo "titulo":

insert into libros (autor,editorial)

values ('Lewis Carroll','Planeta');

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

Veamos cómo SQL Server almacenó los registros:

select *from libros;