1. UNIDAD I Gestor de bases de datos .
1.1 Características del gestor.
A lo largo de estos años Microsoft ha ido recogiendo y estudiando las diferentes solicitudes y
sugerencias de administradores y desarrolladores de todo el mundo. Muchas de estas sugerencias
solicitaban mejoras en el diseño y el modo de gestionar y administrar las tareas de SQL Server.
Microsoft se esforzó en tratar de cumplir con todas estas sugerencias y rediseño desde su servidor
de base de datos. Como fruto de estas mejoras y otras muchas de rendimiento y estabilidad surgió
SQL Server 2005.
Para usuarios veteranos y nuevos en administración de bases de datos con SQL Server, se
quedarán sorprendidos en comprobar que con desde una única herramienta tenemos acceso a la
gestión de casi todas las tareas de SQL Server 2005. Esta herramienta que engloba todas las
funciones, es SQL Server 2005 Management Studio.
Para usuarios con experiencia ya, pueden ver que las antiguas herramientas como Analysis
Manager, Administrador Corporativo y el Analizador de Consultas, están todas compactadas en
SQL Server 2005 Management Studio.
Si además eres desarrollador de software con .net, el entorno te resultará muy familiar al que se
nos presenta en Visual Studio 2005.
Como es lógico la mayor parte del tiempo que dedicaremos como administradores o
desarrolladores de bases de datos estará invertido en esta herramienta, por lo tanto debemos
familiarizarnos al máximo a esta novedosa y potente herramienta.
1.2 Herramientas.
SQL Server Management Studio
Arrancamos la aplicación desde el menú de inicio tal y como vimos en el primer capítulo. Lo
primero que haremos para acceder a la herramienta es conectarnos al servidor, para eso
tendremos la conexión que hemos configurado durante la instalación del producto, así que
seleccionamos esos parámetros: "Autenticación de Windows" y pulsamos en conectar:

2. Al conectarnos se nos presenta la primera pantalla de nuestra herramienta, y observamos que
tenemos la pantalla dividida en dos ventanas:
• Explorador de objetos.
• Resumen.

3. Hay una tercera ventana que resulta muy útil y que por defecto es posible que SQL Server no
muestre: Servidores registrados.
Para mostrar esta ventana vamos al menú "Ver" y seleccionamos "Servidores registrados", de este
modo nuestra pantalla queda dividida en tres ventanas:

4. Si has desarrollado programas con Visual Studio, este entorno te será muy familiar. Visual Studio
se ha convertido en el entorno de programación preferido por los desarrolladores. Parte de este
éxito se debe al diseño del entorno de esta herramienta. Ya que permite un grado de
personalización muy alto, y el desarrollador puede disponer y utilizar el espacio al máximo para
tener un acceso más rápido y cómodo a sus herramientas más utilizadas.
Al igual que sucede con Visual Studio, con SQL Server Management Studio podemos personalizar
su presentación, y acceder rápidamente a nuestras herramientas preferidas. Para aumentar

5. nuestro espacio de trabajo sin influir en el funcionamiento original de Management Studio
tenemos las siguientes posibilidades:
• Cada una de las ventanas puede cambiar a cualquier localización.
• Si tenemos la suerte de trabajar con monitores compartidos, tenemos la posibilidad de
desacoplar la mayoría de ventanas y arrastrarla a cualquier posición.
• Las ventanas pueden ser ocultadas automáticamente, cuando una ventana permanece
oculta se convierte en una pestaña en el borde de la ventana principal. Para mostrarlas de
nuevo basta con colocar el puntero del ratón sobre esta ventana para que se muestre de
nuevo. Para activar y desactivar esta posibilidad tenemos un botón representado por una
chincheta. Otro modo de utilizar esta posibilidad es mediante el menú ventana->Ocultar
automáticamente:
Para activar y desactivar la posibilidad de ocultar automáticamente tenemos el botón chincheta:
Botón Descripción
Activada la opción "Ocultar
Automáticamente".
La ventana permanece fija, tenemos
desactivada la opción "Ocultar
automáticamente".
• Tenemos la posibilidad de configurar el entorno para que nos muestre la información
como fichas. Cada elemento aparece como una ficha el la localización que se encuentre, o
bien como una interfaz de múltiples documentos, conocida esta opción como MDI de
modo que cada documento está en su propia ventana. Para optar a esta configuración
tenemos el menú Herramientas->Opciones->Entorno->General y marcar la opción
Organización por fichas o Entorno MDI:

6. Los diferentes componentes de Management Studio están configurados para trabajar como un
todo. Todas las herramientas están entrelazadas, lo que hace de Management Studio una
herramienta muy eficaz.
Otra opción que debemos comentar es que Management Studio no tiene porque ser instalado en
el mismo servidor donde estamos explotando nuestra base de datos. De hecho el modo más
común de trabajar es tener SQL Server 2005 instalado en el servidor para explotar la base de
datos, y en un equipo a parte y personal del administrador tener instalado Management Studio,
de modo que el administrador pueda trabajar con la base de datos sin la necesidad de trabajar en
el servidor. Además este método de trabajo es aún más eficaz, ya que desde Management Studio
podemos estar conectados a varios servidores y administrar varias bases de datos instaladas en
diferentes servidores y todo esto desde el ordenador personal del administrador.
Servidores registrados.
Hemos visto en el anterior capítulo que la ventana que nos presenta la información relativa a los
Servidores registrados puede permanecer oculta por defecto.

7. Desde esta ventana podemos organizar los servidores "favoritos" a los que accedemos con mayor
frecuencia. Entra otras opciones tenemos la posibilidad de crear grupos de servidores para facilitar
la búsqueda de uno de ellos, en caso de que trabajemos con muchos servidores a la vez.
En el caso de SQL Server 2005 Express Edition tenemos limitados los tipos de servidores al motor
de base de datos que es con el que nos centramos en este curso. En versiones más avanzadas,
aparecerían el resto de tipos de servidores que nos ofrecen.
Desde esta ventana podemos pinchar con el botón derecho sobre el servidor y seleccionar
Conectar->Explorador de objetos, y de este modo nos conectaremos con ese servidor en concreto:
Una vez que estamos conectados, vemos que el icono del servidor aparece con un triángulo con
fondo verde que indica que estamos conectados actualmente a ese servidor:

8. Tenemos la posibilidad de añadir un nuevo registro de servidor, para ello pulsamos con el botón
derecho en el icono del tipo de servidor del cual queremos crear un nuevo registro. En nuestro
caso sólo tenemos el motor de base de datos, pulsamos con el botón derecho y seleccionamos
Nuevo->Registro de servidor...
Dentro de la ventana de Nuevo registro de servidor tenemos dos pestañas tal y como puedes ver
en las siguientes figuras:
Pestaña General:

9. Pestaña propiedades de conexión:

10. Desde estas ventanas tenemos la posibilidad de configurar las siguientes tareas:
Pestaña General:
• Modificar el modo de autenticación: Windows o SQL Server
• En caso de seleccionar el modo SQL Server de autenticación podemos introducir el
nombre de usuario y la contraseña.
• Incluir o modificar el nombre del servidor registrado y añadir una descripción si así lo
deseamos. La descripción no es obligatoria.
Pestaña Propiedades de conexión:
• Indicar la base de datos con la que deseamos conectar directamente al conectar con el
servidor.
• Seleccionar el protocolo de red con el cual conectamos.

11. • Definir el tamaño del paquete de red.
• Especificar el tiempo de espera de conexión y ejecución. Se trata del tiempo que
transcurrirá para conectar, una vez pasado este tiempo el Management Studio entenderá
que ocurre algún problema que no permite la conexión y lanzará un error.
• Activar o desactivar el cifrado de la conexión.
Para agilizar el proceso de registro de servidores, tenemos la opción de importar y exportar las
características de conexión definidas de un servidor a otro, y viceversa. Como es razonable,
podremos importar y exportar estos registros siempre y cuando se traten del mismo tipo de
servidores. Esta información de registro se almacena en archivos. Para llevar a cabo este proceso,
es tan sencillo como pinchar con el botón derecho en un servidor o en un grupo de servidores y
seleccionar del menú la opción Importar o Exportar, dependiendo de la tarea que queramos
realizar:
En la ventana que se nos muestra seleccionamos el archivo de registro y seleccionamos a que
servidor o grupo de servidor queremos aplicarlo, mediante el árbol de servidores:

12. Para eliminar un servidor o un grupo, lo haremos desde el menú que emerge al pulsar con el
botón derecho sobre el servidor a eliminar, nos mostrará un ventana de confirmación para evitar
errores.
Para modificar el nombre o las propiedades de conexión de cualquier servidor podemos pulsar con
el botón derecho y seleccionar la opción propiedades.
Para finalizar vamos a mostrar una tabla con los diferentes iconos que podemos encontrar en los
servidores y lo que significan:
Icono Descripción
No es posible realizar una
conexión con el servidor.
El servidor está en uso
actualmente.
El servidor está pausado.
El servidor está detenido.

13. Agrupar servidores.
Con la versión SQL Server 2000 apareció un nuevo concepto: Grupos de servidores.
El objetivo de los grupos de servidores es meramente organizativos. Es una utilidad administrativa
que ayuda al desarrollador a ordenar varios servidores por grupos, y no tiene ninguna influencia
sobre la actividad y la estructura de nuestros servidores. Físicamente no agrupa, ni conecta los
servidores que pertenezcan a un mismo grupo.
Con los grupos de servidores se pueden mostrar los servidores con diferentes nombres a sus
reales. La ventaja de esta característica es que podemos tener nombres reales que sean complejos
y utilizar nombres más descriptivos para su administración.
Además los grupos de servidores pueden anidarse, es decir, podemos tener un grupo de
servidores dentro de otro. Y podemos tener también un servidor en más de un grupo.
Imagina que nos encargan administrar una gran empresa dividida en diferentes departamentos:
Administración, Recursos Humanos y Producción.
Como se trata de una gran empresa, tenemos además oficinas en Madrid y Barcelona. Cada
departamento tiene su propio de servidor con su correspondiente servidor de base de datos que
guarda la información de la actividad realizada por su departamento.
En este caso podíamos organizar de varios modos nuestros servidores. El más lógico sería crear
dos grupos principales a los que llamaremos Madrid y Barcelona.
Y a su vez dentro de los grupos Madrid y Barcelona crear otros tres grupos que almacenen los
servidores de cada departamento.
Vamos a crear este organigrama de servidores con SQL Server 2005:
Para crear un nuevo grupo pinchamos con el botón derecho en el lugar donde queremos crear un
grupo y seleccionamos Nuevo->Grupo de servidores, podemos hacerlo en la raíz (sobre nuestro
motor de base de datos) o sobre otro grupo de servidores si deseamos anidarlo.

14. Esta operación nos mostrará una ventana donde nos podremos indicar un nombre para el grupo
de servidores y una breve descripción para el grupo. Además nos muestra un panel con la
estructura organizativa de nuestros servidores, como puedes ver en la siguiente figura:
Una vez creados los grupos iremos añadiendo los registros de servidores tal y como hemos visto
en capítulos anteriores.
Siguiendo estas operaciones, y anidando nuestros grupos finalmente conseguimos el siguiente
esquema que nos muestra la ventana de servidores registrados:

15. Explorador de objetos
Otra de las ventanas principales que nos muestra Management Studio es el Explorador de Objetos.
El explorador de objetos se encuentra conectado a los diferentes tipos de servidores que
tenemos. Los elementos que nos ofrece SQL Server 2005 varían en función del tipo de servidor,
pero hay características de desarrollo y herramientas de administración comunes para todos.
En esta ventana podemos ver una barra de herramientas que nos permite realizar unas
determinadas tareas. En la siguiente tabla mostramos estos botones con la tarea que tienen
asignada:

16. Icono Descripción
Realiza una conexión con el
servidor
Realiza una desconexión del
servidor.
Detiene un proceso, sólo estará
disponible durante la ejecución
de uno
Actualiza la lista de elementos
de la carpeta que tengamos
seleccionada.
Realiza un filtro o selección de
objetos, permanece en gris
cuando no es posible filtrar.
Conectar a un servidor
Pulsando en el botón destinado a la conexión con un servidor ( ), nos muestra la pantalla de
conexión que ya conocemos:

17. En esta ventana, tenemos que dar el nombre del servidor con el que deseamos conectar, y
seleccionar el tipo de autenticación con el que realizaremos la conexión. Si seleccionamos
Autenticación de Windows, podremos realizar la conexión, mientras que si elegimos la opción
Autenticación SQL Server, deberemos introducir el nombre de usuario y la contraseña. Esta opción
dependerá del tipo de registro que hayamos definido durante la instalación, o de la modificación
que hayamos realizado sobre el registro del servidor en sus propiedades.
Si pulsamos sobre el botón opciones, se nos abre una nueva ventana que puedes ver en la
siguiente figura:

18. Vemos que tenemos dos pestañas, la primera de ellas "Inicio se sesión" nos muestra la ventana de
conexión de la que partimos. Mientras que en la pestaña "Propiedades de conexión" nos muestra
la ventana que ves en la anterior figura. Esta ventana ya la conocemos, y la información que
podemos introducir ya la hemos visto en la ventana de propiedades que hemos comentado en el
anterior capítulo.
Carpetas del explorador de objetos.
La información y los elementos que tenemos en el explorador de objetos se organiza en carpetas
con estructura de árbol.
Cuando expandamos una de estas carpetas, el explorador de objetos recibe información del
servidor del contenido de la carpeta para poder mostrarlo. Esta petición sólo se realiza la primera
vez que expandimos una carpeta, por lo tanto, si hemos realizado alguna modificación en algún
componente de alguna lista desde la primera vez que expandimos la carpeta, esta modificación no
se mostrará en ella. Para que se muestre esa información "nueva", debemos seleccionar esa

19. carpeta y actualizarla, mediante la opción "actualizar" del menú que se muestra con el botón
derecho, o mediante el botón actualizar de la barra de herramientas.
Si trabajamos con bases de datos empresariales de gran tamaño, es posible que tengamos en una
carpeta un listado de objetos tan grande que no nos permita trabajar con comodidad. Lo más
frecuenta es que de ese listado, sólo nos interese trabajar con unos pocos en un determinado
momento.
Para facilitar esta tarea, tenemos la opción de mostrar sólo aquellos objetos que nos interesa,
mediante el botón de filtrado:
Hay carpetas que no permiten realizar un filtro, nos situamos en una de las carpetas que lo
permitan y pulsamos sobre el botón, para mostrar la ventana de "Configuración de filtro del
explorador de objetos":
Desde esta ventana nos permite realizar filtros por el nombre, esquema (no siempre está
disponible) y la fecha de creación, teniendo la opción de elegir el operador de comparación para el
filtro (Es igual a, Contiene y Entre).
Pestaña Resumen

20. La tercera ventana que nos muestra Management Studio aparece por defecto con la pestaña
"Resumen":
Esta pestaña es utilizada por el Explorador de Objetos para mostrar información del objeto que
tengamos seleccionado. Como puedes ver, esta pestaña tiene su propia barra de herramientas con
los siguientes botones:
Icono Descripción
Sube un nivel en el árbol de
carpetas.
Actualiza el elemento
seleccionado.
Sincroniza la información del
servidor.

21. Filtra el listado, en caso de ser
posible.
Tipo de vista para mostrar la
información:
• Lista: Listado de
objetos de la carpeta
seleccionada.
• Detalles: Muestra
información por
diferentes categorías
del objeto
seleccionado.
El modo de navegación por las carpetas de la pestaña "Resumen" es muy parecido al explorador
de Windows.
Carpetas principales.
En el explorador de objetos de SQL Server 2005 Express Edition (Versión avanzada) tenemos las
siguientes carpetas principales:
• Bases de datos.
• Seguridad.
• Objetos de servidor .
• Réplica.
• Administración.
En este curso iremos viendo la mayoría de objetos que encierran estas carpetas.

22. Carpeta de bases de datos.
En esta carpeta podemos encontrar las bases de datos del sistema y las de usuarios que vayamos
creando nosotros.
Dentro de las bases de datos de usuarios podemos encontrar carpetas anidadas agrupadas por los
objetos que contiene:
Árbol de Bases de Datos.
Base de
datos de Diagramas de bases de datos.
usuario.
Tablas
Vistas.
Sinónimos.
Programación. • Procedimientos
Almacenados.
• Funciones.
• Desencadenadores
de bases de datos.

23. • Ensamblados.
• Tipos.
• Reglas.
• Valores
predeterminados.
• Usuarios.
• Funciones.
• Esquemas.
Seguridad.
• Claves asimétricas.
• Certificados.
• Claves simétricas.
Todos estos objetos puedes verlos al extender una base de datos de usuario. En este caso
mostramos en la siguiente figuras los nodos principales de la base de datos Northwind:

24. 1.3 Instalación y configuración del entorno operativo.
Estructura física
Una base de datos se almacena en varios ficheros o archivos en disco. Como mínimo tendremos
dos ficheros que explicaremos más adelante. Tenemos la posibilidad de almacenar estos ficheros
en discos que no estén ni tan siquiera formateados o que no tengan una partición hecha, pero este
método no es el más aconsejable. Es más razonable almacenar estos archivos en un disco ya
formateado, con formato NTFS.
En empresas cuyo volumen de datos es altísimo y el trabajo que se realiza sobre la base de datos
soporta una actividad elevada, se almacenan los archivos en grupos de discos denominados RAID
por hardware. Este método mejora considerablemente el rendimiento, y nos asegura que en caso
de fallos inesperados no perdamos esa valiosa información.
Como es lógico, nosotros para realizar nuestros ejemplos, no vamos a basarnos en esta tipo de
estructuras de hardware, lo almacenaremos en nuestro disco duro, aunque veremos como
asegurar nuestros datos mediante planes de mantenimiento con copias de seguridad automáticas.
Como hemos mencionado, como mínimo tendremos dos archivos donde almacenar la base de
datos:
· Archivo de datos.
· Archivo de registro de transacciones.

25. Pero debes saber que tenemos otras posibilidades y podemos utilizar archivos extras para mejorar
el rendimiento de nuestra base de datos, podemos usar varios archivos, si pensamos que nuestra
base de datos va a alcanzar un tamaño grande. O si deseamos que nuestros datos se almacenen
en diferentes dispositivos de almacenamiento u ordenadores, y de este modo permitir un trabajo
más rápido al poder acceder a la información en paralelo.
Centrándonos en lo principal:
El archivo de datos, o aquellos que añadimos como extras, son los archivos que tendrán
almacenada la información, los datos. Pero recuerda que hemos dicho que SQL Server 2005 nos
permite también crear en nuestras bases de datos, no sólo información, sino también una serie de
objetos que trabajan con la información. Pues bien, esta serie de objetos también se almacena en
el archivo de datos.
Por otro lado, tenemos el archivo de registro de transacciones. Este fichero es tan importante como
el anterior. Su importante tarea es garantizar que esa base de datos permanece integra. Gracias a
estos archivos de registros (puede haber más de uno), en caso de ser necesario, podremos
recuperar la base de datos, ya que almacena las modificaciones que se producen debido a la
actividad o la explotación de la base de datos.
Nombres de archivos.
El modo de nombrar una base de datos, parte de una base fija, de un nombre principal que
generalmente entrega el administrador de la base de datos. Una vez que tenemos este nombre
principal, SQL Server 2005 se encarga de añadir terminaciones y unas determinadas extensiones,
a ese nombre principal. El administrador además de seleccionar el nombre principal, puede elegir
el destino donde se almacenarán los ficheros que forman la base de datos.
Vamos a suponer que estamos en una empresa como administradores, y estamos creando su
base de datos. Nosotros como administradores le damos el nombre principal " miEmpresa ". Ese
será el nombre de la base de datos, pero los ficheros donde se almacenará su información y el
registro de transacciones, serán:
· Archivo de datos: miEmpresa_Data.MDF
· Archivo de registro de transacciones: miEmpresa_Log.LDF
En caso de tener archivos extras, nosotros como administradores también podremos darles su
nombre principal, y la extensión que suele utilizarse es .NDF
Siguiendo con nuestra tarea de administrador, ahora sería el momento de seleccionar el lugar de
almacenamiento, como ya sabes podemos seleccionar una determinada carpeta o directorio,
incluso diferentes unidades físicas. Lo más aconsejable es guardar en diferentes unidades, por un
lado el archivo de datos, y por otro el archivo de registro de transacciones. De modo que en caso
de fallo, por lo menos tengamos uno de ellos.
A continuación puedes ver una figura que representa la estructura física de la base de datos,
tomando como ejemplo el nombre principal "MiEmpresa".
No debes quedarte con la idea de que una base de datos, se compone sencillamente de dos
archivos, es algo mucho más completo que todo eso lo que representa una base de datos como
entidad.

26. En el momento de crear la base de datos, es casi imposible conocer la cantidad de memoria que
necesitará para almacenar toda la información. Es cierto que hay ciertas técnicas que nos permiten
calcular el tamaño que podrá alcanzar la base de datos, pero estas estimaciones pueden venirse a
bajo, por modificaciones imprevistas, como puede ser el crecimiento de la empresa y que se
intensifique la actividad realizada sobre la información, por citar un ejemplo.
Tampoco es nada aconsejable pecar de precavidos y reservar una cantidad de memoria
exagerada, y pensar que con esta cantidad casi infinita no tendremos problemas de espacio para
nuestros datos. De acuerdo, puede que no haya problemas de espacio (o quizá sí), pero lo que es
seguro es que tendremos muchísimos problemas de rendimiento, de fragmentación etc...
SQL Server 2005 nos permite olvidarnos hasta cierto punto de este problema. Los archivos de
datos y de registro, crecen automáticamente. No crecen con cada dato que se añade. Nosotros
como administradores, le daremos un tamaño inicial sencillo de estimar ( una cantidad muy
pequeña, unos Megabytes ), en ese momento SQL Server 2005 crea la estructura correcta para la
base de datos, y una vez que nuestra base de datos está en explotación cuando alcanza el tamaño
limite, lo incrementa una cantidad dada por un factor predeterminado.
Visto de modo teórico puede asustar un poco, sólo estamos comenzando a crear la base de datos,
y estamos mencionando varias características a tener en cuenta. No tenemos porque asustarnos,
veremos como estos parámetros se pueden dar de un modo altamente sencillo mediante el interfaz
de SQL Server 2005, y como con pocos clicks, todos estos aspectos los realiza SQL Server por
nosotros, así que no te preocupes y sigue leyendo.
Unidad II
1 - Crear una tabla (create table - sp_tables - sp_columns - drop table)
DETALLE DEL CONCEPTO
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';

27. 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,
...
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:

28. drop table usuarios; Si intentamos eliminar una tabla que no existe, aparece un mensaje de error
indicando tal situación y la sentencia no se ejecuta. Para evitar este mensaje podemos agregar a la
instrucción lo siguiente:
if object_id('usuarios') is not null
drop table usuarios;
En la sentencia precedente especificamos que elimine la tabla "usuarios" si existe.
2 - Insertar y recuperar registros de una tabla (insert into - select)
DETALLE DE CONCEPTO
Un registro es una fila de la tabla que contiene los datos propiamente dichos. Cada registro tiene
un dato por cada columna (campo). Nuestra tabla "usuarios" consta de 2 campos, "nombre" y
"clave".
Al ingresar los datos de cada registro debe tenerse en cuenta la cantidad y el orden de los campos.
La sintaxis básica y general es la siguiente:
insert into NOMBRETABLA (NOMBRECAMPO1, ..., NOMBRECAMPOn)
values (VALORCAMPO1, ..., VALORCAMPOn);
Usamos "insert into", luego el nombre de la tabla, detallamos los nombres de los campos entre
paréntesis y separados por comas y luego de la cláusula "values" colocamos los valores para cada
campo, también entre paréntesis y separados por comas.
Para agregar un registro a la tabla tipeamos:
insert into usuarios (nombre, clave) values ('Mariano','payaso');
Note que los datos ingresados, como corresponden a cadenas de caracteres se colocan entre
comillas simples.
Para ver los registros de una tabla usamos "select":
select * from usuarios;
El comando "select" recupera los registros de una tabla.
Con el asterisco indicamos que muestre todos los campos de la tabla "usuarios".
Es importante ingresar los valores en el mismo orden en que se nombran los campos:
insert into usuarios (clave, nombre) values ('River','Juan');
En el ejemplo anterior se nombra primero el campo "clave" y luego el campo "nombre" por eso, los
valores también se colocan en ese orden.
Si ingresamos los datos en un orden distinto al orden en que se nombraron los campos, no
aparece un mensaje de error y los datos se guardan de modo incorrecto.

29. 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');
4 - Tipos de datos básicos
DETALLE DE CONCEPTO
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.
3 - Recuperar algunos campos (select)
DETALLE DE CONCEPTO

30. Hemos aprendido cómo ver todos los registros de una tabla, empleando la instrucción "select".
La sintaxis básica y general es la siguiente:
select * from NOMBRETABLA;
El asterisco (*) indica que se seleccionan todos los campos de la tabla.
Podemos especificar el nombre de los campos que queremos ver separándolos por comas:
select titulo,autor from libros;
La lista de campos luego del "select" selecciona los datos correspondientes a los campos
nombrados. En el ejemplo anterior seleccionamos los campos "titulo" y "autor" de la tabla "libros",
mostrando todos los registros. Los datos aparecen ordenados según la lista de selección, en dicha
lista los nombres de los campos se separan con comas.
4 - Operadores relacionales
DESARROLLO DE CONCEPTO
Los operadores son símbolos que permiten realizar operaciones matemáticas, concatenar
cadenas, hacer comparaciones.
SQL Server tiene 4 tipos de operadores:
1. relacionales (o de comparación)
2. aritméticos
3. de concatenación
4. lógicos.
Por ahora veremos solamente los primeros.
Los operadores relacionales (o de comparación) nos permiten comparar dos expresiones, que
pueden ser variables, valores de campos, etc.
Hemos aprendido a especificar condiciones de igualdad para seleccionar registros de una tabla;
por ejemplo:
select *from libros
where autor='Borges';
Utilizamos el operador relacional de igualdad.
Los operadores relacionales vinculan un campo con un valor para que SQL Server compare cada
registro (el campo especificado) con el valor dado.
Los operadores relacionales son los siguientes:
= igual
<> distinto
> mayor
< menor
>= mayor o igual
<= menor o igual
Podemos seleccionar los registros cuyo autor sea diferente de "Borges", para ello usamos la
condición:
select * from libros
where autor<>'Borges';
Podemos comparar valores numéricos. Por ejemplo, queremos mostrar los títulos y precios de los
libros cuyo precio sea mayor a 20 pesos:
select titulo, precio
from libros
where precio>20;

31. 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.
5 - Borrar registros (delete)
DETALLE DE CONCEPTO
Para eliminar los registros de una tabla usamos el comando "delete":
delete from usuarios;
Muestra un mensaje indicando la cantidad de registros que ha eliminado.
Si no queremos eliminar todos los registros, sino solamente algunos, debemos indicar cuál o
cuáles, para ello utilizamos el comando "delete" junto con la clausula "where" con la cual
establecemos la condición que deben cumplir los registros a borrar.
Por ejemplo, queremos eliminar aquel registro cuyo nombre de usuario es "Marcelo":
delete from usuarios
where nombre='Marcelo';
Si solicitamos el borrado de un registro que no existe, es decir, ningún registro cumple con la
condición especificada, ningún registro será eliminado.
Tenga en cuenta que si no colocamos una condición, se eliminan todos los registros de la tabla
nombrada.
6 - Actualizar registros (update)
DETALLE DE CONCEPTO
Decimos que actualizamos un registro cuando modificamos alguno de sus valores.
Para modificar uno o varios datos de uno o varios registros utilizamos "update" (actualizar).
Por ejemplo, en nuestra tabla "usuarios", queremos cambiar los valores de todas las claves, por
"RealMadrid":
update usuarios set clave='RealMadrid';
Utilizamos "update" junto al nombre de la tabla y "set" junto con el campo a modificar y su nuevo
valor.
El cambio afectará a todos los registros.
Podemos modificar algunos registros, para ello debemos establecer condiciones de selección con
"where".
Por ejemplo, queremos cambiar el valor correspondiente a la clave de nuestro usuario llamado
"Federicolopez", queremos como nueva clave "Boca", necesitamos una condición "where" que
afecte solamente a este registro:
update usuarios set clave='Boca'
where nombre='Federicolopez';
Si Microsoft SQL Server no encuentra registros que cumplan con la condición del "where", no se
modifica ninguno.
Las condiciones no son obligatorias, pero si omitimos la cláusula "where", la actualización afectará
a todos los registros.
También podemos actualizar varios campos en una sola instrucción:

32. 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.
7 - Comentarios
DETALLE DE CONCEPTO
Para aclarar algunas instrucciones, en ocasiones, necesitamos agregar comentarios.
Es posible ingresar comentarios en la línea de comandos, es decir, un texto que no se ejecuta;
para ello se emplean dos guiones (--) al comienzo de la línea:
select * from libros --mostramos los registros de libros;
en la línea anterior, todo lo que está luego de los guiones (hacia la derecha) no se ejecuta.
Para agregar varias líneas de comentarios, se coloca una barra seguida de un asterisco (/*) al
comienzo del bloque de comentario y al finalizarlo, un asterisco seguido de una barra (*/).
select titulo, autor
/*mostramos títulos y
nombres de los autores*/
from libros;
todo lo que está entre los símbolos "/*" y "*/" no se ejecuta.
8 - Valores null (is null)
DETALLE DE CONCEPTO
"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.

33. 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".
9 - Clave primaria
DETALLE DEL CONCEPTO

34. 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.
10 - Campo con atributo Identity
DETALLE DE CONCEPTO

35. 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".
11 - Otras características del atributo Identity
DETALLE DEL CONCEPTO
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),

36. 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;
12 - Truncate table
DETALLE DE CONCEPTO
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.

37. 13 - Otros tipos de datos en SQL Server
DETALLE DE CONCEPTO
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 dato básicos.
17 - Tipo de dato (texto)
DETALLE DE CONCEPTO
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.

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

39. nvarchar(x) 0 a 8K
nchar(x) 0 a 8K
ntext 0 a 2GB
18 - Tipo de dato (numérico)
DETALLE DE CONCEPTO
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.

40. 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
19 - Tipo de dato (fecha y hora)
DETALLE DE CONCEPTO
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'.

41. Podemos emplear los operadores relacionales vistos para comparar fechas.
Tipo Bytes de almacenamiento
_______________________________________
datetime 8
smalldatetime 4
20 - Ingresar algunos campos (insert into)
DETALLE DE CONCEPTO
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).
21 - Valores por defecto (default)
DETALLE DE CONCEPTO
Hemos visto que si al insertar registros no se especifica un valor para un campo que admite
valores nulos, se ingresa automaticamente "null" y si el campo está declarado "identity", se inserta
el siguiente de la secuencia. A estos valores se les denomina valores por defecto o
predeterminados.
Un valor por defecto se inserta cuando no está presente al ingresar un registro y en algunos casos
en que el dato ingresado es inválido.
Para campos de cualquier tipo no declarados "not null", es decir, que admiten valores nulos, el
valor por defecto es "null". Para campos declarados "not null", no existe valor por defecto, a menos
que se declare explícitamente con la cláusula "default".

42. Para todos los tipos, excepto los declarados "identity", se pueden explicitar valores por defecto con
la cláusula "default".
Podemos establecer valores por defecto para los campos cuando creamos la tabla. Para ello
utilizamos "default" al definir el campo. Por ejemplo, queremos que el valor por defecto del campo
"autor" de la tabla "libros" sea "Desconocido" y el valor por defecto del campo "cantidad" sea "0":
create table libros(
codigo int identity,
titulo varchar(40),
autor varchar(30) not null default 'Desconocido',
editorial varchar(20),
precio decimal(5,2),
cantidad tinyint default 0
);
Si al ingresar un nuevo registro omitimos los valores para el campo "autor" y "cantidad", Sql Server
insertará los valores por defecto; el siguiente valor de la secuencia en "codigo", en "autor" colocará
"Desconocido" y en cantidad "0".
Entonces, si al definir el campo explicitamos un valor mediante la cláusula "default", ése será el
valor por defecto.
Ahora, al visualizar la estructura de la tabla con "sp_columns" podemos entender lo que informa la
columna "COLUMN_DEF", muestra el valor por defecto del campo.
También se puede utilizar "default" para dar el valor por defecto a los campos en sentencias
"insert", por ejemplo:
insert into libros (titulo,autor,precio,cantidad)
values ('El gato con botas',default,default,100);
Si todos los campos de una tabla tienen valores predeterminados (ya sea por ser "identity", permitir
valores nulos o tener un valor por defecto), se puede ingresar un registro de la siguiente manera:
insert into libros default values;
La sentencia anterior almacenará un registro con los valores predetermiandos para cada uno de
sus campos.
Entonces, la cláusula "default" permite especificar el valor por defecto de un campo. Si no se
explicita, el valor por defecto es "null", siempre que el campo no haya sido declarado "not null".
Los campos para los cuales no se ingresan valores en un "insert" tomarán los valores por defecto:
- si tiene el atributo "identity": el valor de inicio de la secuencia si es el primero o el siguiente valor
de la secuencia, no admite cláusula "default";
- si permite valores nulos y no tiene cláusula "default", almacenará "null";
- si está declarado explícitamente "not null", no tiene valor "default" y no tiene el atributo "identity",
no hay valor por defecto, así que causará un error y el "insert" no se ejecutará.
- si tiene cláusula "default" (admita o no valores nulos), el valor definido como predeterminado;
- para campos de tipo fecha y hora, si omitimos la parte de la fecha, el valor predeterminado para
la fecha es "1900-01-01" y si omitimos la parte de la hora, "00:00:00".
Un campo sólo puede tener un valor por defecto. Una tabla puede tener todos sus campos con
valores por defecto. Que un campo tenga valor por defecto no significa que no admita valores
nulos, puede o no admitirlos
22 - Columnas calculadas (operadores aritméticos y de concatenación)
DETALLE DE CONCEPTO

43. Aprendimos que los operadores son símbolos que permiten realizar distintos tipos de operaciones.
Dijimos que SQL Server tiene 4 tipos de operadores: 1) relacionales o de comparación (los vimos),
2) lógicos (lo veremos más adelante, 3) aritméticos y 4) de concatenación.
Los operadores aritméticos permiten realizar cálculos con valores numéricos.
Son: multiplicación (*), división (/) y módulo (%) (el resto de dividir números enteros), suma (+) y
resta (-).
Es posible obtener salidas en las cuales una columna sea el resultado de un cálculo y no un campo
de una tabla.
Si queremos ver los títulos, precio y cantidad de cada libro escribimos la siguiente sentencia:
select titulo,precio,cantidad
from libros;
Si queremos saber el monto total en dinero de un título podemos multiplicar el precio por la
cantidad por cada título, pero también podemos hacer que SQL Server realice el cálculo y lo
incluya en una columna extra en la salida:
select titulo, precio,cantidad,
precio*cantidad
from libros;
Si queremos saber el precio de cada libro con un 10% de descuento podemos incluir en la
sentencia los siguientes cálculos:
select titulo,precio,
precio-(precio*0.1)
from libros;
También podemos actualizar los datos empleando operadores aritméticos:
update libros set precio=precio-(precio*0.1);
Todas las operaciones matemáticas retornan "null" en caso de error. Ejemplo:
select 5/0;
Los operadores de concatenación: permite concatenar cadenas, el más (+).
Para concatenar el título, el autor y la editorial de cada libro usamos el operador de concatenación
("+"):
select titulo+'-'+autor+'-'+editorial
from libros;
Note que concatenamos además unos guiones para separar los campos.
23 - Alias
DETALLE DE CONCEPTO
Una manera de hacer más comprensible el resultado de una consulta consiste en cambiar los
encabezados de las columnas.
Por ejemplo, tenemos la tabla "agenda" con un campo "nombre" (entre otros) en el cual se
almacena el nombre y apellido de nuestros amigos; queremos que al mostrar la información de
dicha tabla aparezca como encabezado del campo "nombre" el texto "nombre y apellido", para ello
colocamos un alias de la siguiente manera:
select nombre as NombreYApellido,
domicilio,telefono
from agenda;

44. Para reemplazar el nombre de un campo por otro, se coloca la palabra clave "as" seguido del texto
del encabezado.
Si el alias consta de una sola cadena las comillas no son necesarias, pero si contiene más de una
palabra, es necesario colocarla entre comillas simples:
select nombre as 'Nombre y apellido',
domicilio,telefono
from agenda;
Un alias puede contener hasta 128 caracteres.
También se puede crear un alias para columnas calculadas.
La palabra clave "as" es opcional en algunos casos, pero es conveniente usarla.
Entonces, un "alias" se usa como nombre de un campo o de una expresión. En estos casos, son
opcionales, sirven para hacer más comprensible el resultado; en otros casos, que veremos más
adelante, son obligatorios.
24 – Funciones
DETALLE DE CONCEPTO
Una función es un conjunto de sentencias que operan como una unidad lógica.
Una función tiene un nombre, retorna un parámetro de salida y opcionalmente acepta parámetros
de entrada. Las funciones de SQL Server no pueden ser modificadas, las funciones definidas por el
usuario si.
SQL Server ofrece varios tipos de funciones para realizar distintas operaciones. Se pueden
clasificar de la siguiente manera:
1) de agregado: realizan operaciones que combinan varios valores y retornan un único valor. Son
"count", "sum", "min" y "max".
2) escalares: toman un solo valor y retornan un único valor. Pueden agruparse de la siguiente
manera:
- de configuración: retornan información referida a la configuración.
Ejemplo:
select @@version;
retorna la fecha, versión y tipo de procesador de SQL Server.
- de cursores: retornan información sobre el estado de un cursor.
- de fecha y hora: operan con valores "datetime" y "smalldatetime". Reciben un parámetro de tipo
fecha y hora y retornan un valor de cadena, numérico o de fecha y hora.
- matemáticas: realizan operaciones numéricas, geométricas y trigonométricas.
- de metadatos: informan sobre las bases de datos y los objetos.
- de seguridad: devuelven información referente a usuarios y funciones.
- de cadena: operan con valores "char", "varchar", "nchar", "nvarchar", "binary" y "varbinary" y
devuelven un valor de cadena o numérico.
- del sistema: informan sobre opciones, objetos y configuraciones del sistema. Ejemplo:
select user_name();
- estadísticas del sistema: retornan información referente al rendimiento del sistema.
- texto e imagen: realizan operaciones con valor de entrada de tipo text o image y retornan
información referente al mismo.
3) de conjuntos de filas: retornan conjuntos de registros.
Se pueden emplear las funciones del sistema en cualquier lugar en el que se permita una
expresión en una sentencia "select".

45. Estudiaremos algunas de ellas.
25 - Funciones para el manejo de cadenas
DETALLE DE CONCEPTO
Microsoft SQL Server tiene algunas funciones para trabajar con cadenas de caracteres. Estas son
algunas:
- substring(cadena,inicio,longitud): devuelve una parte de la cadena especificada como primer
argumento, empezando desde la posición especificada por el segundo argumento y de tantos
caracteres de longitud como indica el tercer argumento. Ejemplo:
select substring('Buenas tardes',8,6);
retorna "tardes".
- str(numero,longitud,cantidaddecimales): convierte números a caracteres; el primer parámetro
indica el valor numérico a convertir, el segundo la longitud del resultado (debe ser mayor o igual a
la parte entera del número más el signo si lo tuviese) y el tercero, la cantidad de decimales. El
segundo y tercer argumento son opcionales y deben ser positivos. String significa cadena en
inglés.
Ejemplo: se convierte el valor numérico "123.456" a cadena, especificando 7 de longitud y 3
decimales:
select str(123.456,7,3);
select str(-123.456,7,3);
retorna '-123.46';
Si no se colocan el segundo y tercer argumeno, la longitud predeterminada es 10 y la cantidad de
decimales 0 y se redondea a entero. Ejemplo: se convierte el valor numérico "123.456" a cadena:
select str(123.456);
retorna '123';
select str(123.456,3);
retorna '123';
Si el segundo parámetro es menor a la parte entera del número, devuelve asteriscos (*). Ejemplo:
select str(123.456,2,3);
retorna "**".
- stuff(cadena1,inicio,cantidad,cadena2): inserta la cadena enviada como cuarto argumento, en la
posición indicada en el segundo argumento, reemplazando la cantidad de caracteres indicada por
el tercer argumento en la cadena que es primer parámetro. Stuff significa rellenar en inglés.
Ejemplo:
select stuff('abcde',3,2,'opqrs');
retorna "abopqrse". Es decir, coloca en la posición 2 la cadena "opqrs" y reemplaza 2 caracteres
de la primer cadena.
Los argumentos numéricos deben ser positivos y menor o igual a la longitud de la primera cadena,
caso contrario, retorna "null".
Si el tercer argumento es mayor que la primera cadena, se elimina hasta el primer carácter.
- len(cadena): retorna la longitud de la cadena enviada como argumento. "len" viene de length, que
significa longitud en inglés. Ejemplo:
select len('Hola');
devuelve 4.
- char(x): retorna un caracter en código ASCII del entero enviado como argumento. Ejemplo:

46. select char(65);
retorna "A".
- left(cadena,longitud): retorna la cantidad (longitud) de caracteres de la cadena comenzando
desde la izquierda, primer caracter. Ejemplo:
select left('buenos dias',8);
retorna "buenos d".
- right(cadena,longitud): retorna la cantidad (longitud) de caracteres de la cadena comenzando
desde la derecha, último caracter. Ejemplo:
select right('buenos dias',8);
retorna "nos dias".
-lower(cadena): retornan la cadena con todos los caracteres en minúsculas. lower significa reducir
en inglés. Ejemplo:
select lower('HOLA ESTUDIAnte');
retorna "hola estudiante".
-upper(cadena): retornan la cadena con todos los caracteres en mayúsculas. Ejemplo:
select upper('HOLA ESTUDIAnte');
-ltrim(cadena): retorna la cadena con los espacios de la izquierda eliminados. Trim significa
recortar. Ejemplo:
select ltrim(' Hola ');
retorna "Hola ".
- rtrim(cadena): retorna la cadena con los espacios de la derecha eliminados. Ejemplo:
select rtrim(' Hola ');
retorna " Hola".
- replace(cadena,cadenareemplazo,cadenareemplazar): retorna la cadena con todas las
ocurrencias de la subcadena reemplazo por la subcadena a reemplazar. Ejemplo:
select replace('xxx.sqlserverya.com','x','w');
retorna "www.sqlserverya.com'.
- reverse(cadena): devuelve la cadena invirtiendo el order de los caracteres. Ejemplo:
select reverse('Hola');
retorna "aloH".
- patindex(patron,cadena): devuelve la posición de comienzo (de la primera ocurrencia) del patrón
especificado en la cadena enviada como segundo argumento. Si no la encuentra retorna 0.
Ejemplos:
select patindex('%Luis%', 'Jorge Luis Borges');
retorna 7.
select patindex('%or%', 'Jorge Luis Borges');
retorna 2.
select patindex('%ar%', 'Jorge Luis Borges');
retorna 0.
- charindex(subcadena,cadena,inicio): devuelve la posición donde comienza la subcadena en la
cadena, comenzando la búsqueda desde la posición indicada por "inicio". Si el tercer argumento no
se coloca, la búsqueda se inicia desde 0. Si no la encuentra, retorna 0. Ejemplos:
select charindex('or','Jorge Luis Borges',5);
retorna 13.
select charindex('or','Jorge Luis Borges');
retorna 2.
select charindex('or','Jorge Luis Borges',14);
retorna 0.
select charindex('or', 'Jorge Luis Borges');

47. retorna 0.
- replicate(cadena,cantidad): repite una cadena la cantidad de veces especificada. Ejemplo:
select replicate ('Hola',3);
retorna "HolaHolaHola";
- space(cantidad): retorna una cadena de espacios de longitud indicada por "cantidad", que debe
ser un valor positivo. Ejemplo:
select 'Hola'+space(1)+'que tal';
retorna "Hola que tal".
Se pueden emplear estas funciones enviando como argumento el nombre de un campo de tipo
caracter.
26 - Funciones matemáticas
DETALLE DE CONCEPTO
Las funciones matemáticas realizan operaciones con expresiones numéricas y retornan un
resultado, operan con tipos de datos numéricos.
Microsoft SQL Server tiene algunas funciones para trabajar con números. Aquí presentamos
algunas.
-abs(x): retorna el valor absoluto del argumento "x". Ejemplo:
select abs(-20);
retorna 20.
-ceiling(x): redondea hacia arriba el argumento "x". Ejemplo:
select ceiling(12.34);
retorna 13.
-floor(x): redondea hacia abajo el argumento "x". Ejemplo:
select floor(12.34);
retorna 12.
- %: %: devuelve el resto de una división. Ejemplos:
select 10%3;
retorna 1.
select 10%2;
retorna 0.
-power(x,y): retorna el valor de "x" elevado a la "y" potencia. Ejemplo:
select power(2,3);
retorna 8.
-round(numero,longitud): retorna un número redondeado a la longitud especificada. "longitud" debe
ser tinyint, smallint o int. Si "longitud" es positivo, el número de decimales es redondeado según
"longitud"; si es negativo, el número es redondeado desde la parte entera según el valor de
"longitud". Ejemplos:
select round(123.456,1);
retorna "123.400", es decir, redondea desde el primer decimal.
select round(123.456,2);
retorna "123.460", es decir, redondea desde el segundo decimal.
select round(123.456,-1);
retorna "120.000", es decir, redondea desde el primer valor entero (hacia la izquierda).
select round(123.456,-2);
retorna "100.000", es decir, redondea desde el segundo valor entero (hacia la izquierda).
-sign(x): si el argumento es un valor positivo devuelve 1;-1 si es negativo y si es 0, 0.

48. -square(x): retorna el cuadrado del argumento. Ejemplo:
select square(3); retorna 9.
-srqt(x): devuelve la raiz cuadrada del valor enviado como argumento.
SQL Server dispone de funciones trigonométricas que retornan radianes.
Se pueden emplear estas funciones enviando como argumento el nombre de un campo de tipo
numérico
27 - Funciones para el uso de fechas y horas
DETALLE DE CONCEPTO
Microsoft SQL Server ofrece algunas funciones para trabajar con fechas y horas. Estas son
algunas:
- getdate(): retorna la fecha y hora actuales. Ejemplo:
select getdate();
- datepart(partedefecha,fecha): retorna la parte específica de una fecha, el año, trimestre, día,
hora, etc.
Los valores para "partedefecha" pueden ser: year (año), quarter (cuarto), month (mes), day (dia),
week (semana), hour (hora), minute (minuto), second (segundo) y millisecond (milisegundo).
Ejemplos:
select datepart(month,getdate());
retorna el número de mes actual;
select datepart(day,getdate());
retorna el día actual;
select datepart(hour,getdate());
retorna la hora actual;
- datename(partedefecha,fecha): retorna el nombre de una parte específica de una fecha. Los
valores para "partedefecha" pueden ser los mismos que se explicaron anteriormente. Ejemplos:
select datename(month,getdate());
retorna el nombre del mes actual;
select datename(day,getdate());
- dateadd(partedelafecha,numero,fecha): agrega un intervalo a la fecha especificada, es decir,
retorna una fecha adicionando a la fecha enviada como tercer argumento, el intervalo de tiempo
indicado por el primer parámetro, tantas veces como lo indica el segundo parámetro. Los valores
para el primer argumento pueden ser: year (año), quarter (cuarto), month (mes), day (dia), week
(semana), hour (hora), minute (minuto), second (segundo) y millisecond (milisegundo). Ejemplos:
select dateadd(day,3,'1980/11/02');
retorna "1980/11/05", agrega 3 días.
select dateadd(month,3,'1980/11/02');
retorna "1981/02/02", agrega 3 meses.
select dateadd(hour,2,'1980/11/02');
retorna "1980/02/02 2:00:00", agrega 2 horas.
select dateadd(minute,16,'1980/11/02');
retorna "1980/02/02 00:16:00", agrega 16 minutos.
- datediff(partedelafecha,fecha1,fecha2): calcula el intervalo de tiempo (según el primer argumento)
entre las 2 fechas. El resultado es un valor entero que corresponde a fecha2-fecha1. Los valores
de "partedelafecha) pueden ser los mismos que se especificaron anteriormente. Ejemplos:
select datediff (day,'2005/10/28','2006/10/28');
retorna 365 (días).

49. select datediff(month,'2005/10/28','2006/11/29');
retorna 13 (meses).
- day(fecha): retorna el día de la fecha especificada. Ejemplo:
select day(getdate());
- month(fecha): retorna el mes de la fecha especificada. Ejemplo:
select month(getdate());
- year(fecha): retorna el año de la fecha especificada. Ejemplo:
select year(getdate());
Se pueden emplear estas funciones enviando como argumento el nombre de un campo de tipo
datetime o smalldatetime.
28 - Ordenar registros (order by)
DETALLE DE CONCEPTO
Podemos ordenar el resultado de un "select" para que los registros se muestren ordenados por
algún campo, para ello usamos la cláusula "order by".
La sintaxis básica es la siguiente:
select *from NOMBRETABLA
order by CAMPO;
Por ejemplo, recuperamos los registros de la tabla "libros" ordenados por el título:
select *from libros
order by titulo;
Aparecen los registros ordenados alfabéticamente por el campo especificado.
También podemos colocar el número de orden del campo por el que queremos que se ordene en
lugar de su nombre, es decir, referenciar a los campos por su posición en la lista de selección. Por
ejemplo, queremos el resultado del "select" ordenado por "precio":
select titulo,autor,precio
from libros order by 3;
Por defecto, si no aclaramos en la sentencia, los ordena de manera ascendente (de menor a
mayor).
Podemos ordenarlos de mayor a menor, para ello agregamos la palabra clave "desc":
select *libros
order by editorial desc;
También podemos ordenar por varios campos, por ejemplo, por "titulo" y "editorial":
select *from libros
order by titulo,editorial;
Incluso, podemos ordenar en distintos sentidos, por ejemplo, por "titulo" en sentido ascendente y
"editorial" en sentido descendente:
select *from libros
order by titulo asc, editorial desc;
Debe aclararse al lado de cada campo, pues estas palabras claves afectan al campo
inmediatamente anterior.
Es posible ordenar por un campo que no se lista en la selección.
Se permite ordenar por valores calculados o expresiones.
La cláusula "order by" no puede emplearse para campos text, ntext e image.

50. 29 - Operadores lógicos ( and - or - not)
DETALLE DE CONCEPTO
Hasta el momento, hemos aprendido a establecer una condición con "where" utilizando operadores
relacionales. Podemos establecer más de una condición con la cláusula "where", para ello
aprenderemos los operadores lógicos.
Son los siguientes:
- and, significa "y",
- or, significa "y/o",
- not, significa "no", invierte el resultado
- (), paréntesis
Los operadores lógicos se usan para combinar condiciones.
Si queremos recuperar todos los libros cuyo autor sea igual a "Borges" y cuyo precio no supere los
20 pesos, necesitamos 2 condiciones:
select *from libros
where (autor='Borges') and
(precio<=20);
Los registros recuperados en una sentencia que une 2 condiciones con el operador "and", cumplen
con las 2 condiciones.
Queremos ver los libros cuyo autor sea "Borges" y/o cuya editorial sea "Planeta":
select *from libros
where autor='Borges' or
editorial='Planeta';
En la sentencia anterior usamos el operador "or"; indicamos que recupere los libros en los cuales el
valor del campo "autor" sea "Borges" y/o el valor del campo "editorial" sea "Planeta", es decir,
seleccionará los registros que cumplan con la primera condición, con la segunda condición o con
ambas condiciones.
Los registros recuperados con una sentencia que une 2 condiciones con el operador "or", cumplen
1 de las condiciones o ambas.
Queremos recuperar los libros que NO cumplan la condición dada, por ejemplo, aquellos cuya
editorial NO sea "Planeta":
select *from libros
where not editorial='Planeta';
El operador "not" invierte el resultado de la condición a la cual antecede.
Los registros recuperados en una sentencia en la cual aparece el operador "not", no cumplen con
la condición a la cual afecta el "NOT".
Los paréntesis se usan para encerrar condiciones, para que se evalúen como una sola expresión.
Cuando explicitamos varias condiciones con diferentes operadores lógicos (combinamos "and",
"or") permite establecer el orden de prioridad de la evaluación; además permite diferenciar las
expresiones más claramente.
Por ejemplo, las siguientes expresiones devuelven un resultado diferente:
select*from libros
where (autor='Borges') or
(editorial='Paidos' and precio<20);
select *from libros
where (autor='Borges' or editorial='Paidos') and
(precio<20);

51. Si bien los paréntesis no son obligatorios en todos los casos, se recomienda utilizarlos para evitar
confusiones.
El orden de prioridad de los operadores lógicos es el siguiente: "not" se aplica antes que "and" y
"and" antes que "or", si no se especifica un orden de evaluación mediante el uso de paréntesis.
El orden en el que se evalúan los operadores con igual nivel de precedencia es indefinido, por ello
se recomienda usar los paréntesis.
Entonces, para establecer más de una condición en un "where" es necesario emplear operadores
lógicos. "and" significa "y", indica que se cumplan ambas condiciones; "or" significa "y/o", indica
que se cumpla una u otra condición (o ambas); "not" significa "no", indica que no se cumpla la
condición especificada.
30 - Otros operadores relacionales (is null)
DETALLE DE CONCEPTO
Hemos aprendido los operadores relacionales "=" (igual), "<>" (distinto), ">" (mayor), "<" (menor),
">=" (mayor o igual) y "<=" (menor o igual). Dijimos que no eran los únicos.
Existen otro operador relacional "is null".
Se emplea el operador "is null" para recuperar los registros en los cuales esté almacenado el valor
"null" en un campo específico:
select *from libros
where editorial is null;
Para obtener los registros que no contiene "null", se puede emplear "is not null", esto mostrará los
registros con valores conocidos.
Siempre que sea posible, emplee condiciones de búsqueda positivas ("is null"), evite las negativas
("is not null") porque con ellas se evalúan todos los registros y esto hace más lenta la recuperación
de los datos.
31 - Otros operadores relacionales (between)
DETALLE DE CONCEPTO
Hemos visto los operadores relacionales: = (igual), <> (distinto), > (mayor), < (menor), >= (mayor o
igual), <= (menor o igual), is null/is not null (si un valor es NULL o no).
Otro operador relacional es "between", trabajan con intervalos de valores.
Hasta ahora, para recuperar de la tabla "libros" los libros con precio mayor o igual a 20 y menor o
igual a 40, usamos 2 condiciones unidas por el operador lógico "and":
select *from libros
where precio>=20 and
precio<=40;
Podemos usar "between" y así simplificar la consulta:
select *from libros
where precio between 20 and 40;
Averiguamos si el valor de un campo dado (precio) está entre los valores mínimo y máximo
especificados (20 y 40 respectivamente).
"between" significa "entre". Trabaja con intervalo de valores.
Este operador se puede emplear con tipos de datos numéricos y money (en tales casos incluyen
los valores mínimo y máximo) y tipos de datos fecha y hora (incluye sólo el valor mínimo).
No tiene en cuenta los valores "null".

52. Si agregamos el operador "not" antes de "between" el resultado se invierte, es decir, se recuperan
los registros que están fuera del intervalo especificado. Por ejemplo, recuperamos los libros cuyo
precio NO se encuentre entre 20 y 35, es decir, los menores a 15 y mayores a 25:
select *from libros
where precio not between 20 and 35;
Siempre que sea posible, emplee condiciones de búsqueda positivas ("between"), evite las
negativas ("not between") porque hace más lenta la recuperación de los datos.
Entonces, se puede usar el operador "between" para reducir las condiciones "where".
32 - Otros operadores relacionales (in)
DETALLE DE CONCEPTO
Se utiliza "in" para averiguar si el valor de un campo está incluido en una lista de valores
especificada.
En la siguiente sentencia usamos "in" para averiguar si el valor del campo autor está incluido en la
lista de valores especificada (en este caso, 2 cadenas).
Hasta ahora, para recuperar los libros cuyo autor sea 'Paenza' o 'Borges' usábamos 2 condiciones:
select *from libros
where autor='Borges' or autor='Paenza';
Podemos usar "in" y simplificar la consulta:
select *from libros
where autor in('Borges','Paenza');
Para recuperar los libros cuyo autor no sea 'Paenza' ni 'Borges' usábamos:
select *from libros
where autor<>'Borges' and
autor<>'Paenza';
También podemos usar "in" anteponiendo "not":
select *from libros
where autor not in ('Borges','Paenza');
Empleando "in" averiguamos si el valor del campo está incluido en la lista de valores especificada;
con "not" antecediendo la condición, invertimos el resultado, es decir, recuperamos los valores que
no se encuentran (coindicen) con la lista de valores.
Los valores "null" no se consideran.
Recuerde: siempre que sea posible, emplee condiciones de búsqueda positivas ("in"), evite las
negativas ("not in") porque con ellas se evalún todos los registros y esto hace más lenta la
recuperación de los datos.
33 - Búsqueda de patrones (like - not like)
DETALLE DE CONCEPTO
Existe un operador relacional que se usa para realizar comparaciones exclusivamente de cadenas,
"like" y "not like".
Hemos realizado consultas utilizando operadores relacionales para comparar cadenas. Por
ejemplo, sabemos recuperar los libros cuyo autor sea igual a la cadena "Borges":
select *from libros
where autor='Borges';

53. El operador igual ("=") nos permite comparar cadenas de caracteres, pero al realizar la
comparación, busca coincidencias de cadenas completas, realiza una búsqueda exacta.
Imaginemos que tenemos registrados estos 2 libros:
"El Aleph", "Borges";
"Antologia poetica", "J.L. Borges";
Si queremos recuperar todos los libros de "Borges" y especificamos la siguiente condición:
select *from libros
where autor='Borges';
sólo aparecerá el primer registro, ya que la cadena "Borges" no es igual a la cadena "J.L. Borges".
Esto sucede porque el operador "=" (igual), también el operador "<>" (distinto) comparan cadenas
de caracteres completas. Para comparar porciones de cadenas utilizamos los operadores "like" y
"not like".
Entonces, podemos comparar trozos de cadenas de caracteres para realizar consultas. Para
recuperar todos los registros cuyo autor contenga la cadena "Borges" debemos tipear:
select *from libros
where autor like "%Borges%";
El símbolo "%" (porcentaje) reemplaza cualquier cantidad de caracteres (incluyendo ningún
caracter). Es un caracter comodín. "like" y "not like" son operadores de comparación que señalan
igualdad o diferencia.
Para seleccionar todos los libros que comiencen con "M":
select *from libros
where titulo like 'M%';
Note que el símbolo "%" ya no está al comienzo, con esto indicamos que el título debe tener como
primera letra la "M" y luego, cualquier cantidad de caracteres.
Para seleccionar todos los libros que NO comiencen con "M":
select *from libros
where titulo not like 'M%';
Así como "%" reemplaza cualquier cantidad de caracteres, el guión bajo "_" reemplaza un caracter,
es otro caracter comodín. Por ejemplo, queremos ver los libros de "Lewis Carroll" pero no
recordamos si se escribe "Carroll" o "Carrolt", entonces tipeamos esta condición:
select *from libros
where autor like "%Carrol_";
Otro caracter comodín es [] reemplaza cualquier carácter contenido en el conjunto especificado
dentro de los corchetes.
Para seleccionar los libros cuya editorial comienza con las letras entre la "P" y la "S" usamos la
siguiente sintaxis:
select titulo,autor,editorial
from libros
where editorial like '[P-S]%';
Ejemplos:
... like '[a-cf-i]%': busca cadenas que comiencen con a,b,c,f,g,h o i;
... like '[-acfi]%': busca cadenas que comiencen con -,a,c,f o i;
... like 'A[_]9%': busca cadenas que comiencen con 'A_9';
... like 'A[nm]%': busca cadenas que comiencen con 'An' o 'Am'.
El cuarto caracter comodín es [^] reemplaza cualquier caracter NO presente en el conjunto
especificado dentro de los corchetes.
Para seleccionar los libros cuya editorial NO comienza con las letras "P" ni "N" tipeamos:
select titulo,autor,editorial
from libros