Visual Basic 6-Manual Completo

Visual Basic 6.0 y SQLServer 7.0

Introducción......................................................................................................................................31 Visual Basic versión 6.0................................................................................................................4

1.1 Entorno de Visual Basic.........................................................................................................41.1.1 Exploración del ambiente de V.B....................................................................................41.1.2 Barra de herramientas.....................................................................................................61.1.3 Herramienta de Objetos (ToolBox)..................................................................................71.1.4 Ventana de depuración (Debuger)..................................................................................71.1.5 Ventana de proyecto (Explorer Window).........................................................................81.1.6 Ventana de presentación de las Formas (Form Layout)..................................................81.1.7 Registro de componentes................................................................................................81.1.8 Registro de referencias ................................................................................................10

1.2 Conceptos Básicos: Variables, Identificadores, Constantes, Tipos de datos, Elección del tipo de variables..........................................................................................................................12

1.2.1 Declaración de Variables...............................................................................................121.2.2 Alcance y Tiempo de vida de las Variables...................................................................121.2.3 Tipos de datos................................................................................................................141.2.4 Constantes....................................................................................................................171.2.5 Etiquetas.......................................................................................................................18

1.3 Operadores...........................................................................................................................191.4 Estructuras de control .........................................................................................................281.5 Procedimientos Sub y Funciones ........................................................................................341.6 Procedimientos con argumentos opcionales.........................................................................371.7 Arrays: estáticos y dinámicos............................................................................................401.8 Funciones internas de VB ...................................................................................................421.9 Eventos, propiedades y Controles.......................................................................................481.10 Control de Errores .............................................................................................................591.11 Modelo de Objetos de Sistemas de Archivos (FSO)...........................................................641.12 Objetos del sistema de archivos: Drive, Folder y Files.......................................................721.13 Manejo de API's..................................................................................................................781.14 Interactuar con Word y Excel..............................................................................................791.15 Activar Animación en los procesos.....................................................................................83

2 Desarrollo de aplicaciones bajo el modelo C/S...........................................................................862.1 Modelo cliente / Servidor.......................................................................................................862.2 Que es ODBC.....................................................................................................................1032.3 Conexiones Cliente – Servidor............................................................................................1052.4 Establecimiento de conexiones cliente-servidor.................................................................1062.5 Estrategias de bloqueo.......................................................................................................107

3 SQL Server 7.0..........................................................................................................................1083.1 Permisos.............................................................................................................................1133.2 Utilizar las opciones de SQL Server...................................................................................114

3.2.1 Opciones SET..............................................................................................................1153.2.2 Opciones de base de datos..........................................................................................1183.2.3 Opciones de servidor....................................................................................................1203.2.4 Sugerencias.................................................................................................................1223.3.5 Opción del nivel de compatibilidad de la base de datos...............................................1233.3.6 Comportamiento cuando ARITHABORT y ARITHIGNORE están activadas................123

3.3 Implementación y el mantenimiento de bases de datos.....................................................1243.3.1 Componentes de una base de datos............................................................................1243.3.2 Archivos y grupos de archivos......................................................................................1253.3.2.2 Usar archivos y grupos de archivos...........................................................................1263.3.3.3 Usar archivos y grupos de archivos para administrar el crecimiento de las bases de datos.....................................................................................................................................1283.3.4 Grupos de archivos de sólo lectura..............................................................................1283.3.4 Registros de transacciones..........................................................................................1303.3.4.1 Operaciones no registradas......................................................................................1303.3.4.2 Archivos de registro virtuales....................................................................................131

Material de estudio Página: 1 de 249


3.4 Crear Bases de datos ....................................................................................................1433.5 Creación de Tablas.............................................................................................................151

3.5.1 Restricciones PRIMARY KEY......................................................................................1533.5.2 Restricciones FOREIGN KEY......................................................................................1543.5.3 Restricciones de no duplicados (UNIQUE)...................................................................1553.5.4 Restricciones CHECK..................................................................................................1563.5.5 Dfiniciones DEFAULT...................................................................................................157 3.5.6 Columnas de identificadores.......................................................................................1573.5.7 SET ANSI_NULLS (T-SQL)..........................................................................................1583.5.8 EJEMPLOS..................................................................................................................160

3.6 Elementos de sintaxis de Transact-SQL.............................................................................1661.5.1 Conversión de tipos de datos...........................................................................................166

1.5.2 Utilizar funciones.........................................................................................................1731.5.3 Programar tareas en Transac-SQL .............................................................................1741.5.4 Variables y parámetros.................................................................................................1751.5.5 Control de flujo.............................................................................................................1761.5.5.1 BEGIN…END............................................................................................................1761.5.5.2 GOTO........................................................................................................................1771.5.5.3 IF…ELSE..................................................................................................................1771.5.5.4 RETURN...................................................................................................................1781.5.5.5 CASE.........................................................................................................................180

1.6 Transacciones.....................................................................................................................1811.6.1 Controlar las transacciones..........................................................................................1811.6.2 Transacciones explícitas..............................................................................................1831.6.3 Transacciones de confirmación automática.................................................................184

1.7 Cursores.............................................................................................................................1851.7.1 Cursores de Transact-SQL...........................................................................................1861.7.2 Tipos de cursores.........................................................................................................1891.7.3 DECLARE CURSOR ..................................................................................................1901.7.4 Bloqueo de cursores.....................................................................................................1951.7.5 Obtener metadatos de cursores de servidor................................................................197

1.8 Procedimientos almacenados ............................................................................................1981.8.1 Programar procedimientos almacenados.........................................................................200

1.8.1.1 Devolver datos de un procedimiento almacenado.....................................................2051.8.1.2 Devolver datos mediante parámetros OUTPUT........................................................2051.8.2.2 Devolver datos mediante un código de retorno.........................................................2061.8.2.3 Ejecutar un procedimiento almacenado....................................................................208

1.9 Trigger (Desencadenadores)..............................................................................................2091.9.1 Type (Trigger) (SQL-DMO) (Propiedad).......................................................................2101.9.2 Desencadenadores anidados (recursive).....................................................................2101.9.3 CREATE TRIGGER (Creación de Disparadores).........................................................213

Anexos.........................................................................................................................................223I.1 SQL (Lenguaje Estructurado de Consultas “ Structured Query Language”)........................223I.2 Nomenclatura de Objetos....................................................................................................245I.3 Convenciones de nombres de variables para Visual Basic..................................................247



Introducción

Con la aparición de Windows 3.1, se incrementó sensiblemente la cantidad de usuarios adeptos a este ambiente operativo. Sin embargo, los usuarios de perfil técnico habían permanecido al margen de la utilización de dicho ambiente, por no contar con una herramienta para desarrollar sus aplicaciones.

Como una solución para ello, surgió en Microsoft: Visual Basic. El sistema de programación de Visual Basic, permite desarrollar aplicaciones útiles y atractivas, que utilizan y explotan completamente la interfase gráfica del usuario (GUI).

Visual Basic 6.0 hace más productivo el uso de Microsoft Windows, ya que provee de herramientas apropiadas para diferentes aspectos del desarrollo del GUI. Se puede crear la interfase gráfica con sólo dibujar objetos en una aplicación en el mismo modo gráfico, y definir las propiedades de esos objetos, así como manejar su comportamiento escribiendo código que responda a los eventos que ocurren en la interfase.

• Usando Visual Basic 6.0, se pueden crear poderosas aplicaciones que exploten las características claves de Microsoft Windows, tales como:

• Desarrollar aplicaciones sólo para ambientes de 32 bits.• MDI (Multiple-Document Interface) interfase de documentos múltiples.• La nueva tecnología de Microsoft llamada OLE (Object Linking & Embedding).• El DDE (Dynamic Data Exchange).• El manejo de Gráficos.• La posibilidad de extenderse añadiendo Custom Control y por llamada de procedimientos

en "Dynamic-Link Libraries" (DLLs).• La facilidad de poder generar un archivo ejecutable (.EXE), que use al tiempo de

ejecución DLLs que pueden ser libremente distribuidos.• Creación de controles personalizados Activex y clases.• Manejo de múltiples proyectos en forma simultánea.

Visual Basic es tan fácil de usar. El programa inicia con la pantalla elemental de Windows nombrada Forma por sus creadores, y se utiliza una caja de herramientas similar a la de los programas de dibujo, para añadir los controles: botones de comandos, textos, dibujos, entre otros elementos. Cada programa puede tener tantos controles como requiera el usuario. Controlar el tamaño y la posición de la Forma, es como hacer click con el mouse y arrastrar la ventana en cualquier lugar de la pantalla.



1 Visual Basic versión 6.0

1.1 Entorno de Visual Basic

1.1.1 Exploración del ambiente de V.B.

La versión de Visual Basic 6.0 está disponible en tres ediciones.

1. La edición de aprendizaje2. La edición profesional.3. La edición empresarial.

La diferencia básica entre las versiones, consiste en que se agregan herramientas (como: SourseSafe “control de versiones de aplicaciones”, Crystal Report “reporteador para VB”, entre otras) en cada versión, pero los ambientes de desarrollo son los mismos.

Con la nueva idea de mercado que ha implantado MicroSoft de incluir sus herramientas de desarrollo más populares en un paquete empresarial llamado Visual Studio 6.0 donde se incluyen las siguientes herramientas de desarrollo en 6 discos:

Visual C++

Visual FoxPro

Visual Basic

Visual J++

Viasual Interdev

MSDN (Microsoft Development Network)

Para instalar VB se utiliza el Disco 1, el cual instala Internet Explorer 5.0 y a continuación solicita se seleccione las herramientas de desarrollo deseadas.

Para instalara la ayuda MSDN se utilizan los discos 3 y 4, ejecutando del disco 3 el programa de instalación. En la instalación se solicita se seleccione las ayudas para las herramientas deseadas, si sólo se desea instalar la ayuda de VB se deberá elegir esta opción.



Al igual que otro lenguaje de programación, Visual Basic requiere una comprensión de alguna terminología común. La siguiente lista contiene algunos términos usados en Visual Basic.

Termino en Inglés

Termino en Español

Definición

Design Time Tiempo de Diseño

En cualquier momento cuando no se está ejecutando la aplicación.

Run Time Tiempo de Ejecución

Momento en que la aplicación se está ejecutando

Form Forma Ventana personalizable para incrustar objetos, desplegar diálogos

Control Control Representación gráfica de objetos (Botones, cajas de lista, etc) que el usuario manipula para proveer información de a la aplicación.

Object Objeto Término genérico usado para describir cualquier cosa en Visual Basic (Formas, controles, Activex, etc.)

Properties Propiedades Características de un objeto color, tamaño, nombre, etc.

Methodos Método Acción invocada que un objeto puede desarrollar

Events Evento Acción que desarrolla un objeto en forma automática provocada por el usuario al interactuar con la aplicación, sistema operativo o por la misma aplicación.

Event-Driven Programming

Programación orientada a eventos

Código que se ejecuta en respuesta a eventos invocados (usuario, sistema operativo o la aplicación). Esta difiere de la programación procedural donde el programa inicia en la primera línea de código y seguida por las rutas de ejecución de cada línea por el programa.



1.1.2 Barra de herramientas

La siguiente figura muestra el ambiente de desarrollo que se despliega en tiempo de diseño de una aplicación.


ToolBox

Ventana de depuración (Debugger)

Barra de herramientas(Toolbar)

Ventana de Propiedades

ExploradorDe proyecto

Ventana de Posición del formulario

Formulario

Código


La barra de herramientas (toolbar) contiene botones para muchas de los órdenes más comúnes usadas en VB, como para abrir la ventana del explorador del proyecto, el depurador, la presentación de formas, etc., así como otros elementos en el ambiente de desarrollo.

El Toolbar puede personalizarse para que contenga los botones que deseamos así como la posición donde se desplegarán.

Pulse el botón derecho en el Toolbar y seleccione la opción de personalizar: elija las opciones deseadas en cada una de las pestañas para que aparezcan en la barra de herramientas.

El ToolBar también puede ser desplazado en el área de la pantalla. Para realizar esta operación de click izquierdo y sin dejar de pulsarlo arraste el toolbar hasta la posición deseada. Lo mismo puede hacer para otros objetos del ambiente (ToolBox, Form Window, Property Window, etc.)

1.1.3 Herramienta de Objetos (ToolBox)

La caja de herramientas de controles (ToolBox) contiene los objetos y controles que pueden ser adicionados en las formas para crear las interfaces gráficas (GUI) de la aplicación. Se pueden adicionar controles al ToolBox por medio del comando Project\Components, situado en el menú del proyecto. Para invocar la caja de herramientas es a través del menú View\ToolBox o pulsando el siguiente icono:

1.1.4 Ventana de depuración (Debuger)

La ventana de depuración (Debuger) se usa para consultar o asignar datos (valores de objetos, variables, el objeto activo en una forma, etc.), ejecutar código. La forma de invocar la ventana de depuración (Inmediate Window) es a través del menú View \ Inmediate Window o pulsando CTRL-G.

La ventana de depuración sólo puede tener acción cuando se establece un punto de ruptura en el código que se está ejecutando; en tiempo de diseño no tiene efecto.

El alcance de la ventana de depuración está limitado al procedimiento actual donde ocurre el punto de evaluación. Para evaluar la siguiente línea del código presione F8, si la siguiente línea de código a evaluar es una llamada a un procedimiento o función presione Sifth-F8 si no desea seguir paso a paso el bloque de código del procedimiento o función.

La barra de herramientas asociada al debuger se muestra en la siguiente figura:

la siguiente tabla describe cada uno de los elementos de la figura.

Botón Descripción

Start Inicia la ejecución de la aplicación. Tecla rápida F5.

BreakDetiene temporalmente la ejecución del código.Presione Start o F5 para ejecutar la aplicación.Presione F8 para ejecutar la aplicación línea a línea.

End Finaliza la ejecución de la aplicación.

Toggle BreakpointEstablece/Elimina un punto de ruptura (el código se detiene en la línea que se establece) Tecla rápida F9.

Step Info Ejecuta paso a paso cada línea de código. Tecla rápida F8.

Step OverNo ejecuta paso a paso la siguiente línea de código si es una llamada a un procedimiento o función.

Local Window Despliega el valor actual de variables locales.



Inmediate Window Despliega la ventana del debuger.

Watch window Despliega el valor de la expresión.

Quick WatchDespliega el valor actual de la expresión en donde se encuentra el cursor. También este valor puede ser visualizado ubicando el cursor sobre la expresión y se desplegará el tooltip con el valor actual.

Call StackMuestra el diálogo con los procedimientos contenidos en la forma y pendientes de evaluar. La lista inicia con el activo.

1.1.5 Ventana de proyecto (Explorer Window)

La ventana de exploración del proyecto (Explorer Window) lista la colección de archivos usados en la aplicación. La colección de archivos (formas, módulos, clases) usados se llama proyecto. Se puede desplegar el código o la forma con los botones de “View Code” o “View Object”. Para invocar la forma de proyecto pulse View\Proyect Explorer o CTRL – R o el icono:

1.1.6 Ventana de presentación de las Formas (Form Layout)

Despliega visualmente la posición de como aparecerá la forma en la pantalla. La ventana contendrá un monitor el cual simula la pantalla, tome y arraste el icono de la ventana que aparece en la pantalla simulada, sitúelo en la posición que desea que aparezca en el momento de ejecutar la aplicación. Para desplegar la ventana correspondiente pulse:

1.1.7 Registro de componentes

Los controles ActiveX tienen la extensión de archivo.ocx. Puede usar los controles ActiveX suministrados con Visual Basic 6.0 o bien puede conseguir controles adicionales desarrollados por otros programadores.

Puede utilizar controles ActiveX y otros objetos insertables en el proyecto si los agrega al cuadro de herramientas.

Nota Los controles ActiveX de Visual Basic son controles de 32 bits. Algunos programadores ofrecen controles ActiveX de 16 bits, que no se pueden usar en la versión 6.0 de Visual Basic.

Para agregar un control al cuadro de herramientas de un proyecto:



1 En el menú Proyecto, haga clic en Componentes para mostrar el cuadro de diálogo Componentes, como se ve en la siguiente figura.

Figura 1.4 El cuadro de diálogo Componentes

Sugerencia También puede ver el cuadro de diálogo si hace clic con el botón secundario del mouse (ratón) en el cuadro de herramientas (toolbox).

2 Los elementos que se muestran en este cuadro de diálogo incluyen todos los objetos insertables, diseñadores y controles ActiveX registrados.

3 Para agregar un control ActiveX al cuadro de herramientas, active la casilla de verificación que hay a la izquierda del nombre del control.

4 Haga clic en Aceptar para cerrar el cuadro de diálogo Componentes. Todos los controles ActiveX que haya seleccionado aparecerán ahora en el cuadro de herramientas.

Para agregar controles ActiveX al cuadro de diálogo Componentes, haga clic en el botón Examinar y busque los archivos que tengan la extensión .ocx. Estos archivos suelen estar instalados en el directorio \Windows\System o System32. Al agregar un control ActiveX a la lista de controles disponibles, Visual Basic activa automáticamente su casilla de verificación en el cuadro de diálogo Componentes.



1.1.8 Registro de referencias

También puede utilizar objetos de otras aplicaciones, como los incluidos en la biblioteca de objetos de Microsoft Excel, ya sea como controles del cuadro de herramientas o como objetos programables en el código.

Para que los objetos de otra aplicación estén disponibles en el código, pero no como controles, defina una referencia a la biblioteca de objetos de esa aplicación.

Para agregar una referencia a la biblioteca de objetos de otra aplicación:

1. En el menú Proyecto, elija Referencias.

Aparecerá el cuadro de diálogo Referencias, como se muestra en la figura 1.4

2. Active la casilla de verificación correspondiente a la referencia que desea agregar al proyecto.

Para agregar referencias a aplicaciones no enumeradas en el cuadro de diálogo Referencias, elija el botón Examinar y seleccione la aplicación.

3. Elija Aceptar para agregar al proyecto las referencias seleccionadas.

Figura 1.4 El cuadro de diálogo Referencias

Si no va a usar ningún objeto de una biblioteca a la que se hace referencia, es conveniente desactivar la casilla de verificación de dicha referencia para reducir al mínimo posible el número de referencias a objetos que Visual Basic debe resolver, con lo que se reduce el tiempo de compilación del proyecto.



Una vez que ha definido las referencias a las bibliotecas de objetos que desea, puede buscar un objeto específico, junto con sus métodos y propiedades, en el Examinador de objetos; para ello, elija Examinador de objetos en el menú Ver. Puede utilizar en el código cualquier objeto enumerado en el Examinador de objetos.



1.2 Conceptos Básicos: Variables, Identificadores, Constantes, Tipos de datos, Elección del tipo de variables.

Visual Basic integra diferente tipos de datos, que permiten optimizar el código en velocidad y en tamaño. En este punto se ve su aplicación.

1.2.1 Declaración de Variables

Para declarar una variable se utiliza la sentencia Dim, dando un nombre a la variable.

Dim variablenombre [As type]

Reglas para determinar el nombre de una variable:• Necesita empezar con una letra• Necesita contener sólo caracteres, números y el carácter subrayado (_). Caracteres de puntuación y espacios, no son permitidos.• Necesita no exceder de 40 caracteres.• No puede ser una palabra reservada.

La cláusula opcional As type en la declaración Dim, permite definir el tipo de dato de la variable que se declara. Si ésta se omite, Visual Basic define el tipo de variable como Variant (variante).

Nota: Los estándares para nombres de variables y objetos se definen en los anexos de:

Convenciones de nombres de Variables para Visual Basic

Convenciones de nombres de Objetos para Visual Basic

1.2.2 Alcance y Tiempo de vida de las Variables

Cuando se declara una variable dentro de un procedimiento, solamente el código dentro del procedimiento puede tener acceso o cambiar el valor de esta variable. Esta tiene un alcance local para este procedimiento. Sin embargo, algunas veces se necesita usar una variable que tenga un alcance extenso, cuyo valor esté disponible para todos los procedimientos dentro de la misma Forma, Módulos de código o los eventos para todos los procedimientos en la aplicación. Visual Basic permite especificar el alcance de una variable, cuando ésta se declara.

Alcance de Variables

Dependiendo de cómo se declara, una variable es alcanzada en uno de los tres caminos:

Alcance Declaración

Local Dim, Static, o Redim (dentro de un procedimiento)

Módulo Dim (dentro de la sección Declarations de una Forma o módulo de código)

Global Global (dentro de la sección Declaratlons de un módulo)



Variables Locales

Una variable local, es reconocida sólo dentro del procedimiento en el cual aparece, y son declaradas con la declaración Dim. Las variables locales declaradas con Dim, existen sólo mientras el procedimiento es ejecutado

Variables de Módulo

Las variables definidas en la sección Declarations, son reconocidas en todos los procedimientos que forman parte de una Forma o, en su caso; en un módulo.

Variables Globales

Las variables globales tienen un alcance extenso. Los valores dentro de las variables globales, están disponibles para cada Forma y Módulo en la aplicación. A diferencia de las variables de módulo, las variables globales son declaradas dentro de la sección Declarations de un módulo. Para declarar variables globales, se utiliza la declaración Global en lugar de la declaración Dim.

Figura 1.5 Visibilidad de variables con diferentes alcances

Variables Estáticas

En adición al alcance, las variables tienen un tiempo de vida. El valor, en módulos y variables globales, es preservado por el tiempo de vida de la aplicación. Sin embargo, las variables locales declaradas con Dim, existen sólo mientras el procedimiento, en el cual fueron declaradas; es ejecutado. Normalmente, cuando un procedimiento finaliza su ejecución, el valor de estas variables locales no es preservado. La siguiente vez que el procedimiento es ejecutado, todas estas variables locales son reinicializadas.

Sin embargo, se puede hacer que Visual Basic conserve el valor de una variable local, declarando la variable como estática (static).



Por ejemplo, la siguiente función total, calcula un valor, añadiendo una nueva cantidad al total de previos valores almacenados en la variable estática acumula

Sub Command1_Click ( ) sumatotal = total(2) Print sumatotalEnd Sub

Function total (num) Static acumula acumula = acumula + num total = acumulaEnd Funetion

1.2.3 Tipos de datos

Cuando se declara una variable, se le puede asignar un tipo de dato. Por default, si no se asigna el tipo de dato a la variable, ésta obtiene un tipo de dato Variant (variante).

Tipo de dato Variant (variante).

El tipo de dato Variant, puede almacenar algunos tipos de datos como son: números, strings de textos ó de fecha y hora. Visual Basic desarolla automáticamente, cualquier conversión necesaria. Por ejemplo:

Dim ValorValor = "94"Valor = Valor+1900Valor = "México, D.F. a " & Valor

Las variables Variant, mantienen una representación interna del valor que ésta representa. Con esta representación interna Visual Basic determina cómo tratar estos valores. Si se quiere determinar la representación de una variable, se usa la función VarType. La siguiente tabla, lista el valor regresado de la variable VarType.

VarType Valores regresadosValor regresado Representación Interna0 Empty1 Null2 lnteger3 Long4 Single5 Double6 Currency7 Date/Time8 String

Ejemplo : lf VarType(Y) = 5 Then X = CSng(Y)



Generalmente, almacenar un string en una variable Variant, puede crear pocos problemas. Algunas veces, el resultado del operador + puede ser ambiguo cuando se usa con dos valores Variant. Si ambos valores contienen números, el operador + desarrolla una adición. Si ambos valores contienen un string, desarrolla una concatenación. Pero si uno de los valores representa un número y otro un string, la situación es más complicada. Visual Basíc, primero intenta convertir el string en un valor. Si la conversión es exitosa, entonces el operador + agrega el nuevo valor. De lo contrario, si no es exitosa; éste concatena el número con el string, para producir un nuevo string.

Cuando se quiera estar seguro de que ocurra una concatenación, se debe usar el operador &. Por ejemplo:

Dim ValorValor = "94"Valor = Valor+1900Valor = "México, D.F. a " & Valor

Los rangos de fechas almacenados en variables Variant, son desde Enero 1, 0000 a Diciembre 31, 9999. Se puede usar fecha/hora literalmente en el código, cerrando éstos con el signo (#). Por ejemplo :

lf fecha = #1/5/94 9:15am# then

Visual Basic acepta una variedad de formatos de fechas y horas en forma literal. Estos son todos los valores válidos de fecha/hora

Fecha = #2-5-94 15:30#Fecha = #March 2,1994 9:15am#Fecha = #Dec-31-94#Fecha = #31 December 1994#

Se puede usar la función lsdate para determinar si una variable Variant, puede ser considerada como valor de fecha/hora. También se puede usar la función CVDate, para convertir la variable a un valor de fecha/hora . Ejemplo

Sub Command1_Click ()Dim Fecha lf IsDate(Text1.Text) Then Fecha = CVDate(Text1.Text) MsgBox "Fecha correcta ' & Fecha, 48, "Fecha" Else MsgBox Text1.Text & "no es una fecha valida", 48, "Fecha" End lfEnd Sub

Algunas veces, se necesita saber si el valor de la variable ha sido asignado. Una variable Variant, tiene un valor vacío antes de que se le asigne un valor, ya sea un cero (0) o un string. Para probar si el valor es vacío, se utiliza la función IsEmpty.

lf IsEmpty(Valor) Then Valor = 100



El tipo de dato Variant, maneja todos los tipos fundamentales de datos y hace conversiones entre ellos automáticamente. Sin embargo, si se quiere crear un conciso y rápido código, se pueden usar otros tipos de datos apropiados. Por ejemplo, si una variable siempre contiene un pequeño valor, se puede salvar algunos bytes, incrementar la velocidad en el código cuando se desarrollan operaciones aritméticas, utilizando un Integer (entero) en lugar de una variable Variant.

En la siguiente tabla se muestra una lista de siete tipos de datos fundamentales.

Tipos de datos fundamentales de Visual Basic.Tamaño de

Tipo de dato Sufijo Almacenamiento Rango

Integer % 2 bytes -32,768 a 32,767.

Long(long integer) & 4 bytes -2,147,483,648 a 2,147,483,647.

Single ! 4 bytes -3.402823E38 a -1.401298E-45 paravalores negativos

(single-precision 1.401298E-45 a 3.402823E38 paravalues.floating-point) valores positivos

Double(double-precisionfloating-point) # 8 bytes -1.79769313486232E308 a

-4.94065645841247E-324 para valoresnegativos 4.94065645841247E-324 a1,79769313486232E308 para valorespositivos.

Currency(scaled integer) @ 8 bytes -922,337,203,685,477.5808 a

922,337,203,685,477.5807.

String $ 1 byte 0 aproximadamente a 65,500 bytes.

Variant None El apropiado Cualquier valor númerico, string o de fecha

Antes de usar una variable No-Variant, se debe usar la declaración Dim, Global o Static para declararla As tipodato. Por ejemplo, la siguiente declaración, declara un tipo lnteger, Double, String y Currency, respectivamente.

Dim Valor As lntegerDim Resta As DoubleStatic Regresa As StringGlobal Flag As CurrencyDim Nombre As String, Total As Currency



Tipos Numéricos

Si se sabe que una variable siempre almacena un valor entero, es mejor declararla como un tipo lnteger o Long. Las operaciones con enteros son más rápidas y consumen menos memoria que una de tipo Variant. Si una variable contiene una fracción, es mejor declararla como Single, Double, o Currency. El tipo de dato Currency, soporta hasta cuatro dígitos a la derecha del punto decimal y 15 hasta la derecha del punto decimal. Números de Punto-Flotante (Single y Double), tienen un rango más largo que el tipo Currency.

Tipos String

Si se tiene una variable que siempre contiene un string y nunca un valor numérico, es mejor declarada como un tipo String, además de poder manipular la variable con funciones de string.

Dim Curso As String

Curso = "Visual Basic"Curso = Left( Curso , 6 )

Para declarar el tamaño de un string se utiliza la sintaxis

String * tamaño

Por ejemplo, para declarar un string que siempre va a contener 45 caracteres

Dim Nombre As String * 45

También, para quitar los espacios en un string se utilizan las funciones Trim y Rtrim

Curso = "Visual Basic 6.0“Curso = Rtrim(Curso)

1.2.4 Constantes

Frecuentemente, se verán valores constantes en el código (éstos, aparecen una y otra vez) o se encontrará que el código depende de un cierto valor que es difícil de recordar.

En estos casos, se debe usar la declaración Const. Esta declaración, permite asignar una constante simbólica en lugar de un número

La sintaxis para la declaración Const, es la siguiente:

[Global] Const constnombre = expresión

Una declaración Const, puede representar una cantidad matemática o de fecha/hora:

Const Pl = 3.14159265Global Const Juegos = 2Const Fec-Ent = #2-5-94#Const Codigo = "Enigma"



1.2.5 Etiquetas

Una etiqueta de línea puede ser cualquier combinación de caracteres, pero debe iniciar con una letra y finalizar con dos puntos “:”. El nombre de la etiqueta no es sensitiva a minúsculas/ mayúsculas, esta debe estar en la primera columna. Es usada para identificar una línea en especial, su uso sólo se recomienda para el tratamiento de errores.

Ejemplo:Sub Ini_Mat (Var1, Var2, Var3, Var4)On Error GoTo ManejadordeError Código . . . Exit SubManejadordeError:

Resume NextEnd Sub



1.3 Operadores

En el siguiente punto se dará una idea de los operadores que se manejan en VB6 pero es importante verificar las comentarios que existen en cada uno de estos.

Operador: &Se utiliza para forzar la concatenación de las cadenas de dos expresiones.

Sintaxisresultado = expresión1 & expresión2

La sintaxis del operador & consta de las siguientes partes:

Parte DescripciónResultado Obligatorio; cualquier variable tipo String o Variant.Expresión 1 Obligatorio; cualquier expresión. Expresión 2 Obligatorio; cualquier expresión.

Comentarios

Si una expresión no es una cadena de caracteres, se convierte en un tipo String tipo variant. El tipo de dato del resultado es String si ambas expresiones son expresiones de cadena; de lo contrario, el resultado es una String tipo variant. Si ambas expresiones son Null, el resultado es también Null. Sin embargo, si sólo una expresión es Null, esa expresión se considera como una cadena de longitud cero ("") al concatenarse con la otra expresión. Cualquier expresión Empty se considera también una cadena de longitud cero.

Operador: *Se utiliza para multiplicar dos números.

Sintaxisresultado = número1*número2

La sintaxis del operador * consta de las siguientes partes:

Parte DescripciónResultado Obligatorio; cualquier variable numérica.Número 1 Obligatorio; cualquier expresión numérica. Número 2 Obligatorio; cualquier expresión numérica.

Comentarios

El tipo de dato del resultado es generalmente el de la expresión más exacta. El orden de precisión, de menos exacto a más exacto, es Byte, Integer, Long, Single, Double, Currency y Decimal.



Esta regla tiene las siguientes excepciones:Si Resultado es:

La multiplicación implica un tipo Single y un tipo Long. Se convierte a un tipo Double.

El tipo de dato de resultado es un tipo variant Long, Single o Date que se sale del intervalo válido.

Se convierte a un Variant que contiene un tipo Double

El tipo de dato de resultado es un Byte tipo variant que se sale del intervalo válido.

Se convierte a un Integer tipo variant

El tipo de dato de resultado es un Integer tipo variant que se sale del intervalo válido.

Se convierte a un Long tipo variant.

Si una o ambas de las expresiones son de tipo Null, el tipo de datos del resultado es Null. Si una expresión es del tipo Empty, se considera como 0.

Nota El orden de precisión utilizado por la suma y la resta no es igual que el orden de precisión utilizado por la multiplicación.

Operador: + Se utiliza para sumar dos números.

Sintaxisresultado = expresión 1 + expresión 2

La sintaxis del operador + consta de las siguientes partes:

Parte DescripciónResultado Obligatorio; cualquier variable numérica.Expresión1 Obligatorio; cualquier expresión. Expresión2 Obligatorio; cualquier expresión.

Comentarios

Cuando utilice el operador + , quizá no pueda determinar si se va a realizar una suma o una concatenación de cadenas. Utilice el operador & para la concatenación, de modo que se eviten ambigüedades y se suministren programas claros y explícitos.

Si hay al menos una expresión que no sea de tipo Variant, se aplican las siguientes reglas:Si EntoncesAmbas expresiones son tipos de datos numéricos (Byte, Boolean, Integer, Long, Single, Double, Date, Currency o Decimal)

Suma.

Ambas expresiones son del tipo String Concatenación.Una expresión es de un tipo de datos numérico y la otra cualquier tipo Variant excepto Null

Suma.

Una expresión es del tipo String y la otra cualquier tipo Variant excepto Null

Concatenación.

Una expresión es del tipo Empty Variant Devuelve sin modificacio-nes la expresión restante como resultado.

Una expresión es de un tipo de datos numérico y la otra de tipo String

Puede ocurrir un Error de tipos.

Cualquiera de las expresiones es Null resultado es Null.Si ambas expresiones son del tipo Variant, se aplican las siguiente reglas:



Si EntoncesAmbas expresiones tipo Variant son numéricas Suma.Ambas expresiones tipo Variant son cadenas de caracteres Concatenación.Una expresión tipo Variant es numérica y la otra es una cadena de caracteres

Suma.

En adiciones aritméticas simples de expresiones de tipos de datos numéricos únicamente, el tipo de dato de resultado es habitualmente el mismo que el de la expresión con mayor precisión. El orden de precisión, de menos exacto a más exacto, es Byte, Integer, Long, Single, Double, Currency y Decimal.

Esta regla tiene las siguientes excepciones:Si result esSe suman un tipo Single y un tipo Long, un tipo Double.El tipo de dato de resultado es Long, Single o Date tipo variant que desborda su intervalo válido,

se convierte a un Double tipo variant.

El tipo de dato de resultado es un Byte tipo variant que se sale del intervalo válido,

se convierte a un Integer tipo variant.

El tipo de dato de resultado es un Integer tipo variant que se sale del intervalo válido,

se convierte a un Long tipo variant.

Un Date se agrega a cualquier tipo de dato, un tipo Date.

Si una de las expresiones o ambas son expresiones de tipo Null, resultado es Null. Si ambas expresiones son Empty, el resultado es Integer. Sin embargo, sólo una de las expresiones es Empty, se devuelve la otra sin modificaciones como resultado.


Operador: - Se utiliza para hallar la diferencia entre dos números o para indicar el valor negativo de una expresión numérica.

Sintaxis 1

resultado = número1-número2

Sintaxis 2–número

La sintaxis del operador – consta de las siguientes partes:

Parte DescripciónResultado Obligatorio; cualquier variable numérica.Número Obligatorio; cualquier expresión numérica. Número 1 Obligatorio; cualquier expresión numérica. Número 2 Obligatorio; cualquier expresión numérica.

Comentarios



En la sintaxis 1, – es el operador de substracción aritmética utilizado para hallar la diferencia entre dos números. En la sintaxis 2, – se utiliza como el operador de negación unaria para indicar el valor negativo de una expresión.

El tipo de dato de resultado es generalmente el de la expresión más exacta. El orden de precisión, de menos exacto a más exacto, es Byte, Integer, Long, Single, Double, Currency y Decimal. Este orden tiene las siguientes excepciones:

Si result esEs una substracción de un tipo Single y un tipo Long, se convierte a tipo

Double.El tipo de dato de resultado es un tipo variant Long, Single o Date que se sale del intervalo válido,

se convierte a un Variant que contiene un tipo Double.

El tipo de dato de resultado es un Byte tipo variant que se sale del intervalo válido,

se convierte a un Integer tipo variant.

El tipo de dato de resultado es un Integer tipo variant que se sale del intervalo válido,

se convierte a un Long tipo variant.

La substracción implica a un tipo Date y cualquier otro tipo de dato, es un tipo Date.

La substracción implica dos expresiones tipo Date, es un tipo Double.

Si una o ambas de las expresiones son de tipo Null, el tipo de datos del resultado es Null. Si una expresión es del tipo Empty, se considera como si fuera 0.




Operador: /

Se utiliza para dividir dos números y obtener un resultado de signo flotante.

Sintaxis

resultado = número 1 / número 2

La sintaxis del operador / consta de las siguientes partes:


Comentarios

El tipo de dato de resultado es normalmente un Double tipo variant o un tipo Double. Esta regla tiene las siguientes excepciones:

Si Resultado esAmbas expresiones son expresiones de tipo Byte, Integer o Single,

Un tipo Single a menos que salga de su intervalo válido, en cuyo caso se produce un error.

Ambas expresiones son Byte, Integer o Single tipo variant,

Un tipo Single a menos que salga de su intervalo válido; en este caso resultado es un tipo Variant que contiene un tipo Double.

La división contiene un tipo Decimal y cualquier otro tipo de dato,

Un tipo Decimal.

Si una o ambas de las expresiones son de tipo Null, el tipo de datos del resultado es Null. Si una expresión es del tipo Empty, se considera 0

Operador: \

Se utiliza para dividir dos números y obtener un resultado entero.

Sintaxis

resultado = número 1 \ número 2

La sintaxis del operador \ consta de las siguientes partes:




Comentarios

Antes de efectuar la división se redondean las expresiones numéricas para convertirlas en expresiones tipo Byte, Integer o Long.

Normalmente, el tipo de dato del resultado es tipo Byte, Byte tipo variant, tipo Integer o Integer tipo variant, tipo Long o Long tipo variant, independientemente de si el resultado es un número entero o no. La parte fraccionaria se trunca. Sin embargo, si cualquiera de las expresiones es Null, resultado es Null. Toda expresión que sea Empty se considera como 0.

Operador: ^

Se utiliza para elevar un número a la potencia del exponente.

Sintaxisresultado = número ^ exponente

La sintaxis del operador ^ consta de las siguientes partes:

Parte DescripciónResultado Obligatorio; cualquier variable numérica.Número Obligatorio; cualquier expresión numérica. Exponente Obligatorio; cualquier expresión numérica.

Comentarios

Un número puede ser negativo sólo si exponente es un entero. Cuando se efectúa más de una exponenciación en una única expresión, el operador ^ se resuelve en el orden en que esté, de izquierda a derecha.

Generalmente, el tipo de dato del resultado es un Double o un Variant que contiene un Double. Sin embargo, si número o exponente es una expresión Null resultado es también Null.



Operadores de comparación.

Se utilizan para comparar expresiones.

Sintaxis

resultado = expresión1 operadorcomparación expresión2resultado = objeto1 Is objeto2resultado = cadena Like patrón

Los operadores de comparación constan de las siguientes partes:

Parte DescripciónResultado Obligatorio; cualquier variable numérica.Expresión Obligatorio; cualquier expresión.Operador de comparación Obligatorio; cualquier operador de comparación.Objeto Obligatorio; cualquier nombre de objeto.Cadena Obligatorio; cualquier expresión de cadena.Patrón Obligatorio; cualquier expresión de cadena o intervalo de

caracteres.

Comentarios

Esta tabla contiene una lista de los operadores de comparación y de las condiciones que determinan si el resultado es True, False o Null:

OPERADOR TRUE SI FALSE SI NULL SI< (Menor que) expresión1 < expresión2 expresión1 >= expresión2 expresión1 ó

expresión2 = Null<= (Menor o igual que)

expresión1 <= expresión2 expresión1 > expresión2 expresión1 ó expresión2 = Null

> (Mayor que) expresión1 > expresión2 expresión1 <= expresión2 expresión1 ó expresión2 = Null

>= (Mayor o igual que)

expresión1 >= expresión2 expresión1 < expresión2 expresión1 ó expresión2 = Null

= (Igual a) expresión1 = expresión2 expresión1 <> expresión2 expresión1 ó expresión2 = Null

<> (Distinto de) expresión1 <> expresión2 expresión1 = expresión2 expresión1 ó expresión2 = Null

Nota Los operadores Is y Like tienen funciones de comparación específicas que difieren de las de los operadores incluidos en la siguiente tabla.

Cuando se comparan dos expresiones, puede ser difícil determinar si éstas se comparan como números o como cadenas de caracteres. En la siguiente tabla se muestra el modo en que se comparan expresiones y cuál es el resultado cuando cualquiera de las expresiones no es del tipo Variant:



Si EntoncesAmbas expresiones son de tipos de datos numéricos (Byte, Boolean, Integer, Long, Single, Double, Date, Currency o Decimal)

Se efectúa una comparación numérica.

Ambas expresiones son de tipo String Se efectúa una comparación de cadenas.Una expresión es de tipo de datos numérico y la otra es un tipo Variant que es, o puede ser, un número


Una expresión es de tipo de datos numérico y la otra es un tipo Variant de cadena de caracteres que no se puede convertir en un número

Provoca un error de Error de tipos.

Una expresión es de tipo String y la otra es cualquier tipo Variant, con excepción de Null

Se efectúa una comparación de cadenas.

Una expresión es Empty y la otra es del tipo de datos numérico

Se efectúa una comparación numérica, usando 0 como la expresión Empty.

Una expresión es Empty y la otra es del tipo String

Se efectúa una comparación de cadenas, utilizando una cadena de caracteres de longitud cero ("") como la expresión Empty.

Si tanto expresión1 como expresión2 son del tipo Variant, el tipo subyacente de las mismas es el que determina la manera en que se comparan. En la siguiente tabla se muestra el modo en que se comparan las expresiones y cuál es el resultado de la operación de acuerdo con el tipo subyacente de Variant:

Si EntoncesAmbas expresiones tipo Variant son numéricas


Ambas expresiones tipo Variant son cadenas de caracteres

Se efectúa una comparación de cadenas.

Una expresión tipo Variant es numérica y la otra es una cadena de caracteres

La expresión numérica es menor que la expresión de cadena.

Una expresión tipo Variant es Empty y la otra es numérica

Se efectúa una comparación numérica, usando 0 como la expresión Empty.

Una expresión tipo Variant es Empty y la otra es una cadena de caracteres

Se efectúa una comparación de cadenas, utilizando una cadena de caracteres de longitud cero ("") como la expresión Empty.

Ambas expresiones tipo Variant son Empty Las expresiones son iguales.

Cuando se compara un tipo Single con un tipo Double, éste se redondea al grado de precisión del tipo Single.

Si una expresión tipo Currency se compara con una de tipo Single o Double, ésta se convierte al tipo Currency. De igual forma, cuando un tipo Decimal se compara con un tipo Single o Double, el tipo Single o el Double se convierten a tipo Decimal. Para el tipo Currency, cualquier valor fraccionario menor que 0,0001 se pierde; para el tipo Decimal, cualquier valor fraccionario menor que 1E-28 se pierde y puede ocurrir un error de desbordamiento. Perder valores fraccionarios puede hacer que dos valores se comparen como iguales cuando en realidad no lo son.



Prioridad de Operadores

Cuando hay varias operaciones en una misma expresión, cada parte de la misma se evalúa y se resuelve en un orden predeterminado según la prioridad de los operadores.

Cuando hay expresiones que contienen operadores de más de una categoría, se resuelven antes las que tienen operadores aritméticos, a continuación las que tienen operadores de comparación y por último las de operadores lógicos. Los operadores de comparación tienen todos la misma prioridad; es decir, se evalúan de izquierda a derecha, en el orden en que aparecen. Los operadores lógicos y aritméticos se evalúan en el siguiente orden de prioridad:

Aritméticos Comparación LógicosExponenciación (^) Igualdad (=) NotNegación (–) Desigualdad (<>) AndMultiplicación y división (*, /) Menor que (<) OrDivisión de enteros (\) Mayor que (>) XorMódulo aritmético (Mod) Menor o igual que (<=) EqvAdición y substracción (+, –) Mayor o igual que (>=) ImpConcatenación de cadenas (&) Like

Is

Cuando hay multiplicación y división en la misma expresión, cada operación se evalúa a medida que aparece, de izquierda a derecha. Del mismo modo, cuando se presentan adiciones y substracciones en una misma expresión, cada operación se evalúa tal como aparecen de izquierda a derecha. Es posible usar paréntesis para saltar el orden de preferencia y forzar que algunas partes de una expresión se evalúen antes que otras. Las operaciones entre paréntesis se realizan antes que las de fuera. Sin embargo, dentro de los paréntesis, la precedencia de los operadores se mantiene.

El operador de concatenación de cadenas (&) no es realmente un operador aritmético, pero en orden de prioridad se encuentra a continuación de todos los operadores aritméticos y antes que todos los operadores de comparación.

El operador Like, a pesar de tener la misma prioridad que los operadores de comparación, es en realidad un operador de coincidencia de patrones.

El operador Is es un operador de comparación de referencia de objetos. No compara objetos ni valores de objetos; sólo determina si dos referencias de objeto se refieren al mismo objeto.



1.4 Estructuras de control

Las declaraciones que controlan las decisiones y los loops en Visual Basic, son llamadas estructuras de control. Las estructuras de control de Visual Basic, son similares a los controles encontrados en C y Pascal. Las estructuras de control más usadas en Visual Basic son las siguientes:

• lf-Then blocks• lf-Then-Else blocks• IIf(expresión, parte verdadera, parte falsa)• Select Case declaraciones• Do loops• For loops

Estructuras de Decisión

En Visual Basic, los procedimientos pueden contener una condición de prueba, y ésta, depender del resultado de la prueba para desarrollar diferentes acciones. Las estructuras de decisión que Visual Basic soporta, incluyen:

• lf... Then• lf... Then ... Else• IIf(expresión, parte verdadera, parte falsa)• Select Case

lf ... Then

Usar lf ... Then para ejecutar una o más declaraciones condicionalmente. Se puede usar una línea sencilla ó múltiple. La sintaxis es la siguiente:

lf condición Then declaración

lf condición Then declaraciónEnd lf

Ejemplo:

lf algunvalor > 8 Then Bandera = True

lf algunvalor > 8 ThenBandera = True

End lf



lf ... Then ... Else

Usar lf ... Then ... Else para definir varios bloques de declaraciones, una de las cuales; se ejecuta. La sintaxis es la siguiente

lf condición1 Then declaración1[Elself condicion2 Then [declaración 2]]...[Else

[declaración n ]]End lf

Ejemplo:

Sub Form Dim X,Y ' Declaración de variables. X = lnputBox("Teclear un número mayor que 0 y menor que 1000,") lf X < 10 Then Y = 1 ' 1 digito, Elself X < 100 Then Y=2 '2digitos. Else Y = 3 ' 3 digitos. End lf lf Y > 1 Then Unit = “digitos." Else Unit = “digito.” MsgBox "El número que tu tecleaste tiene ” & Y & UnitEnd Sub

IIf (expresión, parte verdadera, parte falsa)

Evalúa una expresión y retorna un valor. IIf siempre evalúa la parte verdadera y la parte falsa. Por esta razón, deberá vigilar que no se produzcan efectos no deseados.

Ejemplo:Mivar = IIF(A > 8 , “A es mayor”, “A es menor”)



Select Case

Usar Select Case para seleccionar una o más declaraciones condicionalmente. Es similar al lf ... Then ... Else, pero Select Case hace al código más eficiente La sintaxis es la siguiente

Select Case expresionprueba[Case listaexpresión1]

[declaración l]][Case listaexpresión2)

[declaración 2]][Case Else

[declaración n]]End Select Ejemplo

Sub mnuBackColorItem_Click (index As lnteger) Select Case lndex Case0 'Coloca la propiedad BackColor a Rojo txtEdit.BackColor = RGB(255, 0, 0) Case 1 'Coloca la propiedad BackColor a Verde txtEdit.BackColor = RGB(0, 255, 0) Case 2 ' Coloca la propiedad BackColor a Azul txtEdit.BackColor = RGB(0, 0, 255)End Select



Estructuras Continuas

Las estructuras continuas permiten ejecutar más de una línea de código repetitivamente. Las estructuras continuas que Visual Basic soporta, incluyen:

• Do... Loop• For... Next

Do ... Loop

Se utiliza Do ... Loop para ejecutar un bloque de declaraciones, en un número infinito de veces. Cada vez que se ejecuta la declaración, es evaluada, permitiendo determinar la continuación de la misma. Como con lf .... Then, la condición debe ser un valor o una expresión que evalúe si es verdadero (True) ó falso (False).

En el siguiente Do .... Loop, la declaración es ejecutada mientras la condición es verdadera (True):

Do While condición declaracionesLoop

Ejemplo:

Sub Command1_Click ( )

Dim Respuesta ' Declaración de variable

Do While Respuesta = 0 Or Respuesta > 9 Respuesta = lnputBox("Teclear un número mayor que 1 y menor que 9.") Loop

End Sub

Variación del Ejemplo anterior:

Sub Command1_Click ( )

Dim Respuesta 'Declaración de la variable Do Respuesta Respuesta = InputBox("Teclear un número mayor que 1 y menor que 9.") lf Respuesta > 1 And Respuesta < 9 Then Checa el rango. Exit Do ' Exit Do Loop End If Loop

End Sub



Otra variación del Do ... Loops, es cuando la condición es evaluada al final de cada ejecución. Esta variación garantiza al menos, una ejecución de las declaraciones.

Do declaraciónLoop While condición

Las siguientes declaraciones son análogas a las dos anteriores:

Do Until condición Do declaración declaraciónLoop Loop Until condición

For ... Next

Do ... Loop trabaja muy bien, cuando no se sabe cuántas veces se necesita ejecutar declaraciones en el Loop, Sin embargo, se necesita ejecutar un número de veces específico, es más eficiente usar un loop For ... Next. A diferencia de un Do ... Loop, un loop For ... Next usa un contador que incrementa o decrementa un valor, durante cada repetición del loop

La sintaxis es la siguiente

For contador = principio To Final [Step incremento] declaracionesNext [contador]

Nota : el argumento "incremento", puede ser negativo o positivo

Ejemplo:

Sub Command1_Ciick ( ) Dim I, Msg, NL, Rep

NL = Chr(13) & Chr(10) For Rep = 5 To 1 Step -1 For I = Asc("A") To Asc("Z") Msg = Msg & Chr(I) Next I Msg = Msg & NL NextRep MsgBox Msg

End Sub



Salir de una Estructura de Control

La declaración Exit, permite salir directamente desde un For...Loop, Do ... Loop, procedimiento Sub o un procedimiento Function. Sintácticamente, la declaración Exit es simple: Exit For puede aparecer tantas veces como sea necesario dentro de un For...Loop, y un Exit Do puede aparecer tantas veces como sea necesario dentro de un Do...Loop.:

For contador = principio To Final [Step ¡ncremento) [declaraciones] [Exit Forl [declaraciones]Next [contador, [contador] [,....]]

Do [{While Until }] condicion] [declaraciones] [Exít do] [declaraciones]Loop

Ejemplo

Sub Form_Click()

Dim I, Num 'Declaración de variables, Do 'loop infinito

For I = 1 To 1000 Num = Int(Rnd * 100) 'Genera un número random Select Case Num ‘Evalua el número random Case 7 : Exit For ‘Si 7, exit For...Next. Case 29: Exit Do ‘Si 29, exit Do...Loop Case 54 : Exit Sub ‘Si 54, exit Sub procedure. End Select Nexi I LoopEnd Sub

Ejemplo: salida en una función.

Function SquareRoot (X As Double) As Double Select Case Sgn(X) 'Evalua el signo del argumento. Case 1 'OK si es positivo. SquareRoot = Sqr(X) Exit Function Case 0 ' Notify user if 0 SquareRoot = 0 Case -1 ' Notifica al usuario si es negativo. SquareRoot = -1 End SelectEnd Function



1.5 Procedimientos Sub y Funciones

Un evento (event), es una acción reconocida por una Forma ó Control. Las aplicaciones Event-Driven, ejecutan un código en respuesta a un evento. Cada Forma y Control, en Visual Basic; tiene un conjunto de eventos predefinidos. Si uno de estos eventos ocurre, Visual Basic invoca el código asociado con el procedimiento del evento (event procedure). Cuando se quiera que una Forma ó Control responda a un evento,se debe escribir un código llamado event procedure.

Por ejemplo, un evento click ocurre cuando un usuario hace click en un objeto. Si un usuario hace click en un command button nombrado Command1, el procedimiento del evento Command1_Click es ejecutado.

Módulos

Los módulos son muy útiles, ya que ellos permiten llamar procedimientos que sean comunes, entre más de una Forma o Control. Esto permite reducir líneas de código de programación y evita duplicar el código. Además, esto puede permitir la construcción de librerías de Módulos de código, que son muy útiles.

Cada módulo puede contener:

• Declaraciones. Se pueden poner constantes, tipos, variables y declaraciones de procedimientos DLL.

• Event procedures. Son procedimientos Sub, que responden a los eventos de los controles.

• Procedimientos Generales. Todos los procedimientos en un módulo, son procedimientos generales; y en una aplicación, pueden ser llamados desde el código. Los procedimientos generales también pueden ser procedimientos Sub o Function.



Procedimientos

Los procedimientos pueden ser Sub o Function. Un procedimiento Sub no puede retornar un valor, así que un procedimiento Sub es una completa declaración.

Un procedimiento Function puede retornar un valor, así entonces, es parte de una expresión.

Nota: Los eventos de procedimiento son siempre procedimientos Sub, nunca procedimientos Function.

Procedimientos Sub

La sintaxis para el procedimiento Sub es:

Sub nombreprocedimiento (arglist)declaraciones

End Sub

El arglist es una lista de nombres de argumentos, separados por comas (,) si hay más de uno. La sintaxis de un argumento es:

[ByVal] nombrevariable [( )] [As tipo]

Ejemplo

Sub File1_MouseDown (Button As lnteger, Shift As lnteger, X As Single, Y As Single) file1.DragIcon = Drive1.DragIcon fiie1.DragEnd Sub

Cada vez que el procedimiento es llamado, la declaración entre Sub y End Sub es ejecutada. Visual Basic sustituye cada referencia, a una partida en la lista de los argumentos, con el correspondiente argumento. Cuando se llama a un procedimiento general, se necesita pasar el valor para cada argumento. Por ejemplo, si se necesita mover una imagen a la izquierda

Sub Muevelmagen (Mover) lmagen1.Move lmagen1+Mover,imagen1,TopEnd Sub

La declaración anterior necesita ser llamada con un argumento. Ejemplo:

Muevelmagen 50

El procedimiento sustituye 50 por Mover (éste aparece en la lista de argumentos)



Function

La sintaxis para el procedimiento Fuction es;

Function nombreprocedimiento (argumentos) [As tipo]declaraciones

End Function

Los argumentos en procedimiento Function, trabajan exactamente igual que en los procedimientos Sub.

Diferencias del procedimiento Function:

• Siempre se usan paréntesis con cada llamada de función.• El procedimiento Function tiene tipos de datos, como las variables.• Se puede retornar un valor, asignándolo al nombre del procedimiento.

Por ejemplo, se puede escribir esta función para calcular el IVA de una cantidad:

Function CalcIva (Monto) CalcIva = Monto *.1End Function

Se puede llamar la función de la siguiente manera: X = Calclva(5000)

Mecanismos de comentarios, números y declaraciones.

En Visual Basic, el símbolo ( ‘ ), se utiliza para las líneas de comentario. Ejemplo:

'Este texto es asignado al control Text1lText1.Text = "Curso de Visual Basic 3.0" 'Aparece en la caja del texto.

Algunos números se usan para asignar valores a las propiedades de algunos controles. Éstos pueden ser en base 10 (decimal), base 16 (hexadecimal) que en Visual Basic se representa con un prefijo &H ó base 8 (octal) que se representa con un prefijo &O.

En Visual Basic, las declaraciones son normalmente una por línea. Sin embargo. se puede poner más de una declaración en una línea, utilizando los dos puntos ( : ), como separador. Ejemplo

Text1.Text = " Curso de Visual Basic " : Fuente=16 : Text1.FontSize= Fuente

Reglas de nombres en Visual Basic

El nombre de procedimientos, variables y constantes, debe seguir la siguiente regla:

• Comenzar con una letra• Debe contener sólo letras y números. Los signos de puntuación y los espacios, no son permitidos.• No puede ser más largo de 40 caracteres,• No usar los nombres de las palabras reservadas para el lenguaje de Visual Basic.



1.6 Procedimientos con argumentos opcionales.

Normalmente el código de un procedimiento necesita cierta información sobre el estado del programa para realizar su trabajo. Esta información consiste en variables que se pasan al procedimiento cuando se le llama. Cuando se pasa una variable a un procedimiento, se llama argumento.

Tipos de datos de los argumentos

Los argumentos de los procedimientos tienen el tipo de dato Variant de forma predeterminada. Sin embargo, puede declarar otros tipos de datos para los argumentos. Por ejemplo, la función siguiente acepta una cadena y un entero:

Function QuéComer (DíaSemana As String, Hora _As Integer) As String

' Devuelve el menú del almuerzo basándose en el día y la hora.If DíaSemana = "Viernes" then

QuéComer = "Pescado"Else

QuéComer = "Pollo"End IfIf Hora > 4 Then QuéComer = "Demasiado tarde"

End Function

Paso de argumentos por valor

Sólo se pasa una copia de la variable cuando se pasa un argumento por valor. Si el procedimiento cambia el valor, el cambio afecta sólo a la copia y no a la variable propiamente dicha. Utilice la palabra clave ByVal para indicar un argumento pasado por valor. Por ejemplo:

Sub Cuentas (ByVal intNumCuenta as Integer)

. ' Ponga aquí sus instrucciones.

End Sub

Paso de argumentos por referencia

Al pasar argumentos por referencia se permite al procedimiento el acceso al contenido real de la variable en su ubicación de dirección de memoria. Como resultado, el procedimiento al que se ha pasado el valor de la variable se puede modificar de forma permanente. La forma predeterminada de pasar valores en Visual Basic es por referencia.

Si especifica el tipo de dato de un argumento que se pasa por referencia, debe pasar un valor de ese tipo para el argumento. Puede eludirlo si pasa una expresión en vez de un tipo de dato como argumento. Visual Basic evalúa la expresión y la pasa como el tipo requerido si puede.

La forma más sencilla de convertir una variable en una expresión es ponerla entre paréntesis. Por ejemplo, para pasar una variable declarada como entero a un procedimiento que espera una cadena como argumento, debería hacer lo siguiente:

Sub ProcedimientoQueLlama ()Dim intX As IntegerintX = 12 * 3



Foo(intX)End Sub

Sub Foo(Bar As String)MsgBox Bar 'El valor de Bar es la cadena "36".

End Sub

Uso de argumentos opcionales

Puede especificar argumentos a un procedimiento como opcionales si coloca la palabra clave Optional en la lista de argumentos. Si especifica un argumento opcional, todos los argumentos subsiguientes de la lista de argumentos deben ser también opcionales y se deben declarar con la palabra clave Optional. Los dos fragmentos de código de ejemplo que se muestran a continuación suponen que hay un formulario con un botón de comando y un cuadro de lista.

Por ejemplo, este código proporciona todos los argumentos como opcionales:

Dim strNombre As StringDim varDirección As Variant

Sub ListText(Optional x As String, Optional y _As Variant)

List1.AddItem xList1.AddItem y

End Sub

Private Sub Command1_Click()strNombre = "sunombre"varDirección = 12345 ' Se proporcionan ambos argumentos.Call ListText(strNombre, varDirección)

End Sub

Sin embargo, este código no proporciona todos los argumentos como opcionales:

Dim strNombre As StringDim varDirección As Variant

Sub ListText(x As String, Optional y As Variant)List1.AddItem xIf Not IsMissing(y) Then

List1.AddItem yEnd If

End Sub

Private Sub Command1_Click() strNombre = "sunombre" 'No se proporciona el segundo argumento. Call ListText(strNombre)End Sub

En caso de que no se proporcione un argumento opcional, se asigna el argumento como un tipo Variant con el valor Empty. El ejemplo anterior muestra cómo probar si se han perdido argumentos opcionales mediante la función IsMissing.



Proporcionar un valor predeterminado a un argumento opcional

También es posible especificar un valor predeterminado para un argumento opcional. El siguiente ejemplo devuelve un valor predeterminado si no se pasa el argumento opcional al procedimiento Function:

Sub ListText(x As String, Optional y As _Variant = 12345)

List1.AddItem xList1.AddItem y

End Sub

Private Sub Command1_Click()strNombre = "sunombre" ' No se proporciona el segundo

' argumento.Call ListText(strNombre) ' Agrega "sunombre" y "12345".

End Sub

Uso de un número indefinido de argumentos

Generalmente, el número de argumentos en la llamada a un procedimiento debe ser el mismo que los especificados en el procedimiento. Utilizar la palabra clave ParamArray le permite especificar que el procedimiento aceptará un número arbitrario de argumentos. Eso le permite escribir funciones como Sum:

Dim x As VariantDim y As IntegerDim intSum As Integer

Sub Sum(ParamArray intNums())For Each x In intNums

y = y + xNext xintSum = y

End Sub

Private Sub Command1_Click()Sum 1, 3, 5, 7, 8List1.AddItem intSum

End Sub

Creación de instrucciones más sencillas mediante argumentos con nombre

En muchas funciones, instrucciones y métodos incorporados, Visual Basic proporciona la opción de utilizar argumentos con nombre como método abreviado para escribir valores de argumentos. Con los argumentos con nombre puede proporcionar cualquiera o todos los argumentos, en cualquier orden, asignando un valor al argumento con nombre. Para ello, escriba el nombre del argumento y un signo de dos puntos seguido del signo igual y el valor (MiArgumento:= "UnValor") y colocando esta asignación en cualquier secuencia delimitada con comas. Observe que los argumentos del ejemplo siguiente están en orden inverso al de los argumentos esperados:

Function ListText(strNombre As String, Optional varDirección As Variant)



List1.AddItem strNombreList2.AddItem varDirección

End Sub

Private Sub Command1_Click()ListText varDirección:=12345, strNombre:="Su nombre"

End Sub

Esto resulta especialmente útil si sus procedimientos tienen varios argumentos opcionales que no siempre necesita especificar.

Determinación del soporte de argumentos con nombre

Para determinar qué funciones, instrucciones y métodos aceptan argumentos con nombre, utilice la característica Información rápida automática de la ventana Código, compruebe el Examinador de objetos o consulte la Referencia del lenguaje en los Libros en pantalla. Tenga en cuenta lo siguiente cuando trabaje con argumentos con nombre:

• Los métodos de objetos de la biblioteca de objetos de Visual Basic (VB) no aceptan argumentos con nombre, ni tampoco lo hacen todas las palabras clave del lenguaje de la biblioteca de objetos de Visual Basic para aplicaciones (VBA).

• En la sintaxis, los argumentos con nombre se muestran en negrita y cursiva. Todos los demás argumentos se muestran sólo en cursiva.

Importante No puede utilizar argumentos con nombre para evitar especificar argumentos requeridos. Sólo puede omitir los argumentos opcionales. En las bibliotecas de objetos de Visual Basic (VB) y Visual Basic para aplicaciones(VBA), el Examinador de objetos pone los argumentos opcionales entre corchetes [ ].

1.7 Arrays: estáticos y dinámicos.

Un arreglo permite referirse a una serie de variables del mismo nombre, además de usar un número de identificación para cada elemento. Todos los elementos de un arreglo, tienen el mismo tipo de dato.

A continuación, se exponen tres carninos para declarar el tamaño de un arreglo; dependiendo del alcance que necesite tener el arreglo.

• Para crear un arreglo global, usar la declaración Global en la sección Declarations de un módulo.• Para crear un arreglo a nivel de módulo, usar la declaración Dim en la sección Declarations de una Forma o módulo• Para crear un arreglo local, usar la declaración Static en un procedimiento.

Ejemplos de arreglos:

Dim Conteo(20) As lntegerDim Sumas(40) As Double

Para crear un arreglo global:

Global Conteo(20) As IntegerGlobal Sumas(40) As Double



La misma declaración dentro de un procedimiento utilizando Static

Static Conteo(20) As lntegerStatic Sumas(40) As Double

En la siguiente declaración el número indice de Sumas corre de 120 a 140

Dim Sumas(120 a 140) As String

El siguiente ejemplo inicializa los elementos con un número 2

Static Sumas(1 a 20) As integerDim X As integerFor X=1 To 20 Sumas(X) = 2Next

Arreglos Multidimensionales

En Visual Basic, se pueden declarar arreglos hasta de 60 dimensiones. Por ejemplo, la siguiente declaración declara un arreglo de 2 dimensiones de 5x5 .

Static Matriz(4,4) As String0

Static Matriz(1 To 5,1 To 5) As String

Dim Multi(4,1 To 5,1 To 10)

El ejemplo anterior crea un arreglo de 3 dimensiones de 5 x 5 x 10; es decir: 250 elementos.

Arreglos Dinámicos

En algunas ocasiones, no se conoce que tan largo puede ser un arreglo. Un arreglo dinámico es muy eficiente, ya que permite cambiar el tamaño de un arreglo,

• Para crear un arreglo dinámico

1 Declarar el arreglo con la declaración Global o Dim, a nivel de módulo y con Dim o Static en un procedimiento. Se puede declarar el arreglo con una dimensión vacía . Por ejemplo:

Dim Arreglo( )

2 Asignar el actual número de elementos con la declaración ReDim. Por ejemplo:

ReDim Arregio(Y + 1)

La declaración ReDim, puede aparecer sólo en un procedimiento. ReDim puede cambiar el número de elementos de un arreglo, pero no el número de dimensiones.

Cada vez que se ejecuta un arreglo con la declaración ReDim, todos los valores almacenados en un arreglo, se pierden. Para evitar esto, se puede usar la palabra Preserve. Por ejemplo:

ReDim Preserve Arreglo(Arreglo+10)



1.8 Funciones internas de VB

Funciones de Cadenas de caracteres y de Fecha

Aunque un juego de caracteres de doble byte consiste en un byte de cabecera y un byte de cola y requiere dos bytes consecutivos de almacenamiento, debe tratarlo como una única unidad en cualquier operación relacionada con caracteres o cadenas. Varias funciones de manipulación de cadenas controlan de forma apropiada todas las cadenas, incluidos los caracteres DBCS, con base en el caracter.

Estas funciones tienen una versión ANSI/DBCS y una versión binaria o versión Unicode, como se muestra en la tabla siguiente. Utilice las funciones apropiadas dependiendo del propósito de la manipulación de cadenas.

Las versiones "B" de las funciones de la tabla siguiente se diseñaron para utilizarlas con cadenas de datos binarios. Las versiones "W" se diseñaron para utilizarlas con cadenas Unicode.

Función DescripciónAsc Devuelve el código de carácter ANSI o DBCS del primer carácter de una

cadena.AscB Devuelve el valor del primer byte de la cadena dada que contiene datos

binarios.AscW Devuelve el código de carácter Unicode del primer carácter de una

cadena.Chr Devuelve una cadena que contiene un código de carácter ANSI o DBCS

específico.ChrB Devuelve una cadena binaria que contiene un byte específico.ChrW Devuelve una cadena que contiene un código de carácter Unicode

específico.Input Devuelve desde un archivo un número de caracteres ANSI o DBCS

especificados.InputB Devuelve desde un archivo un número de bytes especificados.InStr Devuelve la primera ocurrencia de una cadena dentro de otra.InStrB Devuelve la primera ocurrencia de un byte en una cadena binaria.Left, Right

Devuelve un número de caracteres especificado desde la parte izquierda o derecha de una cadena.

LeftB, RightB

Devuelve un número de bytes especificado desde la parte izquierda o derecha de una cadena binaria.

Len Devuelve la longitud de la cadena en número de caracteres.LenB Devuelve la longitud de la cadena en número de bytes.Mid Devuelve un número especificado de caracteres de una cadena.MidB Devuelve un número especificado de bytes de una cadena binaria.

Las funciones sin una "B" o "W" de esta tabla controlan correctamente los caracteres DBCS y ANSI. Además de las funciones anteriores, la función String controla los caracteres DBCS. Esto significa que todas estas funciones consideran un carácter DBCS como un único carácter, incluso si se compone de 2 bytes.

El comportamiento de estas funciones es diferente cuando controlan caracteres SBCS y DBCS. Por ejemplo, la función Mid se utiliza en Visual Basic para devolver un número especificado de caracteres de una cadena. En las configuraciones regionales que utilizan DBCS, el número de caracteres y el número de bytes no son necesariamente el mismo. En estos casos Mid sólo devolvería el número de caracteres, no el de bytes.



En la mayoría de los casos, utilice las funciones basadas en caracteres cuando quiera controlar los datos de cadenas, ya que estas funciones pueden tratar correctamente las cadenas ANSI, las cadenas DBCS y las cadenas Unicode.

Las funciones de manipulación de cadenas basadas en bytes, como LenB y LeftB, se proporcionan para controlar los datos de las cadenas como datos binarios. Cuando almacena caracteres en una variable String u obtiene los caracteres de una variable String, Visual Basic convierte automáticamente los caracteres Unicode a ANSI. Cuando quiera controlar los datos binarios, utilice matrices Byte en lugar de variables String y las funciones de manipulación de cadenas basadas en bytes.

Para obtener más información Busque la función apropiada en la Referencia del lenguaje de los Libros en pantalla.

Si quiere controlar cadenas de datos binarios, puede asignar los caracteres de una cadena con una matriz Byte si utiliza el código siguiente:

Dim MiCadenaDeBytes() As Byte' Asigna la cadena con una matriz Byte.MiCadenaDeBytes = "ABC"' Presenta los datos binarios.For i = LBound(MiCadenaDeBytes) to UBound(MiCadenaDeBytes)

Print Right(" " + Hex(MiCadenaDeBytes(i)),2) + " ,";NextPrint

Conversión de cadenas DBCS

Visual Basic proporciona varias funciones de conversión cadenas que son útiles para los caracteres DBCS: StrConv, UCase y LCase.

Función StrConv

Las opciones globales de la función StrConv son convertir mayúsculas en minúsculas y viceversa. Además de estas opciones, la función tiene varias opciones específicas para DBCS. Por ejemplo, puede convertir letras estrechas en letras anchas si especifica vbWide en el segundo argumento de esta función. Puede convertir un tipo de carácter en otro, como hiragana en katakana en japonés.

También puede utilizar la función StrConv para convertir caracteres Unicode en caracteres ANSI/DBCS y viceversa. Normalmente, una cadena de Visual Basic está compuesta por caracteres Unicode. Cuando necesite tratar cadenas ANSI/DBCS (por ejemplo, para calcular el número de bytes de una cadena antes de escribir la cadena en un archivo), puede utilizar esta capacidad de la función StrConv.

Conversión de mayúsculas y minúsculas en letras anchas

Puede convertir mayúsculas a minúsculas y viceversa si utiliza la función StrConv con vbUpperCase o vbLowerCase o mediante las funciones UCase o LCase. Cuando utiliza estas funciones, las letras anchas en inglés de DBCS también se convierten como caracteres ANSI.



NOTA:

Visual Basic utiliza Unicode para almacenar y manipular cadenas. Unicode es un juego de caracteres en el que se emplean 2 bytes para representar cada carácter. Algunos otros programas, como la API de Windows 95 y 98, utilizan ANSI (American National Standards Institute) o DBCS para almacenar y manipular cadenas. Cuando mueva cadenas fuera de Visual Basic, puede que encuentre diferencias entre Unicode y ANSI/DBCS. En la tabla siguiente se muestran los juegos de caracteres ANSI, DBCS y Unicode en diferentes entornos.

Entorno Juego o juegos de caracteres utilizadoVisual Basic UnicodeBibliotecas de objetos de 32 bits UnicodeBibliotecas de objetos de 16 bits ANSI y DBCSAPI de Windows NT UnicodeAutomatización en Windows NT UnicodeAPI de Windows 95 ANSI y DBCSAutomatización en Windows 95 Unicode

ANSI

ANSI es el juego de caracteres estándar más utilizado por los equipos personales. Como el estándar ANSI sólo utiliza un byte para representar un carácter, está limitado a un máximo de 256 caracteres y signos de puntuación. Aunque es adecuado para el inglés, no acepta totalmente muchos otros idiomas.

DBCS

DBCS se utiliza en los sistemas Microsoft Windows que se distribuyen en la mayor parte de Asia. Proporciona soporte para muchos alfabetos de Asia Oriental, como el chino, el japonés y el coreano. DBCS utiliza los números de 0 a 128 para representar el juego de caracteres ASCII. Algunos números mayores de 128 funcionan como caracteres de cabecera, que no son realmente caracteres sino simples indicadores de que el valor siguiente es un carácter de un juego de caracteres no occidental. En DBCS, los caracteres ASCII tienen una longitud de 1 byte, mientras que los caracteres japoneses, coreanos y de otros países de Asia Oriental tienen una longitud de 2 bytes.

Unicode

Unicode es un esquema de codificación de caracteres que utiliza 2 bytes por cada carácter. ISO (International Standards Organization) define un número dentro del intervalo 0 a 65.535

(216

– 1) por cada carácter y símbolo de cada idioma (más algunos espacios vacíos para futuras ampliaciones). En todas las versiones de 32 bits de Windows, el Modelo de objetos componentes (COM), que es la base de las tecnologías OLE y ActiveX, utiliza Unicode. Unicode es totalmente compatible con Windows NT. Aunque Unicode y DBCS tienen caracteres de doble byte, los esquemas de codificación son completamente diferentes.



La tabla siguiente identifica los caracteres que puede utilizar para crear formatos de fecha/hora definidos por el usuario:

Carácter Descripción(:) Separador de hora. En algunas configuraciones regionales, se pueden utilizar

otros caracteres para representar el separador de hora. El separador de hora separa las horas, los minutos y los segundos cuando se da formato a los valores de hora. El carácter real que se utiliza como separador de hora en la salida con formato viene determinado por las configuraciones del sistema.

(/) Separador de fecha. En algunas configuraciones regionales se pueden utilizar otros caracteres para representar el separador de fecha. El separador de fecha separa el día, el mes y el año cuando se da formato a los valores de fecha. El carácter real que se utiliza como separador de fecha en la salida con formato viene determinado por las configuraciones del sistema.

c Muestra la fecha como ddddd y la hora como ttttt, en este orden. Sólo se muestra información de fecha si no hay parte fraccionaria en el número de serie de la fecha; sólo se muestra información de hora si no hay una parte entera.

d Muestra el día como un número sin un cero a la izquierda (1 – 31).dd Muestra el día como un número con un cero a la izquierda (01 – 31).ddd Muestra el día como abreviatura (Dom – Sáb).dddd Muestra el día como nombre completo (Domingo – Sábado).ddddd Muestra la fecha como fecha completa (incluyendo el día, el mes y el año), con el

formato de acuerdo a la configuración de formato de fecha corta del sistema. En Microsoft Windows, el formato predeterminado de fecha corta para Inglés – U.S. es m/d/aa, aunque cambia según la configuración regional.

dddddd Muestra un número de serie de fecha como fecha completa (incluyendo el día, el mes y el año), con el formato de acuerdo a la configuración de formato de fecha larga reconocido por el sistema. En Microsoft Windows, el formato predeterminado de fecha larga para Inglés-US es mmmm dd, aaaa, aunque cambia según la configuración regional.

w Muestra el día de la semana como un número (1 para Domingo hasta 7 para Sábado).

ww Muestra la semana del año como un número (1 – 54).m Muestra el mes como un número sin un cero a la izquierda (1 – 12). Si m

sigue inmediatamente a h o hh, se muestra el minuto en lugar del mes.mm Muestra el mes como un número con un cero a la izquierda (01 –

12). Si m sigue inmediatamente a h o hh, se muestra el minuto en lugar del mes.

mmm Muestra el mes como una abreviatura (Ene – Dic).mmmm Muestra el mes como nombre de mes completo (Enero –Diciembre).q Muestra el trimestre del año como un número (1 – 4).y Muestra el día del año como un número (1 – 366).yy Muestra el año como un número de dos dígitos (00 – 99).yyyy Muestra el año como un número de cuatro dígitos (100 – 9999).h Muestra la hora como un número sin ceros a la izquierda (0 – 23).hh Muestra la hora como un número con ceros a la izquierda (00 – 23).n Muestra el minuto como un número sin ceros a la izquierda (0 – 59).

Carácter Descripciónnn Muestra el minuto como un número con ceros a la izquierda (00 –



59).s Muestra el segundo como un número sin ceros a la izquierda (0 –

59).ss Muestra el segundo como un número con ceros a la izquierda (00 –

59).t t t t t Muestra una hora con formato completo (incluyendo hora, minutos y segundos),

utilizando el separador de hora definido por el formato de hora reconocido por el sistema. Se muestra un cero a la izquierda si está seleccionada la opción de cero a la izquierda y la hora es antes de 10:00 AM o PM En Microsoft Windows, el formato predeterminado de hora es h:mm:ss.

AM/PM Utilice el reloj de 12 horas para mostrar AM en mayúsculas con cualquier hora antes del mediodía; y mostrar PM en mayúsculas con cualquier hora entre el mediodía y 11:59 P.M.



am/pm Utilice el reloj de 12 horas para mostrar am en minúsculas con cualquier hora antes del mediodía; y mostrar pm en minúsculas con cualquier hora entre el mediodía y 11:59 P.M.

A/P Utilice el reloj de 12 horas para mostrar A en mayúsculas con cualquier hora antes del mediodía; y mostrar P en mayúsculas con cualquier hora entre el mediodía y 11:59 P.M.

a/p Se utiliza el reloj de 12 horas y muestra A en minúsculas con cualquier hora antes del mediodía; muestra P en minúsculas con cualquier hora entre el mediodía y 11:59 P.M.

AMPM Utilice el reloj de 12 horas para mostrar el literal de cadena AM como lo defina el sistema con cualquier hora antes del mediodía; y mostrar el literal de cadena PM como lo defina el sistema con cualquier hora entre el mediodía y 11:59 P.M. AMPM puede estar en mayúsculas o en minúsculas, pero las mayúsculas o minúsculas en la cadena que resulta se corresponden con la cadena definida por las configuraciones del sistema. En Microsoft Windows, el formato predeterminado es AM/PM.

Los siguientes son ejemplos de formatos de fecha y hora definidos por el usuario para el 6 de diciembre de 1999:

Formato Muestram/d/aa 12/7/99d-mmm 7-Dicd-mmmm-aa 7-Diciembre-99d mmmm 7 Diciembremmmm aa Diciembre 99hh:mm AM/PM 08:50 PMh:mm:ss a/p 8:50:35 ph:mm 20:50h:mm:ss 20:50:35m/d/aa h:mm 12/7/99 20:50



1.9 Eventos, propiedades y Controles

El primer paso para construir una aplicación en Visual Basic, es dibujar el objeto. Para esta primera aplicación, usaremos tres controles del ToolBox.

Control Nombre

TextBox (caja de Textos)

Command Button (Botón de Comando)

• Para dibujar un control usando el Toolbox.

1. Hacer click en el control que se desea. Utilizar en este caso, el de Text Box2. Mover el apuntador dentro de la Forma. Ver figura

3. Hacer click en la Forma con el botón izquierdo del mouse. Sin soltar el botón, arrastrar el objeto.

4. Soltar el botón del mouse

De esta manera, el control aparece en la Forma.



Un simple camino para añadir un control dentro de la Forma, es hacer doble-click en el icono del control del ToolBox: entonces se crea un control localizado en el centro de la Forma, con tamaño normal.

• Para cambiar el tamaño de un control.

1. Seleccionar el control, el cual se desea cambiar de tamaño, haciendo click con el mouse.2. Posicionar el apuntador en la esquina donde se desea cambiar el tamaño, tomarlo y

arrastrarlo con el mouse.3. Soltar el mouse.

• Para mover un control.

1. Posicionar el apuntador del mouse en el control que se desea mover, y tomar el control con el mouse.

2. Arrastrar el control a la nueva localización.3. Soltar el mouse.

Colocación de Propiedades

La Ventana de Propiedades (Properties) provee un fácil camino, para la determinación de las Propiedades de todos los objetos de la Forma. Para abrir la Ventana de Propiedades, se puede: seleccionar desde el menú de Windows; hacer click en el botón de Propiedades en el Toolbar ó bien, presionar la tecla F4.

1.5 Ventana de

Propiedades (Properties Window)


Ventana depropiedades

Lista de objetos

Propiedades

Descripción breve de la propiedad


La Ventana de Propiedades consiste de los siguientes elementos:

• Object Box.- Despliega el nombre del objeto al cual se determinan las propiedades. Al hacer click en la flecha de la derecha de la caja, se puede seleccionar una Forma ó cualquier control que se encuentre dentro de la Forma actual.

• Setting Box.- Permite editar la colocación, para la propiedad seleccionada en la lista de propiedades. Alguna colocación puede ser cambiada, haciendo click en la flecha a la derecha de la caja: esta despliega una lista de opciones, y puede seleccionarse alguna.

• Properties list.- La columna izquierda despliega la lista de propiedades que posee el objeto. La columna derecha determina la colocación de cada propiedad.

Para completar el ejemplo anterior, donde se despliega el mensaje "Mi Primera Aplicación"; se necesita cambiar a los objetos, las siguientes propiedades:

Objetos Propiedades SettingForm Caption Mi primera AplicaciónText Box Text (Vacío)Text Box FontName ArialText Box FontSize 16Command1 Button Caption OK

Para continuar con el ejemplo, añadir un segundo Command Button (Botón de comando) y colocar la siguiente propiedad:

Command2 Button Caption Exit

Escribiendo Código

La Ventana de código, es donde se escribe el código de Visual Basic para la aplicación. El código consiste del lenguaje de declaraciones y constantes. Usando la Ventana de código, se puede escribir rápidamente el código en la aplicación.

• Para abrir la Ventana de código.• Hacer doble-click en la Forma ó el control que está dentro de la Forma a la que se desea

escribir el código.• También se puede dentro de la Ventana de Proyectos, seleccionando el nombre de la

Forma y seleccionando el botón View Code.



La Ventana de código incluye los siguientes elementos:

• Object Box.- Despliega el nombre del objeto seleccionado. Haciendo click en la flecha que se encuentra al lado derecho de la caja, se despliega una lista de todos los objetos asociados con esta Forma.

• Procedure List Box.- Lista los procedimientos para un objeto. La caja despliega el nombre del procedimiento seleccionado; en este caso, Click. Seleccionando la flecha a la derecha de la caja, se despliega la lista de todos los procedimientos para el objeto.

El código, en una aplicación de Visual Basic; es dividido en pequeños bloques llamados procedimientos (procedures). Un event procedure, como el que se creó anteriormente; contiene código que es ejecutado cuando ocurre un evento (como hacer click en el botón).

• Para crear un event procedure

1. En el Object Box, se selecciona el nombre de un objeto en la Forma que se encuentra activada, para continuar con el ejemplo anterior y seleccionar el command button, Command1.

2. En el Procedure List box, se selecciona el nombre de un evento para el objeto seleccionado.

Aquí, el procedimiento Click ya fue seleccioando. Éste es el procedimiento default para los command buttons.

3. Escribir el siguiente código entre la declaración Sub y End Sub:

Para el Command Button, Command1 escribir:

Form1.BackColor = QBColor(Rnd * 15)Text1.Text = "Mi Primera Aplicación"Text1.BackColor = QBColor(Rnd * 15)Text1.FontSize = 16Text1.FontName = "Arial"

El event procedure de Command1, se ve así:

Sub Command1_Click()Form1.BackColor = QBColor(Rnd * 15)Text1.Text = "Mi Primera Aplicación"Text1.BackColor = QBColor(Rnd * 15)Text1.FontSize = 16Text1.FontName = "Arial"

End Sub

Para el Command Button, Command2 escribir: End

Sub Command2_Click()End

End Sub



La sintaxis para este ejemplo, es tomada desde object.property = setting. Se puede usar esta sintaxis para Formas y controles en la ocurrencia de eventos, mientras la aplicación está corriendo.

Control ComboBox

Un control ComboBox combina las características de un control TextBox y un control ListBox; los usuarios pueden introducir información en la parte del cuadro de texto o seleccionar un elemento en la parte de cuadro de lista del control.

Comentarios

Para agregar o eliminar elementos en un control ComboBox, use el método AddItem o RemoveItem. Establezca las propiedades List, ListCount y ListIndex para permitir a un usuario tener acceso a los elementos de un control ComboBox. Como alternativa, puede agregar elementos a la lista mediante la propiedad List en tiempo de diseño.

Nota Un evento Scroll ocurrirá en un control ComboBox sólo cuando se desplace el contenido de la parte desplegable del ComboBox, no cada vez que cambie el contenido del ComboBox. Por ejemplo, si la parte desplegable de un ComboBox contiene cinco elementos y el elemento superior está resaltado, no ocurrirá un evento Scroll hasta que presione seis veces la flecha hacia abajo (o una vez la tecla AV PÁG). Después de eso, ocurrirá un evento Scroll por cada pulsación de la tecla de flecha hacia abajo. Sin embargo, si después presiona la tecla de flecha hacia arriba, no ocurrirá un evento Scroll hasta que presione seis veces la tecla de flecha hacia arriba (o una vez la tecla RE PÁG). Después de eso, cada vez que presione la tecla de flecha hacia arriba se producirá un evento Scroll.

Eventos

Evento Change Evento LostFocusEvento Click Evento OLECompleteDragEvento DblClick Evento OLEDragDropEvento DragDrop Evento OLEDragOverEvento DragOver Evento OLEGiveFeedbackEvento DropDown OLESetData EventEvento GotFocus Evento OLEStartDragEventos KeyDown y KeyUp Evento ScrollEvento KeyPress

Métodos

Método AddItem Método RefreshMétodo Clear (Clipboard, ComboBox, ListBox)

Método RemoveItem

Método Drag Método SetFocusMétodo Move Método ShowWhatsThisMétodo OLEDrag Método ZOrder

Propiedades

Propiedad Appearance Propiedad ListIndexPropiedades BackColor y ForeColor Propiedad LockedPropiedad Container Propiedad MouseIcon



Propiedad DataChanged Propiedad MousePointerPropiedad DataField Propiedad NamePropiedad DragIcon Propiedad NewIndexPropiedad DragMode Propiedad OLEDragModePropiedad Enabled Propiedad OLEDropModePropiedad Font Propiedad ParentPropiedades FontBold, FontItalic, FontStrikethru y FontUnderline

Propiedades SelLength, SelStart y SelText

Propiedad FontName Propiedades SelLength, SelStart y SelText (Controles ActiveX)

Propiedad FontSize Propiedad SortedPropiedades Height y Width Propiedad StylePropiedad HelpContextID Propiedad TabIndexPropiedad hWnd Propiedad TabStopPropiedad Index (Control Array) Propiedad TagPropiedad IntegralHeight Propiedad TextPropiedad ItemData Propiedad ToolTipTextPropiedades Left y Top Propiedad TopIndexPropiedad List Propiedad VisiblePropiedad ListCount Propiedad WhatsThisHelpID



Cuándo debe utilizar un cuadro combinado(ComboBox) en lugar de un cuadro de lista (ListBox)

Generalmente, el ComboBox es el apropiado cuando hay una lista de opciones sugeridas y el cuadro de lista es el apropiado cuando desea limitar la entrada a las opciones de la lista. Un ComboBox contiene un campo de edición, de forma que en este campo se pueden introducir opciones que no figuran en la lista.

Además, los cuadros combinados ahorran espacio en los formularios. Como la lista completa no se presenta hasta que el usuario hace clic en la flecha abajo (excepto en el Estilo 1, donde siempre se presenta), un ComboBox puede ocupar un espacio reducido, en el que no cabría un cuadro de lista.

Características de enlace a datos

Visual Basic incluye versiones estándar y enlazadas a datos del control ComboBox. Si bien las dos versiones permiten presentar, modificar y actualizar la información en la mayoría de los tipos de bases de datos estándar, el ComboBox enlazado a datos proporciona características más avanzadas de acceso a datos. El control DBCombo acepta además un conjunto de propiedades y métodos diferente al del control ComboBox estándar.

Para obtener más información Para obtener más información, vea "Uso del cuadro de lista y el ComboBox enlazados a datos", en "Tener acceso a datos".

Estilos de cuadros combinados

Hay tres estilos de cuadros combinados. Cada estilo puede establecerse en tiempo de diseño o en tiempo de ejecución y, para establecer el estilo del ComboBox, se utilizan valores o constantes equivalentes de Visual Basic.

Estilo Valor ConstanteComboBox desplegable 0 vbComboDropDownComboBox simple 1 vbComboSimpleComboBox desplegable 2 vbComboDropDownList

ComboBox desplegable

Con el valor predeterminado (Style = 0 – ComboDropDown), un ComboBox es un ComboBox desplegable. El usuario puede escribir texto directamente (como en un cuadro de texto) o hacer clic en la flecha de la parte derecha del ComboBox para abrir una lista de opciones. Si selecciona una de las opciones, se inserta en el cuadro de texto de la parte superior del ComboBox. El usuario también puede abrir la lista mediante la combinación de teclas ALT+ FLECHA ABAJO, cuando el control tiene el enfoque.

ComboBox simple

Si establece la propiedad Style de un ComboBox a 1 – ComboSimple, especifica un ComboBox simple en el que la lista se presenta siempre. Para presentar todas las entradas de la lista, debe dimensionar el cuadro de lista de forma que quepan. Cuando hay más entradas de las que se pueden presentar se agrega automáticamente una barra de desplazamiento. El usuario también puede escribir texto directamente o seleccionar una



opción de la lista. Al igual que el ComboBox desplegable, el ComboBox simple permite que los usuarios escriban opciones que no figuran en la lista.

ComboBox de lista desplegable

Un cuadro de lista desplegable (Style = 2 – ComboDropDownList) es como un cuadro de lista normal: presenta una lista de elementos entre los que el usuario tiene que elegir. Sin embargo, a diferencia de los cuadros de lista, la lista no se presenta hasta que se hace clic en la flecha de la derecha del cuadro. La principal diferencia entre este estilo y el ComboBox desplegable es que el usuario no puede escribir en el cuadro, sólo puede seleccionar un elemento de la lista. Utilice este tipo de cuadro de lista cuando no disponga de mucho espacio.

Agregar elementos

Para agregar elementos a un ComboBox, utilice el método AddItem, que tiene la sintaxis siguiente:

Objeto.AddItem elemento[, índice]

Argumento DescripciónObjeto Nombre del ComboBox la lista o del cuadro.elemento Expresión de cadena que va a agregar a la lista. Si elemento es una constante

literal, tiene que ir entre comillas.índice Especifica dónde va a insertar el nuevo elemento dentro de la lista. Un índice de 0

representa la primera posición. Si se omite el argumento índice, el elemento se inserta al final (o en el orden establecido).

Aunque los elementos de la lista se suelen agregar en los procedimientos de evento Form_Load, puede utilizar el método AddItem en cualquier momento. Esto le ofrece la posibilidad de agregar elementos a la lista de forma dinámica (como respuesta a acciones del usuario).

El siguiente código inserta "Chardonnay”, "Fumé Blanc”, "Gewürztraminer” y "Zinfandel" en un ComboBox llamado Combo1 con la propiedad Style establecida a 0 (vbComboDropDown):

Private Sub Form_Load ()Combo1.AddItem "Chardonnay"Combo1.AddItem "Fumé Blanc"Combo1.AddItem "Gewürztraminer"Combo1.AddItem "Zinfandel"

End Sub

Cuando se carga el formulario en tiempo de ejecución y el usuario hace clic en la flecha hacia abajo, aparece la lista, como se muestra en la figura 7.8.

Figura 7.8 El ComboBox "Lista de vinos"

Agregar elementos en tiempo de diseño

También puede insertar elementos en la lista en tiempo de diseño si establece la propiedad List en la ventana Propiedades del control ComboBox. Cuando selecciona la propiedad List y después hace clic en la flecha hacia abajo, puede escribir un elemento de la lista y después presionar la combinación de teclas CTRL+ENTRAR para empezar otra línea.



Sólo puede agregar elementos al final de la lista. De esta forma, si desea ordenar la lista alfabéticamente, tiene que establecer la propiedad Sorted a True. Para obtener más información, consulte "Ordenación de una lista", más adelante en este mismo tema.

Agregar un elemento en una posición especificada

Para agregar un elemento a una lista en una posición determinada, especifique un valor de índice detrás del nuevo elemento. Por ejemplo, la siguiente línea de código inserta "Pinot Noir" en la primera posición y desplaza los demás elementos hacia abajo:

Combo1.AddItem "Pinot Noir", 0

Observe que el valor que especifica el primer elemento de una lista es 0 y no 1.

Ordenación de una lista

Puede establecer que los elementos se agreguen a la lista en orden alfabético si establece la propiedad Sorted a True y omite el índice. El orden no distingue entre mayúsculas y minúsculas; por tanto, las palabras "chardonnay" y "Chardonnay" reciben el mismo tratamiento.

Cuando la propiedad Sorted está establecida a True, el uso del método AddItem con un argumento índice puede producir resultados impredecibles y desordenados.

Quitar elementos

Para quitar elementos de un ComboBox puede utilizar el método RemoveItem, que tiene un argumento, índice, que especifica el elemento que va a quitar:

Objeto.RemoveItem índice

Los argumentos Objeto e índice son iguales que para AddItem.

Por ejemplo, para quitar la primera entrada de una lista utilizaría la siguiente línea de código:

Combo1.RemoveItem 0

Para quitar todas las entradas de un ComboBox, utilice el método Clear:

Combo1.Clear

Obtención del contenido de la lista con la propiedad Text

Normalmente, la manera más sencilla de obtener el valor del elemento seleccionado actualmente es utilizar la propiedad Text. Esta propiedad se corresponde con el contenido de la parte de cuadro de texto del control en tiempo de ejecución. Puede ser un elemento de la lista o una cadena de texto escrita por el usuario en el cuadro de texto.

Por ejemplo, el código siguiente presenta información acerca de Chardonnay si un usuario selecciona "Chardonnay" en el cuadro de lista:

Private Sub Combo1_Click ()If Combo1.Text = "Chardonnay" Then

Text1.Text = "Chardonnay es un vino blanco _ligeramente embocado."

End IfEnd Sub



La propiedad Text contiene el elemento seleccionado actualmente en el cuadro de lista Combo1. El código comprueba si se ha seleccionado "Chardonnay" y, si es así, presenta la información en el cuadro de texto.

Acceso a los elementos de la lista con la propiedad List

La propiedad List proporciona acceso a todos los elementos de la lista. Esta propiedad contiene una matriz en la que cada elemento de la lista es un elemento de la matriz. Cada elemento está representado en forma de cadena de texto. Para hacer referencia a un elemento de la lista, utilice esta sintaxis:

cuadro.List(índice)

El argumento cuadro es una referencia a un ComboBox e índice es la posición del elemento. El primer elemento tiene un índice 0, el siguiente tiene un índice 1 y así sucesivamente. Por ejemplo, la instrucción siguiente presenta el tercer elemento (índice = 2) de una lista en un cuadro de texto:

Text1.Text = Combo1.List(2)

Determinación de la posición con la propiedad ListIndex

Si desea saber la posición del elemento seleccionado en la lista de un ComboBox, utilice la propiedad ListIndex. Esta propiedad establece o devuelve el índice del elemento seleccionado actualmente en el control y sólo está disponible en tiempo de ejecución. Al establecer la propiedad ListIndex en un control ComboBox, también se genera un evento Click en dicho control.

El valor de esta propiedad es 0 si está seleccionado el primer elemento, 1 si es el siguiente y así sucesivamente. ListIndex es – 1 si no hay ningún elemento seleccionado o si el usuario escribe una opción en el ComboBox (Style 0 ó 1) en vez de seleccionar un elemento de la lista.

Nota La propiedad NewIndex permite conocer el índice del último elemento agregado a la lista. Puede ser útil cuando se inserta un nuevo elemento en una lista ordenada.

Obtención del número de elementos con la propiedad ListCount

Para obtener el número de elementos de un ComboBox, utilice la propiedad ListCount. Por ejemplo, la instrucción siguiente utiliza esta propiedad para determinar el número de entradas de un ComboBox:

Text1.Text = "Hay " & Combo1.ListCount & " _entradas en la lista"



Propiedad: ItemData

Devuelve o establece un número específico para cada elemento de un control ComboBox o ListBox.

Sintaxis

Objeto.ItemData(índex) [= número]

La sintaxis de la propiedad ItemData consta de las siguientes partes:

Parte DescripciónObjeto Una expresión de objeto que da como resultado un objeto de la lista Aplicable a.Índice El número de un elemento concreto del objeto.Número El número que se asocia con el elemento especificado.

Comentarios

La propiedad ItemData es una matriz de valores enteros largos cuyo número de elementos es el valor de la propiedad List de un control. Puede utilizar los números asociados con cada elemento para identificar los elementos. Por ejemplo, puede usar un número de identificación de empleado para identificar cada nombre de empleado de un control ComboBox o ListBox. Cuando llena el Objeto, también se llenan los elementos correspondientes de la matriz ItemData con los números de empleado.

La propiedad ItemData se usa a menudo como índice de una matriz de estructuras de datos asociadas con los elementos de un control.

Nota Cuando inserta un elemento en una lista con el método AddItem, el elemento también se inserta automáticamente en la matriz ItemData. Sin embargo, el valor no se reinicia a cero; conserva el valor que había en esa posición antes agregar el elemento a la lista. Cuando use la propiedad ItemData, asegúrese de establecer su valor al agregar nuevos elementos a la lista.

El siguiente ejemplo adiciona elementos (empleados y número de identificación)

Private Sub Form_Load ()' Llena el Combo1 y la matriz ItemData con los ' Elementos correspondientes ordenados.Combo1.AddItem "José Vargas"Combo1.ItemData(Combo1.NewIndex) = 1000Combo1.AddItem "Rosa Reyes"Combo1.ItemData(Combo1.NewIndex) = 2000Combo1.AddItem "Mauro Sorrento"Combo1.ItemData(Combo1.NewIndex) = 3000Combo1.AddItem "Alvaro Dominguez"Combo1.ItemData(Combo1.NewIndex) = 4000

End SubPrivate Sub Combo1_Click () ' Agrega el número y el nombre del empleado. Dim Msg As String Msg = "El empleado:" & Combo1.List(Combo1.ListIndex) Msg = Msg & " tiene el número: " & _ Combo1.ItemData(Combo1.ListIndex) MsgBox Msg, vbInformation + vbOKOnly, "Aviso"End Sub



1.10 Control de ErroresUn controlador de errores es una rutina para interceptar y responder a los errores de la aplicación. Querrá agregar controladores de error a cualquier procedimiento en el que prevea la posibilidad de un error (debería asumir que todas las instrucciones de Basic pueden producir un error a menos que sepa explícitamente que no va a ser así). El proceso de diseño de un controlador de errores implica tres pasos:

1. Establecer o activar, la interceptación de errores indicando a la aplicación hacia dónde se debe bifurcar (qué rutina de tratamiento de errores debe ejecutar) cuando se produce un error.

La instrucción On Error activa la interceptación y dirige la aplicación a la etiqueta que marca el principio de una rutina de tratamiento de errores.

2. Escribir una rutina de tratamiento de errores que responda a cualquier error que pueda prever. Si el control se bifurca realmente en la interceptación en algún punto, se dice que la interceptación está activa.

3. Salir de la rutina de tratamiento de errores.

En el caso del error "El disco no está listo", la instrucción Resume crea la bifurcación del código en la instrucción en la que se produjo el error. Entonces, Visual Basic intenta volver a ejecutar esa instrucción. Si la situación no ha cambiado, se produce otro error y la ejecución vuelve a la rutina de tratamiento de errores.

Establecimiento de la interceptación de errores

La interceptación de errores está activada cuando Visual Basic ejecuta la instrucción On Error, que especifica un controlador de errores. La interceptación de errores permanece activada mientras el procedimiento que lo contiene esté activo; es decir, hasta que se ejecute una instrucción Exit Sub, Exit Function, Exit Property, End Sub, End Function o End Property para ese procedimiento. Aunque sólo puede haber una interceptación de errores activada a la vez en cualquier procedimiento dado, puede crear varias interceptaciones de error alternativas y activar distintas interceptaciones en momentos diferentes. También puede desactivar una interceptación de errores usando un caso especial de la instrucción On Error con On Error GoTo 0.

Para establecer una interceptación de errores que salte a una rutina de tratamiento de errores, use una instrucción On Error GoTo línea, donde línea es la etiqueta que identifica el código de tratamiento de errores. En la función de ejemplo FileExists, la etiqueta es CheckError. (A pesar de que el signo de dos puntos forma parte de la etiqueta, no se utiliza en la instrucción On Error GoTo línea).

Escritura de una rutina de tratamiento de errores

El primer paso para escribir una rutina de tratamiento de errores es agregar una etiqueta de línea para marcar el principio de una rutina de tratamiento de errores. La etiqueta de línea debe tener un nombre descriptivo y debe ir seguida por un signo de dos puntos. Una convención común es colocar el código de tratamiento de errores al final del procedimiento con una instrucción Exit Sub, Exit Function o Exit Property inmediatamente delante de la etiqueta de línea. Esto permite que el procedimiento evite la ejecución de código de tratamiento de errores si no se produce ningún error.



El cuerpo de la rutina de tratamiento de errores contiene el código que realmente trata el error, normalmente en forma de una instrucción Case o If…Then…Else. Necesita determinar qué errores es probable que se produzcan y proporcionar una acción para cada uno; por ejemplo, pedir al usuario que inserte un disco en caso de que se produzca un error "El disco no está listo". Se debe proporcionar siempre una opción para tratar cualquier error inesperado, mediante la cláusula Else o Case Else.

La propiedad Number del objeto Err contiene un código numérico que representa el error de tiempo de ejecución más reciente. Si usa el objeto Err junto con la instrucción Select Case o If...Then...Else, puede llevar a cabo una acción específica para cualquier error que se produzca.

Nota La cadena contenida en la propiedad Description del objeto Err explica el error asociado al número de error actual. El texto exacto de la descripción puede variar de una versión de Microsoft Visual Basic a otra. Por tanto, use Err.Number en vez de Err.Description para identificar el error específico que se ha producido.

Salida de una rutina de tratamiento de errores

Hay varias formas de salir de una rutina de tratamiento de errores. Dependiendo de las circunstancias, puede hacerlo mediante una de las instrucciones que se muestran en la siguiente tabla.

Instrucción Descripción

Resume [0] La ejecución del programa se reanuda con la instrucción que causó el error o la última llamada que haya realizado el procedimiento que contenga la rutina de tratamiento de errores. Úsela para repetir una operación después de corregir la condición que causó el error.

Resume Next Reanuda la ejecución del programa en la instrucción que sigue inmediatamente a la que causó el error. Si el error se produjo fuera del procedimiento que contiene el controlador de errores, la ejecución se reanuda en la instrucción que sigue inmediatamente a la llamada al procedimiento donde se produjo el error, si el procedimiento llamado no tiene activado un controlador de errores.

Resume línea Reanuda la ejecución del programa en la etiqueta especificada por línea, donde línea es una etiqueta de línea (o un número de línea diferente de cero) que debe estar en el mismo procedimiento que el controlador de errores.

Err.Raise Number: = número Desencadena un error en tiempo de ejecución. Cuando se ejecuta esta instrucción dentro de la rutina de tratamiento de errores, Visual Basic busca en la lista de llamadas otra rutina de tratamiento de errores. (La lista de llamadas es la cadena de procedimientos que se han invocado para llegar al punto actual de ejecución. Consulte la sección "La jerarquía del tratamiento de errores", más adelante en este mismo tema.)



La diferencia entre las instrucciones Resume y Resume Next

En la siguiente figura se muestra la diferencia entre las instrucciones Resume y Resume Next.

Por lo general, Resume se usa siempre que el controlador de errores pueda corregir el error y Resume Next cuando el controlador de errores no pueda hacerlo. Puede escribir un controlador de errores de manera que la existencia de un error en tiempo de ejecución no se revele nunca al usuario o para presentar mensajes de error y permitir al usuario que realice correcciones.

Por ejemplo, el procedimiento Function en el siguiente código de ejemplo usa el tratamiento de errores para llevar a cabo una división "segura" de sus argumentos sin revelar los errores que se puedan producir. Los errores que se pueden producir al efectuar una división son:

Error Causa"División por cero" El numerador es distinto de cero, pero el

denominador es cero."Desbordamiento" El numerador y el denominador son cero

(durante una división de punto flotante)."Llamada no válida a un procedimiento" El numerador o el denominador no es un valor

numérico (o no se puede considerar como un valor numérico).



En los tres casos, el siguiente procedimiento Function intercepta estos errores y devuelve Null:

Function Divide (numer, denom) as VariantDim Msg as StringConst mnErrDivByZero = 11, mnErrOverFlow = 6, Const mnErrBadCall = 5On Error GoTo MathHandler

Divide = numer / denomExit Function

MathHandler:If Err.Number = MnErrDivByZero Or _Err.Number = ErrOverFlow _Or Err = ErrBadCall Then

Divide = Null ' Si el error era División por cero,

' Desbordamiento o Llamada no válida

' a un procedimiento, devuelve Null.

Else' Presenta mensaje de error no previsto.Msg "Error inesperado " & Err.Number Msg = Msg & ": " & Err.DescriptionMsgBox Msg, vbExclamation

End If ' En todos los casos, Resume Next continúa

Resume Next ' la ejecución en la instrucción Exit ' Function.

End Function

Reanudar la ejecución en una línea especificada

Resume Next también se puede utilizar cuando se produce un error dentro de un bucle y necesita reiniciar la operación. O bien, puede utilizar Resume línea, que devuelve el control a una etiqueta de línea especificada.

El siguiente ejemplo ilustra el uso de la instrucción Resume línea. Esta función, permite al usuario escribir una especificación de archivo que la función devuelve si existe el archivo.

Function VerifyFile As StringConst mnErrBadFileName = 52, _mnErrDriveDoorOpen = 71Const mnErrDeviceUnavailable = 68, _mnErrInvalidFileName = 64Dim strPrompt As String, strMsg As String, _strFileSpec As StringstrPrompt = "Especificación de archivo que desea comprobar:"

StartHere:strFileSpec = "*.*" ' Empieza con una especificación

' predeterminada.strMsg = strMsg & vbCRLF & strPrompt' Dejar al usuario modificar el valor predeterminadostrFileSpec = InputBox(strMsg, "Buscar archivo", _strFileSpec, 100, 100)



' Sale si el usuario elimina el valor predeterminadoIf strFileSpec = "" Then Exit FunctionOn Error GoTo Handler

VerifyFile = Dir(strFileSpec)Exit Function

Handler:Select Case Err.Number ' Analiza el código de error y carga

' el mensaje.Case ErrInvalidFileName, ErrBadFileName

strMsg = "Su especificación de archivo no es "strMsg = strMsg & "válida; pruebe con otra."

Case MnErrDriveDoorOpenstrMsg = "Cierre la puerta de la unidad de _"strMsg = strMsg & "disco e inténtelo de nuevo."

Case MnErrDeviceUnavailablestrMsg = "No se encuentra la unidad especificada."StrMsg = strMsg & " Inténtelo de nuevo."

Case ElseDim intErrNum As IntegerintErrNum = Err.NumberErr.Clear ' Borra el objeto Err.Err.Raise Number:= intErrNum ' Vuelve a generar el

error.End SelectResume StartHere ' Vuelve a la etiqueta StartHere para

' que el usuario pruebe con' otro nombre ' de archivo.

End Function

Si se encuentra una especificación de archivo coincidente, la función devuelve el nombre del archivo. Si no se encuentra ningún archivo coincidente, la función devuelve una cadena de longitud cero. Si se produce uno de los errores previstos, se asigna un mensaje a la variable strMsg y la ejecución vuelve a la etiqueta StartHere. Esto ofrece al usuario otra oportunidad de escribir una ruta de acceso y una especificación de archivo válida.

Si el error no estaba previsto, el segmento Case Else vuelve a generar el error para que el siguiente controlador de errores de la lista de llamadas pueda interceptar el error. Esto es necesario porque, si no se volviera a generar el error, el código continuaría la ejecución a partir de la línea Resume StartHere. Al volver a generar el error, está haciendo que se vuelva a producir el error y el nuevo error se interceptará en el siguiente nivel de la pila de llamadas.

Nota A pesar de que el uso de Resume línea es una forma legítima de escribir código, una proliferación de saltos a etiquetas de línea puede hacer que el código sea difícil de entender y depurar.



1.11 Modelo de Objetos de Sistemas de Archivos (FSO)

Visual Basic permite procesar archivos, folders y unidades(drives) de dos maneras, una por metodos de objetos independientes y la otra a través del Modelo de Objetos de Sistemas de Archivos.

El modelo FSO usa la convención de Objetos: método, propiedad y eventos para procesar drives, folders y archivos, permitiendo crear, alterar, mover, borrar, buscar y obtener información de objetos relacionados a éste.

El modelo FSO hace fácil estas tareas. Cuando procesa archivos su principal objetivo es almacenar datos eficientemente para poder accesarlos de la misma manera, con el fin de no sobrecargar con procesos a las bases de datos que ocupe, ya que el proceso de guardar datos grandes (BLOB) en la base de datos requiere de mayor tiempo de dedicación del RDBMS (Manejador de Base de Datos Relacional).

NOTA: Para utilizar el objeto FSO debe activar la referencia a “Microsoft Scripting Runtime” que hace refernecia al archivo Scrrun.Dll

El modelo FSO cuenta con los siguientes objetos:Object Description

FileSystemObjectEs el objeto principal del grupo, le permite accesar todos los eventos, metodos y

Drive

Permite obtener información acerca del drive especificado como: espacio disponible, nombre lógico con que se comparte, nombre de la unidad. Nota: También puyede hacer referencia a una unidad de CD-ROM, disco en

RAM, etc. EL drive no requiere que sea una unidad conectada al equipo, también puede ser una unidad lógica accesada por la RED.

FolderPermite crear, borrar o mover folders, así como consultar nombres, paths, etc.

FilesPermite crear, borrar o mover archivos, así como consultar nombres, paths, etc.

TextStream Permite leer y escribir archivos de texto.

Al trabajar con el módelo FSO se involucran tres tareas: El uso del método de CreateObject o declarar la variable como FileSystemObject El uso de los métodos apropiados del objeto creado El uso de las propiedades del objeto creado

Dichas tareas se explicarán a continuación.



Crear un objeto FileSystemObject

El primer paso es crear un objeto FileSystemObject para poder trabajar con él. Se puede realizar ésto de dos formas:

• Declara una valriable del tipo de objeto FileSystemObject:Dim fso As New FileSystemObject

• Usar el método CreateObject:Set fso = CreateObject("Scripting.FileSystemObject")

Note que la esencia es crear un objeto dwl tipo FileSystemObject.

Nota El primer método trabaja bajo VB, mientras que el segundo trabaja en VB y VBScript.

Usar el método apropiado

El siguiente paso es usar el método apropiado del objeto FileSystemObject. Por ejemplo, si desea crear un nuevo objeto, puede usar los métodos CreateFolder o CreateTextFile. (El modelo FSO no soporta la creación o borrado de unidades “drives”).

Si desea borrar un objeto, puede usar los métodos DeleteFile y DeleteFolder del objeto FileSystemObject, o el método de Delete de los objetos File y Folder. Puede copiar y mover archivos y folders.

Accesando existentes Drives, Files, y Folders

Para accesar un existente drive, file, or folder, use el apropriado método "get" del objeto FileSystemObject:

• GetDrive• GetFolder• GetFile

Por ejemplo:

Dim fso As New FileSystemObject, fil As FileSet fil = fso.GetFile("c:\test.txt")



Observe que no es necesario usar el método “get” para obtener información cuando ya ha creado un objeto, una vez creado el objeto podrá manejar los métodos asociados a éste. Por ejemplo, si usted crea un nuevo objeto folder usando el método CreateFolder, no necesitará usar el método GetFolder para usar sus propiedades como son: Name, Path, Size, etc. Sólo necesita establecer la variable al objeto CreateFolder y este nuevo objeto accesará las propiedades, métodos y eventos asociados, como lo muestra el siguiente ejemplo:

Private Sub Create_Folder() Dim fso As New FileSystemObject, fldr As Folder Set fldr = fso.CreateFolder("C:\MyTest") MsgBox "nombre del folder creado:" & fldr.NameEnd Sub

Accesando las propiedades de Objeto

Una vez que tiene el manejador del objeto, podrá accesar sus propiedades. Por ejemplo, decirle que quiere obtener el nombre de un folder particular. Primero cree una instancia del objeto, entonces podrá manejar los métodos apropiados de éste ( en este caso el método GetFolder, si es que ya existe este folder): Set fldr = fso.GetFolder("c:\")

Ahora usted podrá manejar el objeto folder como checar la propiedad Name:Debug.Print "Folder name is: "; fldr.Name

Si desea saber cual fue la última vez que el archivo fue modificado, use el siguiente método:Dim fso As New FileSystemObject, fil As FileSet fil = fso.GetFile("c:\detlog.txt") ' Get a File object to query.Debug.Print "El File fue modificado: "; fil.DateLastModified '

Trabajando con Drives y Folders

Con el modelo FSO usted puede trabajar con drivers y folders al igual que lo hace con Windows, podrá copiar, mover y obtener información acerca de los drivers y folders.

Obteniéndo información acerca de Drives

El objeto Drive, le permitirá obtener información de los drives que se encuentran en el sistema (PC) tanto físicos como mapeados. Estas propiedades le permitirán obtener información sobre:

• El tamaño total del drive en bytes (TotalSize).• El espacio disponible existente en el drive en bytes (AvailableSpace or FreeSpace).• Que letra está asignada al drive (DriveLetter property).• El tipo de drive: removible, fijo, mapeado, CD-ROM, o RAM disk (DriveType).• El número serial del drive (SerialNumber).• El tipo de file system del drive, como FAT, FAT32, NTFS, etcétera (FileSystem).• Que drive esta disponible para usar (IsReady).• El nombre compartido y/o etiqueta del drive (ShareName and VolumeName).• El path o RootFolder del drive (Path and RootFolder).



El ejemplo siguiente muestra como usar el objeto Drive, para obtener información acerca de éste. Recuerde que no necesita hacer una referencia al objeto Drive, en lugar de eso use el método GetDriver para obtener información acerca del objeto Drive.

Private Sub Command3_Click() Dim fso As New FileSystemObject, drv As Drive, s As String Set drv = fso.GetDrive(fso.GetDriveName("c:")) s = "Drive " & UCase("c:") & " - " s = s & drv.VolumeName & vbCrLf s = s & "Espacio Total: " & FormatNumber(drv.TotalSize / 1024, 0) s = s & " Kb" & vbCrLf s = s & "Espacio Libre: " & FormatNumber(drv.FreeSpace / 1024, 0) s = s & " Kb" & vbCrLf MsgBox sEnd Sub

Usando CurDir, ChDrive, ChDir o App.Path

Si usa la función Cur Dir, las instrucciones ChDrive y ChDir o la propiedad de Path (App.Path), ponga atención, ya que éste puede retornar un path UNC (como \\Server\Nombre_compartido…) en vez del path del drive (como E:\Folder), ésto dependera de cómo ejecute su programa o proyecto.

App.Path retorna un UNC path de acuerdo a:

• Cuando se ejecuta un proyecto después de cargarlo de un recurso compartido, siempre que el recurso esté mapeado a nuestra PC con una letra.

• Cuando se corre un archivo ejecutable desde un recurso compartido, siempre que éste sea ejecutado usando UNC path.

ChDrive no puede manejar un UNC path, éste provocará un error cuando el App.Path retorna uno. Podrá manejar este error adicionando la instrucción On Error Resume Next después de la instrucción ChDrive o probando los primeros dos caracteres de App.Path para verificar si son diagonales invertidas (\\):

On Error Resume NextChDrive App.PathChDir App.Path


smb://Server/Nombre


Trabajando con Folders

La siguiente tabla muestra las tareas y métodos del objeto Folder:Tarea Método

Crear un folder FileSystemObject.CreateFolder

Borrar un folder Folder.Delete o FileSystemObject.DeleteFolder

Mover un folder Folder.Move o FileSystemObject.MoveFolder

Copiar un folder Folder.Copy o FileSystemObject.CopyFolder

Obtener el nombre de un folder Folder.Name

Verificar si existe un folder FileSystemObject.FolderExists

Establecer una instancia de un folder existente

FileSystemObject.GetFolder

Obtener el nombre del padre del folder FileSystemObject.GetParentFolderName

Obtener el path del folder FileSystemObject.GetSpecialFolder

Ejemplo

El siguiente ejemplo ilustra el uso de los objetos Folder y FileSystemObject:

Private Sub Command10_Click() ' Establecer una instancia del FileSystemObject. Dim fso As New FileSystemObject, fldr As Folder, s As String ' Establecer el objeto Drive. Set fldr = fso.GetFolder("c:") ' Desplegar el nombre del folder padre. Debug.Print " nombre del folder padre: " & fldr ' Desplegar el nombre del drive. Debug.Print "Contenido del drive " & fldr.Drive ' Desplegar la ruta. If fldr.IsRootFolder = True Then Debug.Print "Este folder es la raíz." Else Debug.Print " Este folder no es la raíz." End If ' Crear un folder con el objeto FileSystemObject. fso.CreateFolder ("c:\Nuevo") Debug.Print "Se creo el folder C:\Nuevo" ' Desplegar el nombre base del folder. Debug.Print "Nombre base= " & fso.GetBaseName("c:\Nuevo") ' Borrar el folder creado. fso.DeleteFolder ("c:\Nuevo") Debug.Print "Folder borrado C:\Nuevo"End Sub



Trabajando con Archivos

Con el objeto FSO puedes copiar, borrar y abrir archivos. Existen dos categorias para el manejo de estas opciones:

• Crear, adicionar, remover datos y lectura.• Mover, copiar y borrar.

Crear, adicionar, remover datos y lectura

Existen tres maneras para crear archivos de texto secuenciales, algunas veces nos referimos a éstos como "text stream”. Una de estas es usar el método CreateTextFile:

Dim fso As New FileSystemObject, fil As FileSet fil = fso.CreateTextFile("c:\prueba.txt", True)

Nota. El modelo de objetos FSO no soporta la creación de archivos Random o Binarios, para crear estos tipos de archivos use el comando Open con la bandera establecida como Random o Binary.

Otra forma para utilizar el método OpenTextFile del objeto FileSystemObject con la bandera establecida como ForWriting (para escritura):

Dim fso As New FileSystemObject, ts As New TextStreamSet ts = fso.OpenTextFile("c:\test.txt", ForWriting)Or you can use the OpenAsTextStream method with the ForWriting flag set:Dim fso As New FileSystemObject, fil As File, ts As TextStreamSet fso = CreateObject("Scripting.FileSystemObject")fso.CreateTextFile ("test1.txt")Set fil = fso.GetFile("test1.txt")Set ts = fil.OpenAsTextStream(ForWriting)

Adicionando datos al Archivo

Una vez que el archivo de texto ha sido creado, usted podrá adicionar datos de acuerdo con lo siguiente:

1. Abrir el archivo de texto para escritura de datos.2. Escribir los datos.3. Cerrar el archivo.

Para abrir el archivo, puede usar los siguientes métodos: el método OpenAsTextStream del objeto File o el método OpenTextFile del objeto FileSystemObject.

Para escribir datos en el archivo abierto de datos, use los métodos Write o WriteLine del objetoTextStream. La diferencia entre éstos es que WriteLine adiciona un salto de línea al final de la cadena.



Si desea adicionar una línea en blanco en el archivo de texto use el método WriteBlankLines.

Para cerrrar un archivo abierto, use el método Close del objeto TextStream.

El siguiente ejemplo ilustra lo anterior.

Sub Create_File() Dim fso, txtfile Set fso = CreateObject("Scripting.FileSystemObject") Set txtfile = fso.CreateTextFile("c:\prueba.txt", True) txtfile.Write ("This is a test. ") ' Write a line. ' Write a line with a newline character. txtfile.WriteLine("Testing 1, 2, 3.") ' Write three newline characters to the file. txtfile.WriteBlankLines(3) txtfile.CloseEnd Sub

Lectura de Archivos con FSO

Para leer datos de un archivo de texto, use los siguientes métodos del objeto TextStream:Tarea MétodoLeer un número especificado de caracteres de un archivo ReadLeer una línea entera (no incluye el carácter nueva línea). ReadLineLeer el contenido total de un archivo de texto ReadAll

Si desea saltar n caracteres o líneas, puede utilizar los métodos Skip o SkipLine.

El texto resultante de una lectura es almacenado en un string.

Nota La constante vbNewLine avanza el cursor hasta el comienzo de la siguiente línea.

Ejemplo

Sub Read_Files() Dim fso As New FileSystemObject, txtfile, _ fil1 As File, ts As TextStream Set txtfile = fso.CreateTextFile("c:\prueba.txt", True) MsgBox "Escribiendo en el archivo" ' Escribiendo una línea. Set fil1 = fso.GetFile("c:\prueba.txt") Set ts = fil1.OpenAsTextStream(ForWriting) ts.Write "Curso de Visual Basic" ts.Close ' Leyendo contenido. Set ts = fil1.OpenAsTextStream(ForReading) s = ts.ReadLine MsgBox s ts.CloseEnd Sub



Moviendo, Copiando y Borrando Archivos

Tarea MétodoMover un archivo File.Move o FileSystemObject.MoveFileCopiar un archivo File.Copy o FileSystemObject.CopyFileBorrar una archivo File.Delete o FileSystemObject.DeleteFile

Ejemplo

Este ejemplo crea un archivo de texto en la raíz del drive c. Escribe en éste, lo mueve al directorio \tmp, hace una copia de éste llamado \temp y borra los archivos copiados en ambos directorios.

Para ejecutar este ejemplo asegúrese que tiene los directorios \tmp y \temp en la raíz del drive C.

Sub Manip_Files() Dim fso as New FileSystemObject, txtfile, fil1, fil2 Set txtfile = fso.CreateTextFile("c:\prueba.txt", True) MsgBox "Escribiendo en archivo" ' Escribiendo una línea. txtfile.Write ("Curso de Visual Basic.") ' Cerrando el archivo. txtfile.Close MsgBox "Moviendo el archivo a c:\tmp" ' Obteniendo una instancia del archivo. Set fil1 = fso.GetFile("c:\prueba.txt") ' Moviendo el archivo a \tmp directory. fil1.Move ("c:\tmp\prueba.txt") MsgBox "Copiando archivo a c:\temp" ' Copiando archivo a \temp. fil1.Copy ("c:\temp\prueba.txt") MsgBox "Borrando archivos" ' Obteniendo una instancia de los archivos creados. Set fil1 = fso.GetFile("c:\tmp\prueba.txt") Set fil2 = fso.GetFile("c:\temp\prueba.txt") ' Borrando archivos. fil1.Delete fil2.Delete MsgBox "Fin de proceso"End Sub



1.12 Objetos del sistema de archivos: Drive, Folder y Files

Tipos de acceso a archivos

Por sí mismo, un archivo no es más que una serie de bytes relacionados ubicados en un disco. Cuando su aplicación tiene acceso a un archivo, debe asumir qué se supone que representan los bytes (caracteres, registros de datos, enteros, cadenas, etc.)

Dependiendo del tipo de datos que contiene el archivo, se usa el tipo de acceso apropiado. En Visual Basic hay tres tipos de acceso a archivos:

• Secuencial: para leer y escribir archivos de texto en bloques continuos.

• Aleatorio: para leer y escribir archivos binarios de texto o estructurados como registros de longitud fija.

• Binario: para leer y escribir archivos estructurados de forma arbitraria.

El acceso secuencial está diseñado para usarlo con archivos de texto normales. Se supone que cada carácter del archivo representa un carácter de texto o una secuencia de formato de texto, como un carácter de nueva línea (NL). Los datos se almacenan como caracteres ANSI. Se supone que un archivo abierto para acceso aleatorio se compone de un conjunto de registros de longitud idéntica. Puede usar tipos definidos por el usuario para crear registros compuestos de varios campos, en los que cada uno puede tener tipos de datos diferentes. Los datos se almacenan como información binaria.

El acceso binario le permite usar archivos para almacenar datos de la manera que desee. Es similar al acceso aleatorio, excepto porque no se hacen suposiciones sobre los tipos de datos o la longitud del registro. No obstante, debe saber de manera precisa cómo se escribieron los datos en el archivo para poder recuperarlo correctamente.

Para obtener más información Para obtener más información acerca de los tipos de acceso a datos, consulte "Uso del acceso secuencial a archivos", "Uso del acceso aleatorio a archivos" y "Uso del acceso binario a archivos". Para obtener información acerca de cuestiones de Unicode y ANSI, consulte "ANSI, DBCS y Unicode: Definiciones" y "Procesamiento de archivos con caracteres de doble byte" en "Aspectos internacionales".

Instrucciones y funciones de acceso a datos

Las siguientes funciones se usan con los tres tipos de acceso a datos:

Dir FileLen LOFEOF FreeFile SeekFileCopy GetAttr SetAttrFileDateTime Loc



La siguiente tabla muestra todas las instrucciones de acceso a archivos y las funciones disponibles para cada uno de los tipos de acceso directo a archivos.

Instrucciones y funciones

Secuencial Aleatorio BinarioClose X X XGet X X

Input( ) X X

Input # X

Line Input # X

Open X X XPrint # X

Put X X

Write # X

Un control DirListBox muestra directorios y rutas de acceso en tiempo de ejecución. Utilice este control para mostrar una lista jerárquica de directorios. Puede crear cuadros de diálogo que, por ejemplo, permitan a un usuario abrir un archivo desde una lista de archivos de todos los directorios disponibles.

Sintaxis

DirListBox

Comentarios

Establezca las propiedades List, ListCount y ListIndex para permitir al usuario tener acceso a los elementos de una lista. Si también muestra los controles DriveListBox y FileListBox, puede escribir código para sincronizarlos con el control DirListBox y entre sí.

Eventos

Evento Change Evento MouseMoveEvento Click Evento OLECompleteDragEvento DragDrop Evento OLEDragDropEvento DragOver Evento OLEDragOverEvento GotFocus Evento OLEGiveFeedbackEventos KeyDown y KeyUp Evento OLESetDataEvento KeyPress Evento OLEStartDragEvento LostFocus Evento ScrollEventos MouseDown y MouseUp

Métodos

Método Drag Método SetFocusMétodo Move Método ShowWhatsThisMétodo OLEDrag Método ZOrderMétodo Refresh



Propiedades

Propiedad Appearance Propiedad ListCountBackColor y ForeColor Propiedad ListIndexPropiedad Container Propiedad MouseIconPropiedad DragIcon Propiedad MousePointerPropiedad DragMode Propiedad NamePropiedad Enabled Propiedad OLEDragModePropiedad Font Propiedad OLEDropModePropiedad FontBold, FontItalic, FontStrikethru y FontUnderline

Propiedad Parent

Propiedad FontName Propiedad PathPropiedad FontSize Propiedad TabIndexPropiedad Height y Width Propiedad TabStopPropiedad HelpContextID Propiedad TagPropiedad hWnd Propiedad ToolTipTextPropiedad Index (Control Array) Propiedad TopIndexPropiedad Left y Top Propiedad VisiblePropiedad List Propiedad WhatsThisHelpID

Un control DriveListBox permite al usuario seleccionar una unidad de disco válida en tiempo de ejecución. Utilice este control para mostrar una lista de todas las unidades válidas del sistema de un usuario. Puede crear cuadros de diálogo que permitan al usuario abrir un archivo de una lista de un disco en cualquier unidad disponible.

Sintaxis

DriveListBox

Comentarios

Establezca las propiedades List, ListCount y ListIndex para permitir al usuario tener acceso a los elementos de la lista. Si además muestra los controles DirListBox y FileListBox, podrá escribir código para sincronizarlos con el control DriveListBox y entre sí.

Eventos

Evento Change Evento OLECompleteDragEvento DragDrop Evento OLEDragDropEvento DragOver Evento OLEDragOverEvento GotFocus Evento OLEGiveFeedbackEvento KeyDown y KeyUp Evento OLESetDataEvento KeyPress Evento OLEStartDragEvento LostFocus Evento Scroll

Métodos

Métodos Drag Métodos SetFocusMétodos Move Métodos ShowWhatsThisMétodos OLEDrag Métodos ZOrderMétodos Refresh



Propiedades

Propiedad Appearance Propiedad ListPropiedades BackColor y ForeColor Propiedad ListCountPropiedad Container Propiedad ListIndexPropiedad DragIcon Propiedad MouseIconPropiedad DragMode Propiedad MousePointerPropiedad Drive Propiedad NamePropiedad Enabled Propiedad OLEDropModePropiedad Font Propiedad ParentPropiedades FontBold, FontItalic, FontStrikethru y FontUnderline

Propiedad TabIndex

Propiedad FontName Propiedad TabStopPropiedad FontSize Propiedad TagPropiedades Height y Width Propiedad ToolTipTextPropiedad HelpContextID Propiedad TopIndexPropiedad hWnd Propiedad VisiblePropiedad Index (Control Array) Propiedad WhatsThisHelpIDPropiedades Left y Top

El control FileListBox encuentra y muestra los archivos del directorio especificado por la propiedad Path en tiempo de ejecución. Utilice este control para mostrar una lista de los archivos seleccionados por tipo. Puede crear cuadros de diálogo en la aplicación que, por ejemplo, permitan al usuario seleccionar un archivo o un grupo de archivos.

Sintaxis

FileListBox

Comentarios

Establezca las propiedades List, ListCount y ListIndex para permitir al usuario tener acceso a los elementos de la lista. Si además muestra los controles DirListBox y DriveListBox, podrá escribir código para sincronizarlos con el control FileListBox y entre sí.

Eventos

Evento Click Evento OLECompleteDragEvento DblClick Evento OLEDragDropEvento DragDrop Evento OLEDragOverEvento DragOver Evento OLEGiveFeedbackEvento GotFocus Evento OLESetDataEventos KeyDown y KeyUp Evento OLEStartDragEvento KeyPress Evento PathChangeEvento LostFocus Evento PatternChangeEvento MouseDown y MouseUp Evento ScrollEvento MouseMove

Métodos

Método Drag Método SetFocusMétodo Move Método ShowWhatsThisMétodo OLEDrag Método ZOrderMétodo Refresh

Propiedades



Propiedad Appearance Propiedad LockedPropiedades Archive, Hidden, Normal y System

Propiedad MouseIcon

Propiedades BackColor y ForeColor Propiedad MousePointerPropiedad Container Propiedad MultiSelectPropiedad DragIcon Propiedad NamePropiedad DragMode Propiedad OLEDragModePropiedad Enabled Propiedad OLEDropModePropiedad FileName Propiedad ParentPropiedad Font Propiedad PathPropiedades FontBold, FontItalic, FontStrikethru y FontUnderline

Propiedad Pattern

Propiedad FontName Propiedad ReadOnlyPropiedad FontSize Propiedad SelectedPropiedades Height y Width Propiedad TabIndexPropiedad HelpContextID Propiedad TabStopPropiedad hWnd Propiedad TagPropiedad Index (Control Array) Propiedad ToolTipTextPropiedad Left y Top Propiedad TopIndexPropiedad List Propiedad VisiblePropiedad ListCount Propiedad WhatsThisHelpIDPropiedad ListIndex

NOTAS IMPORTANTES SOBRE EL MANEJO DE OBJETOS: Drive, Folder y Files

Drive

La propiedad Drive del control lista de unidades de disco permite saber cual es la unidad actual. Cuando queremos modificar la unidad actual, solo el primer carácter de la cadena de caracteres correspondiente es significativa. Un cambio de unidad de disco genera el susceso Change.Esta propiedad sólo esta disponible en tiempo de ejecución. Por ejemplo:Drv_Drive.Drive =”d:”

Cuamndo se elige una unidad de disco de la lista, la unidad de trabajo actual no cambia automáticamente. Si desea hacerlo, tiene que ejecutar la sentencia:

ChDrive drv_Drive.Drive

Folder

El directorio actual en el control lista de directorios aparece sombreado. La propiedad Path devuelve la ruta completa del directorio actual, incluyendo el nombre de la unidad. Modificando el valor de esta propiedad podemos cambiar el directorio actual. Si sólo modificamos la unidad (por ejemplo, d: ), por defecto se selecciona el directorio actual en dicha unidad. Un cambio de directorio actual genera el suceso Change. La propiedad Path sólo esta disponible en tiempo de ejecución y pertenece también al control Lista de Ficheros, con la diferencia de que aquí un cambio del camino actual genera el susceso PathChange. Por ejemplo:

Dir_Dir.Path = “d:\temp”



Cuando se elige un directorio de la Lista ele directorio de trabajo actual no cambia automáticamente. Si desea hacerlo tiene que ejecutar la sentencia:

ChDir Dir_Dir.Path

El directorio especificado por la propiedad Path siempre tiene como índice –1 (Propiedad ListIndex). El directorio que esta inmediatamente encima de él tiene como índice-2, y así sucesivamente hasta el directorio raíz. El primer subdirectorio que esta inmediatamente a continuación tiene como índice 0. Si hay varios directorios en el priemer nivel de subdirectorios, el siguiente tiene índice 1, y así sucesivamente. Dese cuenta que una lista sólo esta compuesta por el directorio especificado por la propiedad Path, más los directorios hasta llegar desde éste hasta el directorio Raíz, más los directorios correspondientes a su primer nivel de subdirectorios.El número de directorios correspondientes al primer nivel de subdirectorios del directorio especificado por la propiedad Path viene dado por la propiedad ListCount de la Lista.

Para calcular el índice correspondiente al directorio Raíz, escriba el siguiente código:

Dim InDirRaíz As IntegerInDirRaíz = dir_Dir.ListIndex Do Until dir_Dir.List(InDirRaíz) = “”

InDirRaíz= InDirRaíz-1Loop InDirRaíz= InDirRaíz+1

FilesLa propiedad FileName permite especificar el fichero que se quiere utilizar o devuelve el nombre del fichero seleccionadoen una lista; esta propiedad sólo está disponible en tiempo de ejecución por ejemplo:

Lstr_NomArchivo = File1.FilenName

La propiedad Pattern del control Lista de Ficheros permite que se visualicen solamente los ficheros que cumplan el patrón especificadoo ésta. Por ejemplo:

*.txt ‘hace que se visualicen sólo los archivos con extensión .txt

Los atributostambién estan disponibles a través de las propiedades Archive, Normal, System, Hidden y ReadOnly. Por ejemplo:

Si no quiere visualizar los archivos ocultos, asigene a ala propiedad Hidden el valor False. Cuando la propiedad Normal tiene asignado el valor True, se visualizan todos los ficheros, menos los ocultos y los de sistema. Las proepiedades System y Hidden tienen por defecto valor False; las demás tienen valor True. Para poner atributos a un archivo utilece la sentencia SetAttr y para obtenerlos GetAttr.



1.13 Manejo de API's

Un programa en ambiente Windows, además de accesar toda la funcionalidad establecida en su entorno, también accesa el entorno de programación de interfaz de aplicaciones para Windows conocido como API (Windows Aplication Programming Interface), cuya característica principal son los mensajes y las funciones.

Existen cientos de funciones que ejecutan una amplia variedad de tareas. Los mensajes son utilizados por Windows para permitir que las aplicaciones se comuniquen entre sí y con el propio sistema. Se dice entonces que las aplicaciones Windows son conducidas por mensajes o sucesos.

Una Biblioteca Dinámica (Dynamic Link Libraries, DLL) permite que las aplicaciones windows compartan código y recursos. Una DLL es un archivo ejecutable que contiene funciones que puede ser utilizada por todas las aplicaciones.

Ventajas. Permiten realizar acciones especiales que no se pueden realizar directamente en VB. Se actualizan sin tener que modificar los programas que la utilizan. No existe duplicidad de código cuando varias aplicaciones las utilizan.

DesventajasΧ Tiempo en que Windows emplea para leer las funciones.Χ El archivo físico debe estar presente cuando se ejecuta el programa.

Las funciones de la API de Windows están disponibles en las bibliotecas Kernel, GDI y User, locaclizadas en la carpeta System de Windows. Para acceder a estas funciones, VB utiliza la sentencia DECLARE: El archivo win32API.txt, contiene las sentencias DECLARE de casi todas las funciones del API de windows (exceptuando las que trabajan con punteros).

Como los procedimientos de una DLL son externos a su aplicación, deberá proporcionar cierta información que permita localizar y por lo tanto ejecutar el procedimiento deseado. Esta información se declara en un módulo. Por ejemplo:

Declare Function GetModuleHandle Lif “Kernel32” (ByVal LPModuleName As String) As Integer

Puede utilizar la clausula Alias en cualquier otra situación en la que le sea conveniente. Por ejemplo, En un modulo inserte la siguiente instrucciónDeclare Function DirWin Lib "Kernel32" Alias _"GetWindowsDirectoryA" (ByVal lpBuffer As String, _ ByVal nSize As Integer) As Integer

Ahora podrá llamar a la función con el nombre más corto.

Dim RutaWin As StringRutaWin = String (145, chr(0))RutaWin = Left (RutaWin, DirWin(RutaWin, len(RutaWin)))



1.14 Interactuar con Word y Excel

¿Necesita algunas veces proporcionar la misma capacidad de análisis y cálculo que Microsoft Excel en sus aplicaciones de Visual Basic? O bien, quizá le gustaría dar formato a un documento con las herramientas de formato de Microsoft Word o almacenar y administrar datos con el motor de base de datos Microsoft Jet. Mejor aún, ¿no le gustaría poder crear o comprar componentes estándar para utilizarlos después en múltiples aplicaciones sin necesidad de modificarlos?

Puede conseguir todo esto y más si genera sus aplicaciones con componentes ActiveX. Un componente ActiveX es un fragmento reutilizable de código de programación y datos compuesto por uno o más objetos creados mediante la tecnología ActiveX. Las aplicaciones pueden utilizar componentes existentes, como los incluidos en las aplicaciones de Microsoft Office, componentes de código, documentos ActiveX o controles ActiveX (antes llamados controles OLE) que venden diversos proveedores. O bien, si dispone de la Edición profesional o de la Edición empresarial de Visual Basic, puede crear sus propios controles ActiveX.

En el caso de los componentes compatibles con la vinculación e incrustación de objetos, puede insertar objetos en su aplicación sin necesidad de escribir código, utilizando la interfaz visual del componente. Puede insertar en la aplicación un objeto activado para ActiveX utilizando el control contenedor OLE o agregando la clase del objeto al cuadro de herramientas.

La palabra “documento” del término “documento ActiveX” puede llevar a confusión. Aunque la génesis de los documentos ActiveX indica que un documento ActiveX de Microsoft Visual Basic es análogo a un documento de Word, al crear el primero la distinción entre un “documento” y una aplicación se difumina por completo. Aunque los documentos tradicionales (como los de Word) son estáticos, los documentos ActiveX no tienen por qué serlo. Con Visual Basic puede crear una aplicación completa con la semántica de un documento tradicional. Es decir, dispone de la funcionalidad de la aplicación, pero con la flexibilidad del comportamiento de un documento. Cuando un usuario abre un documento ActiveX, no sólo tendrá la funcionalidad completa de una aplicación, sino también la capacidad de conservar y distribuir “copias” de los datos intrínsecos a la aplicación. De este modo, el “documento” es realmente activo.

Una analogía: documento de Word = documento ActiveX

Los documentos ActiveX no son un concepto completamente nuevo. Probablemente ya esté familiarizado con los documentos de Word. Como sabe, un documento de Word no es lo mismo que la aplicación Word: el documento (con la extensión .doc) almacena el contenido real, mientras que la aplicación Word (Winword.exe) se utiliza para crear el documento.

Después de declarar una variable de objeto, debe asignar una referencia de objeto a la variable antes de poder utilizar las propiedades, métodos y eventos del objeto. Hay varias formas de asignar una nueva referencia de objeto:

• Si ha declarado la variable utilizando la palabra clave New, Visual Basic asignará automáticamente una nueva referencia de objeto la primera vez que utilice la variable.

• Puede asignar una referencia a un objeto nuevo en una instrucción Set utilizando la palabra clave New o la función CreateObject.

• Puede asignar una referencia a un objeto nuevo o existente en una instrucción Set utilizando la función GetObject.

Asignación de una referencia de objeto mediante la palabra clave New



Si el componente ActiveX proporciona una biblioteca de tipos, puede utilizar la palabra clave New en una declaración de variable o una instrucción Set para crear un nuevo objeto y asignar una referencia de objeto a una variable de objeto.

Si declara una variable de objeto con la palabra clave New, Visual Basic creará automáticamente un nuevo objeto la primera vez que utilice la variable. Para obtener más información al respecto, consulte "Declaración de una variable de objeto".

También puede utilizar la palabra clave New en una instrucción Set para asignar una referencia a un nuevo objeto de la clase especificada. Por ejemplo, las instrucciones siguientes asignan una referencia a un nuevo objeto de tabla DAO a la variable tdfOrders, estableciendo la propiedad Name de la tabla a "Pedidos":

Dim tdfOrders As DAO.TableDefSet tdfOrders = New DAO.TableDeftdfOrders.Name = "Pedidos"

Asignación de una referencia de objeto mediante CreateObject

Independientemente de que un componente ActiveX proporcione o no una biblioteca de tipos, puede utilizar la función CreateObject en una instrucción Set para crear un nuevo objeto y asignar una referencia de objeto a una variable de objeto. Debe especificar el identificador de programación del objeto como argumento para la función, y el objeto al que desea tener acceso debe ser de creación externa.

Para asignar una referencia de objeto utilizando CreateObject

• Utilice la sintaxis siguiente para CreateObject.

Set variable_objeto = CreateObject("Idprog")

El argumento Idprog suele ser el nombre de clase calificado del objeto que se está creando; por ejemplo, Word.Document. Sin embargo, Idprog puede ser diferente del nombre de clase. Por ejemplo, Idprog para un objeto de Microsoft Excel es "Sheet" en lugar de "Worksheet".

El ejemplo de código siguiente inicia Microsoft Excel (si Microsoft Excel no está ya en ejecución) y establece la variable xlApp para hacer referencia a un objeto de la clase Application. El argumento "Excel.Application" califica correctamente Application como una clase definida por Microsoft Excel:

Dim xlApp As Excel.ApplicationSet xlApp = CreateObject("Excel.Application")

Asignación de una referencia de objeto mediante GetObject

La función GetObject se utiliza normalmente para asignar una referencia a un objeto existente, aunque también puede utilizarla para asignar una referencia a un nuevo objeto.

Para asignar una referencia a un objeto existente, utilice la sintaxis siguiente:

Set variable_objeto = GetObject([nombre_ruta] [, Idprog])

El argumento nombre_ruta puede ser la ruta de acceso a un archivo existente, una cadena o se puede omitir. Si se omite, se requiere Idprog. Especificar la ruta de acceso a un archivo existente hace que GetObject cree un objeto utilizando la información almacenada en el archivo. Utilizar una cadena vacía para el primer argumento hace que GetObject actúe como CreateObject: creará un nuevo objeto de la clase cuyo identificador de programación sea Idprog. En la tabla siguiente se describen los resultados de utilizar GetObject.



Al igual que ocurre con CreateObject, el argumento "Word.Application" es el identificador de programación para la clase Application definida por Microsoft Word. Si están en ejecución múltiples instancias de Microsoft Word, no puede saber a que instancia hará referencia wdApp.

Importante También puede utilizar GetObject para asignar una referencia a un objeto en un archivo de documento compuesto. Un archivo de documento compuesto contiene referencias a múltiples tipos de objetos. Por ejemplo, un archivo de documento compuesto puede contener una hoja de cálculo, texto y mapas de bits.

El ejemplo siguiente inicia la aplicación de hoja de cálculo, si no está ya en ejecución, y abre el archivo Ingresos.xls:

Dim xlBook As Excel.WorkbookSet xlBook = GetObject("C:\Cuentas\Ingresos.xls")

Cuando haya terminado de utilizar un objeto, borre las variables que hagan referencia al objeto de forma que se pueda liberar el objeto de la memoria. Para borrar una variable de objeto, establézcala a Nothing. Por ejemplo:

Dim acApp As Access.ApplicationSet acApp = New Access.ApplicationMsgBox acApp.SysCmd(acSysCmdAccessVer)Set acApp = Nothing

Todas las variables de objeto se borran automáticamente cuando se salen del alcance. Si desea que la variable conserve su valor en todos los procedimientos, utilice una variable pública o de nivel formulario, o cree procedimientos que devuelvan el objeto. El código siguiente muestra como se utilizaría una variable pública:

Public wdApp Aas Word.Application...' Crea un objeto Word e inicia Microsoft Word.Set wdApp = New Word.Application...' Microsoft Word no se cerrará hasta que la' aplicación termine o la referencia se establezca a' Nothing:Set wdApp = Nothing

Tenga cuidado también de establecer todas las referencias de objetos a Nothing cuando termine, incluso las de objetos dependientes. Por ejemplo:

Dim xlApp As Excel.ApplicationDim xlBook As Excel.WorkbookSet xlApp = New Excel.ApplicationSet xlBook = xlApp.Workbooks.AddSet xlApp = Nothing ' ¡Cuidado! xlBook puede contener

' aún una referencia de objeto.Set xlBook = Nothing ' Ahora se han borrado todas

' las referencias.



En este ejemplo se ilustran los distintos usos de la instrucción AppActivate para activar una ventana de una aplicación. Las instrucciones Shell suponen que las aplicaciones están en las rutas especificadas. En Macintosh, se puede utilizar la función MacID para especificar la identidad de la aplicación, en lugar del nombre de ésta. La instrucción AppActivate está disponible para el sistema operativo de Macintosh System 7.0 o posterior.

Dim MyAppID, ReturnValue' En Microsoft Windows:AppActivate "Microsoft Word" ' Se activa Microsoft ' Word.

' AppActivate puede también utilizar el valor devuelto ' por la función Shell.MyAppID = Shell("C:\WORD\WINWORD.EXE", 1)' Se ejecuta Microsoft Word.AppActivate MyAppID ' Se activa Microsoft ' Word.

' También se puede utilizar el valor devuelto por la función Shell.ReturnValue = Shell("c:\EXCEL\EXCEL.EXE",1)' Se ejecuta Microsoft Excel.AppActivate ReturnValue ' Se activa Microsoft ' Excel.



1.15 Activar Animación en los procesos

El control Animation reproduce secuencias de vídeo AVI sin sonido. Una secuencia AVI está formada por una serie de marcos de mapas de bits, como una película.

Un ejemplo es la hoja de papel que “vuela” de una carpeta a otra al copiar archivos en el sistema Windows 95:

Aunque las secuencias AVI pueden tener sonido, cuando lo tienen no pueden utilizarse con el control Animation y se producirá un error si intenta cargar un archivo de ese tipo. Sólo puede utilizar secuencias AVI sin sonido. Para reproducir archivos .avi con sonido, utilice el control Multimedia (MCI).

Nota Encontrará diversos archivos .avi sin sonido en el directorio \Graphics\AVI del CD-ROM de Visual Basic.

En tiempo de ejecución, el control Animation no tiene un marco visible.

El control Animation mantiene un subproceso de ejecución independiente mientras se reproduce la secuencia. Por tanto, la aplicación no se bloquea y puede continuar la ejecución dentro de su proceso.

Aplicaciones posibles

• Crear cuadros de diálogo que informen al usuario de la duración y naturaleza de una operación.

• Reproducir sin sonido secuencias de vídeo informativas sobre la aplicación.

• Permitir a los usuarios reproducir los archivos colocados en el control.

Funcionamiento básico: métodos Open, Play, Stop y Close

Al utilizar el control, el archivo .avi se abre con el método Open, se reproduce con el método Play y se detiene con el método Stop. Una vez terminada la reproducción de un vídeo, puede utilizar el método Close para cerrar el archivo. No es necesario cerrar un archivo para poder abrir otro.

En el código siguiente se utilizan dos controles CommandButton, cmdPlay y cmdStop, y un control CommonDialog llamado dlgOpen. Como título de cmdPlay, establezca “Abrir y reproducir”. El título del control CommandButton cmdStop es "Detener".

Private Sub cmdPlay_Click()' Configura un control CommonDialog para permitir ' al usuario buscar archivos .avi y reproducirlos.' El control CommonDialog se llama "dlgOpen". El ' control Animation se llama "anmAVI".dlgOpen.Filter = "archivos avi (*.avi)|*.avi"dlgOpen.ShowOpenanmAvi.Open dlgOpen.FileNameanmAVI.Play

End Sub

Este código detiene la reproducción del vídeo:

Private Sub cmdStop_Click()anmAVI.Stop



End Sub

Argumentos del método Play: repeat, start y stop

El método Play tiene tres argumentos, repeat, start y stop, que determinan el número de veces que se reproduce un archivo, en qué marco comienza la reproducción y dónde se detiene el archivo.

Si no se especifica el argumento repeat, el archivo se reproducirá continuamente. Por ejemplo, el código siguiente reproducirá un archivo continuamente hasta que el usuario haga clic en el botón cmdStop:

Private Sub cmdPlay_Click()dlgOpen.Filter = "archivos avi (*.avi)|*.avi"dlgOpen.ShowOpenanmAVI.Open dlgOpen.FileName' Reproduce el archivo indefinidamente.anmAVI.Play

End Sub

Private Sub cmdStop_Click()anmAVI.Stop

End Sub

El código siguiente reproduce el archivo diez veces, desde el marco sexto al decimosexto (el primer marco es el 0):

anmAVI.Play 10, 5, 15

Reproducción automática de archivos con la propiedad AutoPlay

Si la propiedad AutoPlay se establece a True, el control comenzará a reproducir un archivo en cuanto se haya cargado. Por el contrario, para que no se reproduzca el archivo, establezca la propiedad AutoPlay a False, como se muestra en el código siguiente:

Private Sub cmdPlay_Click()' Si establece a True la propiedad AutoPlay, se ' reproduce el archivo al cargarlo. Por eso no es ' necesario el método Play.dlgOpen.Filter = "archivos avi (*.avi)|*.avi"dlgOpen.ShowOpenanmAvi.AutoPlay = TrueanmAVI.File = dlgOpen.FileName

End Sub

Private Sub cmdStop_Click()' Establece AutoPlay a False para detener la ' reproducción.anmAVI.AutoPlay = False

End Sub

Centrado del área de reproducción con la propiedad Center

Puede especificar si desea o no centrar el vídeo en el control mediante la propiedad Center. Cuando el valor de esta propiedad es False, el control cambia automáticamente de tamaño en tiempo de ejecución para ajustarse al tamaño del vídeo. En tiempo de diseño, los bordes izquierdo y superior del control definen el área donde se mostrará el vídeo, de esta forma:



Cuando el valor de la propiedad Center es True, el control no cambia de tamaño, sino que el vídeo se muestra en el centro del área definida por el control, de esta forma:

Nota Si el área definida por el control en tiempo de diseño es menor que el vídeo, se recortarán los bordes de éste.



2 Desarrollo de aplicaciones bajo el modelo C/S

2.1 Modelo cliente / Servidor.

Podemos decir que en la arquitectura cliente/servidor existe en procesos separados que residen en plataformas diferentes, e interactúan por medio de una red.

UNA PLATAFORMA ES UN CONJUNTO FORMADO POR :

• Hardware

• Software (Sistema Operativo)

• Software de Subsistema (Manejador de Base de Datos)

• Software de AplicaciónEXISTEN DIFERENTES TIPOS DE PLATAFORMAS

• Mainframe o Minis enlazadas:

Funciona como servidor gigante de archivos o servidor de base de datos, manejan aplicaciones tanto batch como interactivas y la interface con el usuario es tipo carácter, además que son equipos propietarios.

• Minis o Workstation de alto desempeño :

Dan servicio a nivel departamental, pero a diferencia de las workstations, las microcomputadoras son equipos propietarios y también manejan aplicaciones tanto batch como interactivas

• Microcomputadoras:

Existe una gran base instalada en ellas

La Arquitectura cliente/servidor pertenece a un Modelo Distribuido.

MODELO DISTRIBUIDO

Este esquema puede ser definido formalmente como aquel en el cual múltiples procesadores autónomos, posiblemente de diferentes tipos, están interconectados por una red de comunicación para interactuar entre sí, con la finalidad de llevar a cabo tareas de procesamiento común. Para alcanzar está meta los sistemas son integrados lógicamente en varios grados por sistemas operativos para procesamiento distribuido y aplicaciones distribuidas, tales como bases de datos distribuidas. Sin embargo, el esquema no sólo incluye procesadores y sistemas operativos, en un concepto más general el modelo distribuido es capaz de integrar los más diversos equipos periféricos, aplicaciones, tecnologías de diseño de redes y herramientas de administración.



Entre las características más relevantes de este modelo se encuentran:

• Soporte para un número arbitrario de sistemas y aplicaciones.• Diseño modular de la arquitectura física.• Uso de sistemas operativos y aplicaciones para procesamiento distribuido.• Soporte de terceros tanto en hardware como en software.

Mientras que algunos de los beneficios que se derivan de adoptar el modelo, son:

• Incremento de desempeño.• Incremento de la confiabilidad y disponibilidad.• Modularidad y control local.• Costos reducidos y un alto grado de confiabilidad.

INFRAESTRUCTURA

Basado primordialmente en redes de computadoras, el modelo de cómputo distribuido, utiliza todos los recursos y capacidades de éstas como la herramienta principal de su infraestructura, para comunicar a los diferentes recursos que se verán involucrados en el esquema.

Dada la rápida evolución de tecnologías en el campo de la computación, así como en el de las comunicaciones, la red de computadoras que se utilizará para implantar el esquema, como ya se había mencionado, requiere de ser lo suficientemente robusta, eficiente y adaptable a nuevas tecnologías, con la finalidad de garantizar la continuidad del modelo.

El esquema distribuido no sólo permite la integración de las más variadas tecnologías de diseño y construcción de procesadores y periféricos, sino también de las diferentes tecnologías de diseños de redes. Permitiendo de ésta forma, integrar redes de comunicaciones ya existentes dentro de una organización al modelo, que representa una ventaja sobre el esquema centralizado, sin embargo, resulta conveniente que la red a utilizarse sea realmente eficiente, dado que los resultados del modelo dependerán en gran medida de ésta.

Dadas las facilidades de integración de tecnologías de redes y equipos, la infraestructura del modelo distribuido puede ilustrarse, como se muestra en la siguiente figura.



C H I H U A H U A

W O R K S T A T I O N

S O N O R AC D .C A R M E N


C D . D E M E X I C O

T E R M I N A L

T E R M I N A L

W O R K S T A T I O N W O R K S T A T I O N





MANEJO DE INFORMACION

Al igual que se distribuyen equipos de cómputo y periféricos, la información se halla distribuida a lo largo de toda la organización, encontrándose en aquellos lugares donde comúnmente es utilizada, donde sin embargo, no importando su localización, cualquier persona puede tener acceso a ella.

A diferencia del modelo centralizado, la información bajo este esquema conserva las características de oportunidad y rapidez, ya que las consultas se harán normalmente a bases de datos locales. Sin embargo dado que la información generalmente es procesada en forma distribuida y pese a que las herramientas para su manejo empleen complejos algoritmos de validación de datos, ésta es susceptible de perder características como consistencia y confiabilidad.

Con este esquema, el usuario final tiene también la posibilidad de acceder a diversos bancos de información, que existen alrededor del mundo, y la consulta a estos se efectúa a través de aplicaciones y herramientas capaces de manipular la información contenida en ellos, sin importar su localización geográfica. Entre las fuentes externas a las cuales se puede acceder para obtener información actualizada y oportuna, se encuentran diversas redes de computación públicas y privadas que existen alrededor del mundo, destacando entre ellas Internet que es la red más grande e importante, que cuenta entre sus miembros a universidades, instituciones de investigación, agencias gubernamentales e instituciones privadas. Herramientas para consultar estas fuentes, comúnmente permiten una fácil interacción con el usuario, al contar con interfaces amigables que harán del proceso de adquisición de información una tarea sencilla para cualquier persona.

PROCESAMIENTO

Nuevos conceptos que han sido integrados a sistemas operativos, así como complejos mecanismos de comunicación entre computadoras a través de una red, permitiendo llevar a cabo el procesamiento de grandes cantidades de datos y complejos algoritmos utilizando para ello múltiples procesadores, que pueden ser de diferentes tipos y encontrarse distribuidos a lo largo de la organización, esta forma de procesar datos, conocida como procesamiento distribuido, es totalmente transparente el usuario final ya que serán los sistemas operativos y aplicaciones los que llevarán a cabo la distribución y control de todas las tareas que esto implique, entre aquellos sistemas que se dispongan para ese efecto dando la apariencia de que todas las operaciones necesarias las está llevando a cabo un solo procesador.

Dado que el procesamiento distribuido sería llevado a cabo por diversos procesadores utilizando como medio de comunicación la red de cómputo, está deberá ser lo suficientemente confiable para que el procesamiento puede efectuarse, pues se requerirá de llamadas y peticiones de control entre todos aquellos procesadores que estén participando en el procesamiento.



SERVICIOS

Sustentar el modelo distribuido en redes de computadoras, permite ofrecer al usuario final una amplia gama de servicios basados en la utilización de aplicaciones que operan bajo la red de cómputo instalada, entre ésta variedad de facilidades se encuentran algunas que para el usuario final revisten vital importancia, como lo es el caso del correo electrónico, ya que éste adquiere gran relevancia cuando la organización pasa a formar parte de algunas de las redes existentes alrededor del mundo. Bajo estas circunstancias, el correo electrónico proporciona mayores beneficios en relación con otros medios de comunicación tradicionales tales como mensajería, fax, telefonía, ya que el usuario no sólo tendrá la posibilidad de entablar comunicación con personas de su organización, sino que también le será posible hacerlo con otras personas e instituciones de forma segura y eficiente, no importando en que lugar del mundo se encuentren.

Otro servicio que reviste igual importancia es la transferencia de información, el modelo cuenta con herramientas eficientes y confiables para transferir información entre sitios remotos sin importar que tipo de información deba transferirse, abarcando desde artículos periodísticos, reportes de clima, imágenes sobre condiciones atmosféricas hasta archivos de aplicaciones guardados bajo formatos especiales.

Compartir equipos periféricos, tales como impresoras y graficadores de alta calidad y desempeño es una tarea que se facilita tanto para los administradores como para los usuarios finales, haciendo uso de la red de cómputo éstos podrán ser utilizados por todo aquel personal que así lo requiera, sin considerar donde se localicen los recursos. La integración y distribución de recursos en el modelo se efectúa mediante sistemas operativos y aplicaciones, las cuales una vez configuradas permitirán al usuario hacer uso de aquellos recursos que le sean más convenientes o adecuados al momento de requerirlo en forma transparente.

Dada la veracidad del modelo distribuido, integrar recursos y servicios no previstos, no implicará rediseñar o modificar totalmente la estructura del modelo, sólo se requerirá variar configuraciones en sistemas operativos y aplicaciones. Integrar nuevos equipos periféricos no implicará contar con un distribuidor o fabricante único, periféricos de terceros pueden ser empleados sin ocasionar problemas de compatibilidad y sin recurrir a gastos excesivos.

ADMINISTRACION

Una de las tareas más importantes para alcanzar las metas previstas cuando se utiliza cómputo distribuido, lo constituye la administración de su infraestructura. En este esquema donde el uso exhaustivo de una red de computadoras es común, la administración de este recurso ocupa un lugar primordial, contar con las herramientas adecuadas, así como con el personal capacitado, garantizará el correcto desempeño y funcionamiento de cada una de las partes que forman la red de cómputo. Herramientas comunes son aplicaciones que utilizan protocolos especialmente diseñados para monitorear el estado actual de la red y dar al administrador una idea precisa de cual es el problema y en que parte éste está ocurriendo, para así poder tomar decisiones sobre una solución rápida y adecuada, además



de contar con un equipo de personal especializado, permitirá dar pronta solución a problemas técnicos en la infraestructura de la Red.

MODELO COOPERATIVO

Es una variante de los sistemas distribuidos, el modelo cooperativo que consiste cuando el procesamiento de la aplicación se ejecuta en la plataforma óptima de hardware.

El termino Proceso Cooperativo, es una definición literal, implica los componentes individuales, en lo que aplicaciones se refieren, es cuando diferentes aplicaciones de las mismas se llevan a cabo en varias computadoras de la red y estas son transparentes para el usuario.

Proceso dela Aplicación

Parte deProceso

Parte deProceso

Resultados

Estación A

Estación B

Proceso Cooperativo.

Existen tres tipos de procesos para el Modelo Cooperativo, que son : Peer-to-peer, RPC y Cliente/Servidor.

CLIENTE/SERVIDOR

En un sistema Cliente/Servidor, uno o más clientes y uno o más servidores, juntos con el sistema operativo y los protocolos de comunicación, conforman el ambiente que permite y facilita el computo distribuido.

En una aplicación basada en esta arquitectura existen dos procesos independientes, en lugar de uno solo. De esta forma se puede repartir el trabajo a través de varias computadoras en una red. Estos dos procesos, el cliente y el servidor, se comunican mediante un protocolo bien definido. Esta técnica modular permite la comunicación entre distintas computadoras (Servidor de archivos, estaciones de trabajo con alta calidad de graficación, etc ), para que cada uno de ellos se dedique a realizar el trabajo que realiza mejor.



De manera introductoria, se puede decir que un servidor es un sistema o un programa en un sistema que provee de algún servicio a otros sistemas a través de una Red. Un ejemplo típico es un servidor de archivos, que permite el acceso a información remota a cualquier usuario a través de la red. Un cliente es un sistema o un programa que requiere y recibe alguna acción de un servidor.

Existen varias interpretaciones acerca de la definición exacta de que es la computación Cliente/Servidor y en vez de discutir una definición precisa mejor discutiremos las características que debe cumplir.

Básicamente la arquitectura Cliente/Servidor es aprovechar la computación que esta en procesos separados sobre separadas plataformas, interactuando una con otra permitiendo el aprovechamiento de recursos, mientras toman la mejor ventaja de los diferentes dispositivos.

Si bien no existe una definición precisa de Cliente/Servidor que sea aceptada por el ámbito informático, si existen diez características que debe cumplir. Las cinco primeras son aceptadas como obligatorias y las cinco restantes como opcionales, precisando aún más como deseables, las cuales son:

1La arquitectura Cliente/Servidor, consiste en un proceso cliente y un proceso servidor, distinguiéndose uno de otro, sin embargo pueden interactuar conjuntamente.

2La parte del cliente y la del servidor, pueden operar en plataformas diferentes y esto generalmente ocurre, pero no necesariamente.

3La plataforma del cliente o del servidor, puede ser actualizada sin que esto implique actualizar ambas.

4El servidor dispone de servicios múltiples de concurrencia de clientes, en algunos sistemas el cliente puede tener acceso a múltiples servicios.

5El sistema Cliente/Servidor incluye capacidad de administración de la red.

6Una parte significativa (en algunos casos, no todos) de aplicaciones lógicas, residen en el cliente.

7Usualmente la acción es iniciada por el cliente final y no por el servidor final, sin embargo, servidores de base de datos pueden tomar acciones basados en disparadores, como una política de la organización o proceso almacenado.

8Una interfaz gráfica amigable GUI (Graphical User Interface), generalmente reside en el cliente.

9La capacidad de un lenguaje estructurado de consulta (SQL), es característica de la mayoría de los sistemas Cliente/Servidor.

10El servidor de base de datos, debe proveer seguridad y protección de datos.



DESCRIPCION FUNCIONAL

De manera general, para iniciar la comunicación entre un cliente y un servidor es necesario establecer una sesión. Por lo tanto, el servidor debe estar esperando ó escuchando que algún cliente trate de establecer una sesión, esto quiere decir que un cliente trate de “hablar” pero si no es “escuchado” la comunicación fracasará. Es muy posible que por algún momento el servidor también “hable” y que el cliente “escuche”, pero esto sólo ocurrirá cuando el servidor así se lo indique al cliente.

Un servidor también se reserva el derecho de establecer comunicación con uno o más clientes. Así, el servidor se encargara de atender a cada cliente y establecer los mecanismos que seguirá para la distribución de sus servicios. Un servidor define operaciones que son exportadas a los clientes, los clientes invocan estas operaciones para que el servidor controle el manejo de datos.

Típicamente, una aplicación cliente comenzará una transacción, ejecutará una o varias operaciones en el servidor y terminará la transacción. Lógicamente, los servidores están estructurados como un ciclo infinito. El servidor simplemente recibe los requerimientos de los clientes para invocar operaciones en favor de esas transacciones. Para implantar las operaciones que exporta, el servidor puede requerir de otro servidor o puede manipular sus propios datos.

Bajo este esquema, se reparte el proceso de una aplicación entre un front-end (Cliente) y un back-end (Servidor), cuyas funciones se distinguen como se muestra a continuación:

FRONT-END BACK-END

PROGRAMA DE APLICACIÓN

SERVIDOR DE BASE DE DATOS- Diseño de formas - Almacenamiento

- Presentación - Seguridad

- Lógica de la aplicación - Administración de datos

- Manejo de datos - Selección de registros

- Consultas - Reorganización de la BD

- Menús - Indexación

- Utilerías - Ordenamientos

- Actualizaciones en lote

Comparación de funciones: Front-end vs Back-end.

SISTEMAS ABIERTOS “OPEN SYSTEM”

Muchas organizaciones han instalado una variedad de plataformas, y en cada una de ellas manejan información necesaria para la vida de las organización. El reto de los sistemas abiertos y con ellos los estándares, está en hacer que estas diferentes plataformas trabajen de manera conjunta.



Los estándares permiten mejorar la compatibilidad, dejan mayor libertad al usuario para elegir lo que más convenga a sus necesidades tanto de hardware como de software, permite explotar nuevas tecnologías y generan un ambiente de competencia tanto en precios, como en el desempeño en el mercado.

Un sistema abierto es aquel basado en un ambiente independiente a fabricantes, cuyas especificaciones son aceptadas, disponibles y estandarizadas. En estos sistemas los usuarios pueden mezclar hardware y software de diversos fabricantes en redes muy diversas. Los sistemas abiertos son de crucial importancia en el ambientes de computo distribuidos ya que estos son construidos con sistemas de diversos proveedores de computadoras, redes, manejadores de base de datos y aplicaciones.

A pesar de que los estándares de programación y de comunicaciones han evolucionado por décadas, UNIX de AT&T fue el primer sistema operativo que funciono en diversas plataformas con éxito, permitiendo escalabilidad, portabilidad e interoperabilidad, como ventajas características.

Interoperabilidad Significa que dos sistemas pueden trabajar conjuntamente a través de interfaces bien definidas, por ejemplo, una aplicación desarrollada en el sistema operativo UNIX puede interactuar con aplicaciones para los sistemas operativos OS/2 y MVS. Estas aplicaciones deben tener interfaces que permiten intercambiar información.

Portabilidad Significa que las aplicaciones deben ser independientes de las plataformas, de tal manera que cambios que sufran las plataformas existentes no signifiquen modificaciones a las aplicaciones. Las aplicaciones desarrolladas en una plataforma deben ser transportadas y utilizables en otras plataformas.

Integración Se refiere a la facilidad con la cual un sistema puede ser usado. Un sistema integrado básicamente minimiza el esfuerzo necesario para utilizarlo.

Los estándares son necesarios para hacer a los sistemas abiertos una realidad. Un gran número de estándares han sido desarrollados para cumplir con interoperabilidad, portabilidad e integración. Estos estándares son desarrollados por la ISO (International Standard Organization). Los estándares TCP/IP y XWindows son claros ejemplos de sistemas abiertos.

INFRAESTRUCTURA DE SOFTWARE CLIENTE/SERVIDOR

El término Cliente/Servidor, en primera instancia es un termino complejo y abstracto, de la misma forma tanto las empresas de computo, como los



especialistas en sistemas hacen referencia a él, como un modelo o como una arquitectura.

En un sentido estricto, de acuerdo a la definición del diccionario:

MODELO. “Es un objeto que se reproduce o se imita. Representación de alguna cosa en pequeña escala. Técnicamente es la construcción de una o varias piezas para hacer el molde en el cual se vaciarán los objetos”.

En tanto que:

ARQUITECTURA. “Arte de proyectar, construir y adornar. Forma, estructura”Por lo tanto Cliente/Servidor, es la conjunción de varias piezas que primeramente se diseñarán a escala para posteriormente reproducirse como un esquema digno de imitarse, Pero, ¿dónde esta la interconexión de componentes?. Desde luego, que aquí entra la infraestructura de comunicación entre los elementos o piezas adicionales a su ubicación para construir el sistema.

Podemos decir que la Infraestructura Cliente/Servidor es la integración distribuida y abierta de un sistema en red, con los recursos, medios y aplicaciones, que definidos modularmente en los servidores, administran, ejecutan y atienden peticiones de los clientes, todos interrelacionados física y lógicamente, compartiendo datos, procesos e información, estableciendo así un enlace de comunicación transparente entre los elementos que conforman la estructura.

Los elementos que conforman la estructura Cliente/Servidor son : El Cliente, El Servidor y Software De Comunicación.

CLIENTESoftware de

ComunicaciónSERVIDOR

Estructura básica de la arquitectura Cliente / Servidor.

Una idea simple de la computación Cliente/Servidor es, que el servidor acepta requerimientos de datos de un cliente y retorna los resultados a éste. El cliente manipula los datos y presenta los resultados al usuario.

La computación cliente/servidor no se basa solo en los componentes del hardware, sin menospreciar sus cualidades, lo que hace posible esta tecnología es el software. Al dividirse las tareas entre el cliente y el servidor, pueden ser procesadas en diferentes: plataformas, Sistemas Operativos y Protocolos de Comunicación, teniendo como resultado un desarrollo más rápido de la aplicación donde están envueltas. Entonces el usuario podrá accesar los datos con una interfaz gráfica agradable, que despertará su interés e invitación y sin la necesidad de capacitaciones exhaustivas.



EL CLIENTE: Es un consumidor de servicios provistos por uno o más servidores (acceso a la base de datos, servicio de impresión, correo electrónico). desarrolla parte y en ocasiones toda la lógica de aplicación, brinda servicios de presentación al usuario a través de una interfaz gráfica.

EL SERVIDOR: Es diseñado con el objetivo de dar servicio, sus capacidades de hardware son mayores a las del cliente, generalmente, a través del DBMS que radica en él, puede recuperar, actualizar y almacenar los datos. Administra los recursos de la red, dispositivos y demás servicios con los que cuente.

SOFTWARE DE COMUNICACIÓN: Por medio de él se realiza la comunicación entre el cliente y el servidor, administra el flujo de datos a través de la red, permite la comunicación hacia otros sistemas (por medio de ruteadores, puentes y gateways). Es responsable de detectar problemas y recuperación de datos por coaliciones.

Una aplicación envuelve varias tareas las cuales pueden ser llevadas a cabo en el modulo cliente o el del servidor, con el fin de entender mejor como se realiza una aplicación la dividiremos en seis tareas, las cuales son :

1. INTERFACE PARA EL USUARIO. Cuenta con un dispositivo que acepta entradas del usuario y las despliega en la lógica de presentación. Este dispositivo puede simplemente desplegar caracteres recibidos de un teclado o un dispositivo que reciba señales de un mouse.

2. LÓGICA DE PRESENTACIÓN. Controla la interacción entre el usuario y la computadora. Esta es la especificación que el usuario realiza cuando selecciona un menú de opciones, un botón de selección o escoge un elemento de una lista.

3. LÓGICA DE APLICACIÓN. Es una colección de decisiones, cálculos y operaciones que la aplicación puede llevar a cabo. Esta puede incluir los cálculos del pago a empleados, la decisión de aceptar una orden de compra, la evaluación de cargar una aplicación o el procedimiento de realizar una transacción la cual ha sido transferida.

4. LÓGICA DE DATOS. Es la expresión de las operaciones desarrolladas en la base de datos que son necesarias para realizar la lógica del negocio. Como la mayoría de los manejadores de bases de datos se basan sobre el modelo relacional, las expresiones son instrucciones en SQL como el Select, Insert y Update.

5. SERVICIO DE DATOS. Son las acciones que el DBMS toma para realizar la lógica de datos, incluyendo la manipulación, la definición y la transacción de los mismos. Para manipular datos el DBMS típicamente compila las instrucciones en SQL.



6. SERVICIO DE ARCHIVOS. Accesa el disco y trae los bits que se convierten en datos cuando son vistos a través del DBMS. Los servicios de archivos son usualmente realizados por funciones del sistema operativo.

En el ambiente Cliente/Servidor, una aplicación se puede almacenar, dentro de los clientes, en los servidores o parcialmente en ambos dependiendo de las características y capacidad del equipo, así como de las necesidades particulares en cuanto al acceso a datos e información; de esta manera, es responsabilidad del área de Sistemas así como de los diseñadores de la red, definir "desde la etapa de Planeación", cómo serán estructuradas las aplicaciones y componentes dentro del sistema en red.

A continuación se muestra una clasificación de alternativas, para organizar las aplicaciones sobre la base del acceso a la información como se muestra a continuación.

Presentación Distribuida: Se separan los datos, procesos y presentación en el servidor y solo una parte de la presentación se ejecuta en el cliente. Donde varios usuarios pueden accesar los mismos datos desde los diferentes servidores y cada uno visualiza exclusivamente la información que solicita. Por ejemplo. la consulta e impresión de las listas de proveedores que maneja el Departamento de Compras de la empresa, adicionándole los datos personales del usuario. Este tipo de estructura hace uso del poder gráfico de los clientes y permite compartir las aplicaciones existentes.

Presentación Remota: Se concentran los datos y procesos en el servidor y la presentación se ejecuta en el cliente. Aquí se aprovechan las capacidades particulares de cada cliente, de tal manera que el usuario por su parte, puede accesar los datos que requiera, manipularlos con sus propias herramientas creando y/o modificando libremente la presentación y salida de la información. Por ejemplo, un vendedor de seguros realiza una consulta a la base de datos (servidor) de las diferentes primas que se tienen registradas para los automóviles modelo 94, al visualizar la información, utiliza su procesador de textos para una mejor presentación y así obtiene los reportes requeridos.

Función Distribuida: Se tienen los datos y procesos en el servidor, pero parte de los procesos conjuntamente con la presentación, se ejecutan con los recursos propios del cliente. Aquí el principal aspecto es el uso y manejo de ciertas subrutinas y/o programas dentro de lo servidores, mismas que pueden ser utilizadas tantas veces como sean requeridas, sin tener que reescribirlas o particularizarlas para cada cliente. Por ejemplo, se puede solicitar la consulta de las cifras de ventas por los últimos dos trimestres, a las diferentes subsidiarias (bases de datos), dónde internamente se efectúa un proceso de selección de datos, el concentrado de información se recibe en el servidor local y a su vez el cliente ejecuta el proceso correspondiente para obtener los



datos de su empresa, así mediante ciertas instrucciones predefinidas conjunta la información y obtiene el informe requerido.

Acceso Remoto de Datos: Los datos se almacenan en el servidor, de esta forma los procesos y la presentación se ejecutan desde el cliente. Básicamente es el modo de acceso utilizado en el software de correo electrónico, dónde se solicitan consultas de información a bases de datos remotas, de la misma forma que se recibe y se envía información de otros clientes. Por ejemplo, consultas a las bibliotecas de las diferentes universidades nacionales y del extranjero.

Base de Datos Distribuida: Todos los datos se concentran en los servidores, pero cierta porción de información así como los procesos y presentación se accesan con los recursos del cliente. Este tipo de estructura permite la comparación de datos a cualquier nivel dentro de la empresa, dónde cada usuario puede manipular la información de su área o departamento y compartirla con la de otros en forma simultánea. Por ejemplo, una empresa puede tener una base de datos única dónde concentre la información relacionada a las existencias en almacén de sus productos, de tal forma que las altas, bajas y cambios se efectúan en línea y al ser consultadas por cualquier persona dichas modificaciones se visualizan por todos los demás usuarios.

Manejo deDatos

Logica deAplicación

Lógica dePresentación


Manejo deDatos



Manejo deDatos




Manejo deDatos



Manejo deDatos

LógicaPresentación


Manejo deDatos

RED

RED

SERVIDOR

CLIENTE

PresentaciónDistribuida

PresentaciónRemota

FunciónDistribuida

AccesoRemoto de

Datos

Dase deDatos

Distribuida

División de un procesos del Cliente y del Servidor .



EL CLIENTE

Características del Cliente:

• Es el medio de enlace y/o comunicación entre el usuario y el computadora.• Es la entidad que requiere o solicita el servicio.• Requiere el uso de los recursos del computadora para realizar cualquier

actividad.• Es el medio por el cual se envía la solicitud y se reciben los resultados o

notificaciones del servidor.• Contiene la interface gráfica (GUI).• Puede interactuar con uno o varios servidores.• Es el responsable de mantener el diálogo con el usuario.• Su costo comparado con un servidor es considerablemente más bajo.

Funciones principales del Cliente :

• Inicia y termina la solicitud.• Permite el manejo de la pantalla y ventanas.• Presenta la información y/o datos.• Interpreta los comandos.• Maneja procesos de ayuda.• Recibe las entradas provenientes del mouse , teclado y touch-screen.• Permite controlar las cajas de diálogo.• Habilita el manejo de multimedia (si es el caso).

EL SERVIDOR

Es la entidad física que provee un servicio, se encuentra la ejecución de procesamiento de datos, aplicaciones, manejo de la información y recursos. En el reside el BACK-END, que es la parte destinada a recibir las solicitudes del cliente y donde se ejecutan los procesos.

Un servidor es considerado, por muchos, como la conjunción de Hardware y Software que ejecuta tareas específicas.

Sus principales características son:

• Responde a las peticiones de los clientes.• Tiene gran capacidad de almacenamiento y rapidez.• Provee el uso de los recursos y servicios a los clientes.• Es el administrador de los recursos de la red• Tiene capacidad de procesamiento transaccional.• Puede actuar como cliente de otros servidores.• Contiene los datos, programas, aplicaciones, software e información.• Realiza procesos como accesar, organizar, almacenar, actualizar y manejar

datos o recursos compartidos.

SOFTWARE DE COMUNICACIÓN



Algunos profesionales del ámbito informático, utilizan el termino “Middleware”, el cual crea más confusión que contribución, ya que es usado indistintamente. Utilizaremos el término software de comunicación, para describir las capacidades de comunicación entre el cliente y el servidor.



LA RED

La arquitectura de la red define los protocolos, formato de los mensajes y estándares que se usarán. Una arquitectura de red robusta usa una estructura de capas, cada capa consiste en entidades compuestas por hardware y procesos de software, las normas y formatos para comunicación entre capas adyacentes son colectivamente llamadas una interface. Los protocolos son las normas y formatos para comunicación dentro de la misma capa, a través de diferentes dispositivos, incluyen formatos y el orden de los datos para su intercambio y cualquier acción para la transmisión y recepción de datos

El sistema operativo es el corazón y alma de la red. El hardware del sistema proporciona las trayectorias de datos y las plataformas en la red, pero el sistema operativo es el encargado de controlar todo lo demás. La funcionalidad, la facilidad de uso, el rendimiento, la administración. la seguridad de los datos y la seguridad de acceso, dependen del sistema operativo.

Actualmente existen en el mercado varios sistemas operativos de red, cada uno tiene su forma de operar, proporcionando mayor seguridad unos que otros, por lo cual, cada uno tiene una participación diferente en el mercado; no obstante, una de las direcciones más claras para el desarrollo de sistemas futuros es hacia estrategias similares de diseño.

BONDADES Y DESVENTAJAS

De lo expuesto se resume que, el ambiente Cliente/Servidor ofrece las siguientes ventajas:

• Permite la integración de los recursos y elementos del sistema en red.• Incrementa aún mas la productividad y el desempeño de la red.• Permite el uso y comparación de los sistemas y recursos

interconectados.• Incrementa la velocidad de respuesta al usuario.• Evita el sustituir totalmente los equipos instalados.• Permite el ensamble de las aplicaciones heredadas (legancy systems)

ya existentes con las aplicaciones y software que se están desarrollando.

• Permite la integración abierta en plataformas multivendor.• Reduce los costos de mantenimiento de software.• Agiliza el tráfico en la red y tiempos de respuesta.• Mejora la administración y el control de los procesos y recursos en red.• Propicia un ambiente para la implantación de nuevas tecnologías.• Incrementa el nivel de calidad y obtención de información.• Reduce tangiblemente los costos del sistema una vez implantado la

arquitectura Cliente/Servidor.



Dentro de un ambiente idóneo y "perfecto" como el que se vislumbra bajo ésta arquitectura, también es importante mencionar su lado gris, las principales desventajas son:

• La migración e implantación es costosa ya que se requiere de servidores poderosos, equipos y recursos.

• Requiere necesariamente de una infraestructura de comunicación en red.

• Se requiere de software y aplicaciones adicionales a las ya existentes como parte del software de comunicación para conformar el nuevo sistema.

• Las aplicaciones para Cliente/Servidor son en ocasiones más complejas que las convencionalmente utilizadas.

• Aún no existen estándares específicos y reconocidos universalmente que reglamenten esta arquitectura.

Sin embargo, conforme la arquitectura vaya madurando seguramente estos puntos dejarán de ser desventajas, puesto que los expertos ya trabajan sobre ello para desarrollar los productos que cubran dichas deficiencias.



2.2 Que es ODBC

Lo que dice Microsoft:ODBC (Conectividad abierta a bases de datos)

La tecnología proporciona una interface común para acceder bases de datos heterogéneas basadas en SQL. ODBC esta basado en el lenguaje Estructurado de consultas (SQL) como una norma para acceder a los datos. Esta interface proporciona interoperabilidad al máximo: no solo la aplicación puede acceder bases de datos de diferentes Sistemas basados en SQL, a través de un juego común de código. Esto le permite a un diseñador construir y distribuir una aplicación cliente/servidor sin tener un DBMS específico. Se agregan drivers para unir la aplicación, a la base de datos destino, con el fin de que el usuario elija el DBMS deseado.

La flexibilidad de ODBC se caracteriza por:

ODBC esta diseñado con la interface de nivel de llamadas estándar de la ISO

No se atan aplicaciones a un propietario API.

Las declaraciones SQL pueden ser incluidas explícitamente en código fuente o construidas en tiempo de ejecución de la aplicación.

Una aplicación puede ignorar los datos subyacentes de los protocolos de comunicaciones.

Pueden enviarse y recibirse datos en un formato conveniente a la aplicación.

Existen más de 55 drivers para accesar a las bases de datos más populares.



Lo que pienso:

ODBC es un intermediario entre bases de datos y aplicaciones, cuya tarea es sostener una conversación de preguntas y respuestas entre dos "sujetos" que no hablan el mismo idioma y que gestionan sus recursos de forma diferente, esto es una abstracción de un concepto muy tecnificado. Concretando, puedes tener un CAD, una hoja de calculo, un editor de texto, etc., cuyas finalidades son las que quieras, menos gestionar datos en la forma que lo hace un sistema de base de datos; estas aplicaciones no saben como se obtienen y se guardan datos en, por ejemplo, un archivo MDB de Microsoft Access, o en un DBF, o en SQL Server, o en algún otro. Por otra parte, pero en lo mismo, que tal si un usuario de Paradox quiere extraer información de SQL Pato, un nuevo sistema de lo más avanzado que nadie conoce pero que alguien uso para guardar información que resulta necesaria (no sabes cuántas veces sucede), ambos son sistemas de bases de datos, Paradox conoce la forma de leer los archivos de los sistemas conocidos, pero no los de SQL Pato.

En el ambiente Windows, Microsoft creó la tecnología ODBC pensando en este problema. No es una solución de la comunidad informática del orbe, es de Microsoft, y por eso se basa en los impulsos estomacales del corazón de Microsoft; esto quiere decir que no se esta recomendando esta tecnología, sino que mientras sea en Windows, hay que usarla cuando no hay algo mejor, punto. ODBC es una utilería que alberga controladores. La utilería sirve para gestionar los controladores, y los controladores son los que saben "hablar" con las bases de datos. Entonces el "acuerdo" entre Microsoft y los fabricantes de software para Windows fue: "Ustedes, que hacen software no especifico para bases de datos, enseñen, si quieren, a sus aplicaciones a comunicarse con el armatoste llamado ODBC; y ustedes, fabricantes de bases de datos, hagan controladores de sus sistemas para ponerlos en la utilería, si quieren que otras aplicaciones puedan accesar su información".

Así Excel puede leer una base de datos en Access o SQL Server, incluso SQL Pato (si es que alguien fabricó un controlador de ODBC). Siendo sinceros, esas no son todas las razones ni los intereses por los que ODBC fue implementado, hay cierta oscuridad por ahí.

En ODBC no se tiene que hacer gran cosa, es una simple tarea, se llama crear un origen de datos, otros le denominan fuente en vez de origen.Un origen o fuente de datos consiste en el nombre, el controlador y la base de datos. Por ejemplo, si un usuario quiere tener acceso a una base de datos de Access, digamos que se llama Negocio.mdb, desde una hoja de cálculo de Excel para consultar su volumen de ventas por país, este usuario crea un nuevo origen de datos en ODBC llamado Volumen_Ventas (este es, pues, el nombre), después selecciona un controlador para Microsoft Access e indica el archivo de base de datos está en "c:\LaEmpresa\Administración\Negocio.mdb". Eso es básicamente de lo que se trata.

Las aplicaciones creadas específicamente para Windows 95, 98 y NT usan el ODBC de 32 bits; pero algunos sistemas conservan un ODBC de 16 bits para las aplicaciones de legado que corrían o corren en Windows 3.11.

Al iniciar ODBC de 32Bits la tres pestañas se refieren a: User DSN, System DSN y File DSN, versión en inglés, traduciendo un poco:

User DSN: nombre del origen de datos para el usuario. A veces, una máquina es utilizada por más de un usuario, los orígenes de datos declarados aquí son exclusivos del usuario.



System DSN: nombre del origen de datos para el sistema. Todos los usuarios de la máquina tienen acceso a estos orígenes de datos.

File DSN: nombre del origen de datos en archivo. Se crea un archivo con la extensión DSN, que sirve como origen de datos y puede ser distribuido a otros usuarios. Este origen es el que usa Excel por omisión cuando hace consultas, cuidado con eso.

Otra petaña importante que es ODBC Drivers o Controladores ODBC. Aquí se ven todos los controladores disponibles en la máquina. De está forma se puede consultar si se dispone del controlador que se necesita y si es la versión conveniente. Regularmente los controladores de bases de datos vienen con un programa de instalación que los instala y quedan dados de alta en esta lista.

Las otras pestañas merecen explicarse aparte, ya que están fuera del alcance de este curso.

2.3 Conexiones Cliente – Servidor.

La comprensión del paradigma cliente - servidor contribuye a la correcta implementación de servidores de motores de bases de datos remotos. Los programadores que no tengan experiencia en el desarrollo cliente - servidor pueden cometer fácilmente errores que hagan que sus aplicaciones fallen o tengan un rendimiento bajo. Dichos fallos pueden conducirles a malinterpretar el concepto cliente - servidor o los componentes de desarrollo utilizados para desplegar el sistema.

Por ejemplo, el diseño de tablas con demasiadas columnas o que no estén correctamente normalizadas puede privar de muchas de las ventajas del modelo de base de datos relacional. Los diseños que extraen tablas enteras o que crean cursores que contienen demasiadas filas también pueden conducir a un rendimiento no deseado, independientemente del modelo de programación.

La programación de aplicaciones para sistemas de servidores centrales, especialmente para sistemas que tienen acceso a grandes cantidades de datos o tienen cientos de usuarios, es muy diferente de la programación de sistemas de bases de datos basados en ISAM planos. Cuando desarrolle una aplicación que tenga acceso a una base de datos remota, debe implementar un modelo relacional cuidadosamente diseñado. Aunque es algo que podría dejar para una fecha posterior en un intento de mejorar el rendimiento, sería como intentar modificar el sótano de su casa después de haber terminado el último piso.

Antes de tomar la decisión final sobre el modelo de programación que va a implementar, debe tener en cuenta una serie de aspectos que afectan al diseño independientemente del modelo.

Para tener acceso a un servidor remoto, su aplicación tiene que establecer una conexión. Esta conexión crea un vínculo de comunicaciones en la red entre el servidor y el cliente. A su aplicación se le pasa un controlador de esta conexión. Una vez creada, la conexión proporciona acceso a un servidor específico, a una de las bases de datos del servidor y a cualquiera de los objetos temporales específicos de la conexión que su aplicación cree en el servidor.



2.4 Establecimiento de conexiones cliente-servidor.Dependiendo del modelo de programación cliente-servidor de acceso a datos que elija, puede establecer una conexión con un servidor remoto desde el código con los siguientes métodos descritos.

En Visual Basic, existen tres formas de acceso a datos: ActiveX Data Objects (ADO), Remote Data Objects (RDO) y Data Access Objects (DAO). Una interface de acceso a datos es un modelo de objetos que representan una forma de accesar datos desde una B.D. la última versión de conexión es ADO es simple y más flexible, ya que contiene la facilidad de uso de DAO y la robustes de RDO.

Todas estas técnicas crean una o varias conexiones que vinculan la instancia específica de su aplicación con el servidor remoto. En algunos casos, está limitado a un número de conexiones relativamente bajo; con Microsoft SQL Server Workstation Edition son 15 o menos. En otros casos, dicho número puede ser relativamente alto (32.767), como con SQL Server Enterprise Edition. No todas estas técnicas tienen el mismo nivel de rendimiento. Por ejemplo, utilizar DAO para abrir directamente una base de datos remota puede ser muy costoso en tiempo y en recursos de red.

Nota Compruebe con el administrador del servidor el número de conexiones disponibles. Éstas pueden estar limitadas por restricciones de licencia o de recursos. Como una única aplicación puede crear cualquier número de conexiones, el número de usuarios que su servidor remoto acepta puede estar limitado por su capacidad de administrar suficientes conexiones.

Puede que en su aplicación no sea necesario mantener una conexión permanente con el servidor remoto, pero en algunos casos la pérdida de una conexión puede hacer que se pierdan los objetos temporales específicos de la conexión. En un sistema multiusuario, la administración de las conexiones se hace mucho más importante porque el número total de usuarios conectados a una base de datos puede estar limitado por el número de conexiones que utilice cada aplicación. Dependiendo del servidor y del número de conexiones disponibles, puede ser más eficiente dejar una o varias conexiones establecidas durante toda la vida de la aplicación. En otros casos, puede que tenga que abrir y cerrar conexiones lo más rápidamente para dar cabida a otros usuarios debido al número limitado de controladores de conexión. Asegúrese de que la interfaz de programación que elija acepte una estrategia de conexión adecuada.

La mayoría de los modelos de programación de acceso a datos utilizan esquemas de bloqueo de páginas de 2 KB. Generalmente, esto significa que cuando una fila (registro) queda bloqueada para su actualización, toda la página (y todas las demás filas de la página) también permanecen bloqueadas durante la operación. Algunas veces, cuando la operación de actualización o eliminación afecta a un gran número de filas, el DBMS puede pasar los bloqueos de página a bloqueos de tabla para acelerar el proceso. Cuando se utiliza SQL Server , puede controlar el número de bloqueos de página que provocan el bloqueo de la tabla mediante el uso de opciones de escalado del bloqueo. También puede especificar el bloqueo de fila en los sistemas SQL Server

Todas las filas de una página de datos pertenecen a la misma tabla. Por este motivo, puede aliviar las situaciones de bloqueo si modifica la distribución de las columnas en su base de datos. Este proceso de normalización distribuye la información de las columnas sobre tablas relacionadas. Si su tabla tiene un tamaño de fila que se aproxima al límite de 2 KB, probablemente necesite implementar cierto grado de normalización, lo que minimiza la



duplicación de información en una base de datos relacional mediante un diseño eficiente de las tablas.

Nota Si el tamaño de una fila individual es mayor de 1 KB, en cada página de 2 KB sólo se coloca un fila porque las filas no ocupan más de una página.

2.5 Estrategias de bloqueo.

Todos los modelos de programación de acceso a datos de Visual Basic proporcionan varios métodos de bloqueo. A veces puede controlar el grado de bloqueo mediante:

• Operaciones de transacción (BEGIN TRANS/COMMIT TRANS).

• Un HOLDLOCK.

• Otros parámetros en las instrucciones SQL SELECT.

En general, las recomendaciones siguientes le ayudarán a definir una estrategia de bloqueo. Asegúrese de elegir una interfaz de programación que proporcione la flexibilidad necesaria para implementar las recomendaciones que considere importantes.

• Evite las situaciones en las que varios procesos intenten realizar actualizaciones o inserciones en la misma página de datos. Por ejemplo, esto puede ocurrir en una tabla no indexada, porque todas las inserciones se aplican a la última página de la cadena. Cree tablas distintas de historial para cada grupo de usuarios para minimizar los retrasos provocados por esta situación. Además, cree un índice agrupado para distribuir datos en varias páginas.

• Evite las transacciones que incluyan interacción con el usuario. Como los bloqueos se mantienen durante toda la transacción, un único usuario puede bloquear todo el sistema.

• Haga que las transacciones que modifiquen datos sean lo más breves posible. Cuanto más larga sea la transacción, más tiempo duran los bloqueos, bloqueando así otras actividades y provocando un aumento en el número de situaciones de punto muerto.

• Agrupe las transacciones en un único lote. Problemas inesperados de red pueden retrasar la finalización de las transacciones y, por tanto, la liberación de los bloqueos.

• Los sistemas SQL Server utilizan lecturas repetibles, niveles de aislamiento serializables o SELECT con HOLDLOCK sólo cuando es necesario. Las actualizaciones pueden retrasarse esperando la liberación de los bloqueos.

• En sistemas SQL Server, reduzca el factor de ocupación (que determina el porcentaje de la página que SQL Server llena cuando crea un nuevo índice sobre datos existentes) cuando cree un índice para evitar la posibilidad de que actualizaciones aleatorias requieran la misma página. Esto es especialmente útil en tablas pequeñas con acceso frecuente.



3 SQL Server 7.0

Introducción

El principal objetivo de una base de datos de Microsoft SQL Server es almacenar datos y, posteriormente, poner esos datos a disposición de las aplicaciones y usuarios autorizados. Mientras que los administradores de base de datos crean y mantienen las bases de datos, los usuarios trabajan con el contenido de las mismas al:

• Tener acceso o recuperar los datos existentes. • Cambiar o actualizar los datos existentes. • Agregar o insertar nuevos datos. • Eliminar los datos existentes.

El acceso y modificación de datos en Microsoft SQL Server se realiza mediante la utilización de una aplicación o herramienta para enviar peticiones de recuperación y modificación de datos a SQL Server. Por ejemplo, puede conectarse a SQL Server con el Administrador corporativo de SQL Server, el Analizador de consultas de SQL Server o la herramienta osql, y empezar a trabajar con los datos de SQL Server.

Las aplicaciones y herramientas usan dos componentes para tener acceso a SQL Server:

• Interfaces de programación de aplicación de base de datos (API) para enviar comandos a SQL Server y recuperar el resultado de esos comandos. Estas API pueden ser API de base de datos de propósito general, como ADO, OLE DB, ODBC o bibliotecas de bases de datos. También pueden ser API diseñadas específicamente para usar las características especiales de SQL Server, como SQL-DMO, SQL-DTS o los componentes de duplicación de SQL Server.

• Los comandos enviados a SQL Server son instrucciones de Transact-SQL. Las instrucciones de Transact-SQL se generan con el lenguaje SQL definido en la Referencia de Transact-SQL. La mayor parte de estas operaciones se implementa usando una de las siguientes cuatro instrucciones de Transact-SQL:

• La instrucción SELECT se usa para recuperar los datos existentes. • La instrucción UPDATE se usa para cambiar los datos existentes. • La instrucción INSERT se usa para agregar nuevas filas de datos. • La instrucción DELETE se usa para quitar filas que ya no son necesarias.

Estas cuatro instrucciones forman el núcleo del lenguaje SQL. Cuando se comprenda cómo funcionan estas cuatro instrucciones, se habrá entendido en gran medida cómo funciona SQL.

Las herramientas de consulta gráficas o basadas en formularios no requieren ningún conocimiento de SQL. Presentan al usuario una representación gráfica de la tabla. El usuario puede seleccionar gráficamente las columnas y especificar con facilidad cómo calificar las filas que desea recuperar.

Algunas aplicaciones, como, por ejemplo, el Analizador de consultas de SQL Server y la herramienta osql, son programas para ejecutar instrucciones de Transact-SQL. Las herramientas ejecutan las instrucciones de Transact-SQL introducidas interactivamente o leídas de un archivo.

Para usar estas herramientas, debe ser capaz de construir instrucciones de Transact-SQL.

Las aplicaciones escritas para las API de base de datos de propósito general, como, por ejemplo, ADO, OLE DB, ODBC o bibliotecas de bases de datos, también envían instrucciones de Transact-



SQL a SQL Server. Estas aplicaciones presentan al usuario una interfaz que refleja la función de empresa que implementan. Cuando el usuario ha indicado qué función de empresa debe realizarse, la aplicación usa una de las API de base de datos para pasar instrucciones SQL a SQL Server. Para codificar estos tipos de aplicaciones, debe conocer las instrucciones de Transact-SQL.

Otras aplicaciones, como el Administrador corporativo de SQL Server, usan un modelo de objetos que aumenta la eficiencia de la utilización de SQL Server. El Administrador corporativo de SQL Server usa un modelo de objetos que facilita la tarea de administrar los distintos servidores SQL Server. Las API como SQL-DMO y SQL-DTS, y los componentes de duplicación usan también modelos similares de objetos. Sin embargo, los propios objetos se comunican con SQL Server mediante Transact-SQL. Entender el lenguaje Transact-SQL puede ayudarle a comprender estos objetos.



Crear instrucciones de Transact-SQL

En los fundamentos del acceso y modificación de los datos se explican los elementos básicos usados para crear instrucciones de Transact-SQL. También se proporciona información acerca de las funciones que Transact-SQL puede realizar, así como de la funcionalidad similar que ofrecen las API de bases de datos.

Una instrucción SELECT contiene los elementos comunes usados en las instrucciones de Transact-SQL. Por ejemplo, para seleccionar los nombres, nombres de contacto y números de teléfono de los clientes que viven en Estados Unidos de la tabla Customers de la base de datos Northwind, se usan estos elementos:

• El nombre de la base de datos que contiene la tabla (Northwind) • El nombre de la tabla que contiene los datos (Customers) • Una lista de las columnas cuyos datos se van a devolver (CompanyName,

ContactName, Phone) • Los criterios de selección (sólo para los clientes que viven en Estados Unidos)

A continuación se muestra la sintaxis de Transact-SQL utilizada para recuperar esta información:

SELECT CompanyName, ContactName, PhoneFROM Northwind.dbo.CustomersWHERE Country = 'USA'

Entre los elementos adicionales usados en instrucciones de Transact-SQL se encuentran:

• Funciones Las funciones se usan en las consultas, informes y muchas instrucciones de Transact-SQL de SQL Server para devolver información, de forma parecida a como se utilizan las funciones de otros lenguajes de programación. Toman parámetros de entrada y devuelven un valor que se puede usar en las expresiones. Por ejemplo, la función DATEDIFF toma dos fechas y una parte de una fecha (semanas, días, meses, etc.) como argumentos y devuelve el número de unidades de parte de fecha que hay entre dos fechas.

• Identificadores Los identificadores son los nombres dados a los objetos, como, por ejemplo, tablas, vistas, bases de datos e índices. Un identificador se puede especificar sin delimitadores (por ejemplo, TEST), con delimitadores entre comillas (por ejemplo, "TEST") o entre corchetes (por ejemplo, [TEST]).

• Comentarios Los comentarios son fragmentos de texto que no se ejecutan en el código del programa.

• Expresiones Las expresiones incluyen valores de constantes o literales (por ejemplo, 5 es un literal numérico), funciones, nombres de columna, aritmética, operaciones de bits, subconsultas escalares, funciones CASE, funciones COALESCE y funciones NULLIF.

• Palabras clave reservadas Las palabras que SQL Server reserva para su propio funcionamiento. Se recomienda evitar la utilización como identificadores de estas palabras clave reservadas.

• Valores NULL



Los valores NULL son aquellos que son desconocidos. Puede usar valores NULL para indicar que la información se proporcionará posteriormente. Por ejemplo, si la persona de contacto de la empresa Comercio Leka cambia y no se conoce la nueva persona de contacto, podría indicar que su nombre es desconocido con un valor NULL.

• Tipos de datos Los tipos de datos definen el formato en el que se almacenan los datos. Por ejemplo, puede usar cualquiera de los tipos de datos de carácter o Unicode (char, varchar, nchar o nvarchar) para almacenar los datos de carácter como, por ejemplo, los nombres de los clientes.

• Lotes Los lotes son grupos de instrucciones transmitidas y ejecutadas como una unidad. Algunas instrucciones de Transact-SQL no se pueden agrupar en un lote. Por ejemplo, para crear cinco tablas nuevas en la base de datos pubs, cada instrucción CREATE TABLE debe encontrarse en su propio lote o unidad. A continuación se muestra un ejemplo de un lote de Transact-SQL:

USE Northwind SELECT * FROM Customers WHERE Region = 'WA' AND Country = 'USA' ORDER BY PostalCode ASC, CustomerID ASC UPDATE Employees SET City = 'Missoula' WHERE CustomerID = 'THECR' GO

• Lenguaje de control de flujo El lenguaje de control de flujo permite al código del programa emprender una acción en función de que se cumpla o no alguna condición. Por ejemplo, IF (si) la cantidad de productos pedida es igual o menor que la cantidad de productos almacenada actualmente, THEN (entonces) necesitamos pedir más productos.

• Operadores SQL Server incluye operadores que permiten la ejecución de ciertas acciones en los datos. Por ejemplo, mediante la utilización de operadores aritméticos puede realizar operaciones matemáticas como, por ejemplo, sumas y restas en los datos.

Para realizar procesos que no se pueden llevar a cabo con una sola instrucción de Transact-SQL, Microsoft SQL Server permite agrupar instrucciones de Transact-SQL de varias formas:

• Usar lotes Un lote es un grupo compuesto por una o varias instrucciones de Transact-SQL que se envían desde una aplicación al servidor como una unidad. SQL Server ejecuta cada lote como una unidad ejecutable individual.

• Utilizar procedimientos almacenados Un procedimiento almacenado es un grupo de instrucciones de Transact-SQL que han sido definidas y compiladas previamente en el servidor. El procedimiento almacenado puede aceptar parámetros y devolver conjuntos de resultados, códigos de retorno y parámetros de salida a la aplicación que realiza la llamada.

• Utilizar desencadenadores



Un desencadenador es un tipo especial de procedimiento almacenado. No es llamado directamente por las aplicaciones. En su lugar, se ejecuta cuando un usuario realiza una modificación determinada (INSERT, UPDATE o DELETE) en una tabla.

• Utilizar secuencias de comandos Una secuencia de comandos es una serie de instrucciones de Transact-SQL almacenadas en un archivo. El archivo se puede usar como entrada para la herramienta osql o para el Analizador de consultas de SQL Server. Las herramientas ejecutarán entonces las instrucciones de Transact-SQL almacenadas en el archivo.

Las siguientes características de SQL Server permiten controlar la utilización de varias instrucciones de Transact-SQL a la vez:

• Instrucciones de control de flujo Le permiten incluir lógica condicional. Por ejemplo, si el país es Canadá, se realiza una serie de instrucciones de Transact-SQL. Si el país es Reino Unido, se realiza otra serie de instrucciones de Transact-SQL.

• Variables Le permiten almacenar datos para ser utilizados posteriormente como entrada de una instrucción de Transact-SQL. Por ejemplo, puede que tenga que codificar una consulta que necesite especificar distintos valores de datos en la cláusula WHERE cada vez que se ejecuta la consulta. Puede escribir la consulta para que use variables en la cláusula WHERE y codificar la lógica para que rellene las variables con los datos adecuados. Los parámetros de los procedimientos almacenados son una clase especial de variables.

• Tratamiento de errores Le permite personalizar la forma en la que SQL Server responde a los problemas. Pueden especificar las acciones apropiadas que se llevarán a cabo cuando se produzcan errores, o generar mensajes de error personalizados que sean más informativos para el usuario que los errores genéricos de SQL Server.



3.1 PermisosCada objeto de una base de datos de Microsoft SQL Server tiene un propietario, normalmente el identificador del usuario activo en la conexión en que se creó el objeto. Otros usuarios no pueden tener acceso a ese objeto hasta que el propietario autorice a sus identificadores de usuario para que tengan acceso al objeto.

Ciertas instrucciones de Transact-SQL también están limitadas a determinados identificadores de usuario. Por ejemplo, la instrucción CREATE DATABASE está limitada a los miembros de las funciones fijas de servidor sysadmin y dbcreator. Los usuarios no pueden tener acceso a un objeto o ejecutar una instrucción a menos que hayan sido autorizados a hacerlo.

Todas las instrucciones de Transact-SQL que emite un usuario están sujetas a los permisos que éste ha recibido. Los miembros de la función fija de servidor sysadmin, los miembros de la función fija de base de datos dbowner y los propietarios de objetos de base de datos pueden conceder, denegar o revocar permisos a una persona o función. Cuando use Transact-SQL, utilice las instrucciones GRANT, DENY y REVOKE para especificar quién puede usar qué instrucciones de modificación de datos:

• GRANT da permisos para trabajar con datos o ejecutar otras instrucciones de Transact-SQL.

• DENY deniega un permiso e impide que el usuario, grupo o función especificada herede el permiso a través de su pertenencia a un grupo o función.

• REVOKE quita los permisos concedidos o denegados previamente.

Los permisos que se pueden conceder a los objetos son: • SELECT :Permite a un usuario emitir instrucciones SELECT en una tabla o vista. • INSERT :Permite a un usuario emitir instrucciones INSERT en una tabla o vista. • UPDATE:Permite a un usuario emitir instrucciones UPDATE en una tabla o vista. • DELETE :Permite a un usuario emitir instrucciones DELETE en una tabla o vista. • REFERENCES :Permite a un usuario insertar una fila en una tabla que tiene una clave

externa, que hace referencia a la tabla que se nombra en la instrucción GRANT, DENY y REVOKE.

• EXECUTE :Permite a un usuario emitir instrucciones EXECUTE en un procedimiento almacenado.

Los permisos se pueden conceder también para ejecutar instrucciones de Transact-SQL que normalmente están limitadas a los miembros de una función determinada. Por ejemplo, un miembro de la función fija de servidor sysadmin puede conceder permisos de CREATE DATABASE a un usuario que normalmente no podría crear bases de datos.



3.2 Utilizar las opciones de SQL Server

Microsoft SQL Server proporciona opciones que afectan al resultado y rendimiento de las instrucciones SQL. Transact-SQL permite establecer estas opciones de las siguientes maneras:

• Las opciones de configuración del servidor se establecen mediante el procedimiento almacenado sp_configure.

• Las opciones de base de datos se establecen al ejecutar el procedimiento almacenado sp_dboptions.

• El nivel de compatibilidad de la base de datos se establece mediante la ejecución del procedimiento almacenado sp_dbcmptlevel.

• Las opciones de conexión (opciones SET) se especifican con instrucciones SET, como, por ejemplo, SET ANSI_PADDING y SET ANSI_NULLS.

• Las opciones de instrucción (sugerencias de consultas, de tablas y de combinación) se especifican en instrucciones individuales de Transact-SQL.

Las aplicaciones ODBC pueden especificar opciones de conexión que controlan algunas de las opciones de ANSI SET. El controlador ODBC de SQL Server y Microsoft OLE DB Provider for SQL Server establecen de forma predeterminada varias opciones SET. Las opciones se pueden establecer también mediante el Administrador corporativo de SQL Server.

Jerarquía de opciones

Cuando una opción se admite en más de un nivel: 1. Una opción de base de datos anula una opción de servidor. 2. Una opción SET anula una opción de base de datos. 3. Un sugerencia anula una opción SET.

Nota sp_configure proporciona la opción user options, que permite cambiar los valores predeterminados de varias opciones SET. Aunque user options parece una opción del servidor, es una opción SET.



3.2.1 Opciones SET

En esta tabla se incluye una lista alfabética de opciones SET y las correspondientes opciones de base de datos y de servidor que se admiten en Microsoft SQL Server.

OPCIÓN SET OPCIÓN DE BASE DE DATOS OPCIÓN DE SERVIDORValor pre-

determinado

ANSI_NULL_DFLT_ONANSI_NULL_DFLT_OFF

ANSI null default(valor NULL ANSI predeterminado)

user options asignavalor predeterminado

OFF

ANSI_NULLSValores NULL ANSI

(ANSI nulls)user options asignavalor predeterminado

OFF

ANSI_PADDING Ningunouser options asignavalor predeterminado

ON

ANSI_WARNINGSAdvertencias ANSI

(ANSI warnings)user options asignavalor predeterminado

OFF

CONCAT_NULL_YIELDS_NULLEl resultado de la

concatenación con nulles null

(concat null yields null)

Ninguno OFF

CURSOR_CLOSE_ON_COMMIT

Cierre de cursor al confirmar (cursor close on commit)

User options asignavalor predeterminado

OFF

IMPLICIT_TRANSACTIONS NingunoUser options asignavalor predeterminado

OFF

QUOTED_IDENTIFIERIdentificador entre comillas

(quoted identifier)User options asignavalor predeterminado

OFF

ANSI_DEFAULTS Ninguno Ninguno N/D

ARITHABORT NingunoUser options asignavalor predeterminado

OFF

ARITHIGNORE NingunoUser options asignavalor predeterminado

OFF

DATEFIRST Ninguno Ninguno 7DATEFORMAT Ninguno Ninguno mdyDEADLOCK_PRIORITY Ninguno Ninguno NORMAL

DISABLE_DEF_CNST_CHK NingunoUser options asignavalor predeterminado

OFF

FIPS_FLAGGER Ninguno Ninguno OFFFMTONLY Ninguno Ninguno OFFFORCEPLAN Ninguno Ninguno OFFIDENTITY_INSERT Ninguno OFFLANGUAGE Ninguno Ninguno us_englishLOCK_TIMEOUT Ninguno Ninguno Sin límite

NOCOUNT NingunoUser options asignavalor predeterminado

OFF

NOEXEC Ninguno Ninguno OFFNUMERIC_ROUNDABORT Ninguno Ninguno OFFOFFSETS Ninguno Ninguno OFFPARSEONLY Ninguno Ninguno OFFPROCID Ninguno Ninguno OFFQUERY_GOVERNOR_COST_LIMIT

NingunoLímite del administrador

de consultasOFF

REMOTE_PROC_TRANSACTIONS

Ninguno Ninguno OFF

ROWCOUNT Ninguno Ninguno OFFSHOWPLAN_ALL Ninguno Ninguno OFFSHOWPLAN_TEXT Ninguno Ninguno OFFSTATISTICS IO Ninguno Ninguno OFFSTATISTICS_PROFILE Ninguno Ninguno N/D



STATISTICS TIME Ninguno Ninguno OFFTEXTSIZE Ninguno Ninguno OFFTRANSACTION ISOLATION LEVEL

Ninguno Ninguno N/D

XACT_ABORT Ninguno Ninguno OFF

Opciones SET de tiempo de análisis y tiempo de ejecución

El momento en el que las opciones SET surten efecto depende de si la opción es una opción de tiempo de análisis o de tiempo de ejecución. Las opciones de tiempo de análisis surten efecto durante el análisis, según se encuentran las opciones en el texto, sin tener en cuenta las instrucciones de control de flujo. Las opciones de tiempo de ejecución surten efecto durante la ejecución del código en el que se especifican. Si la ejecución falla antes de que se haya ejecutado la instrucción SET, la opción no se establece. Si la ejecución falla una vez ejecutada la instrucción SET, la opción se habrá establecido.

Las opciones QUOTED_IDENTIFIER, PARSEONLY, OFFSETS y FIPS_FLAGGER son de tiempo de análisis. El resto de las opciones SET son de tiempo de ejecución.

Las instrucciones SET QUOTED_IDENTIFIER y SET ANSI_NULLS que se producen en un lote o procedimiento almacenado no afectan al lote o al procedimiento almacenado. En su lugar, la configuración que se utiliza para las instrucciones de un lote o procedimiento almacenado es la que hay cuando se crea el lote o procedimiento almacenado.

Duración de las opciones SET

En esta sección se describe la duración de las opciones SET. • Las opciones SET que establece un usuario en una secuencia de comandos se aplican

hasta que se restablezcan o hasta que se termine la sesión del usuario con el servidor. • Las opciones SET que se establecen en un procedimiento almacenado o

desencadenador se aplican hasta que se restablezcan en el procedimiento almacenado o desencadenador, o hasta que el control retorne al código que los llamó.

• A menos que se restablezcan de forma explícita, los valores de las opciones SET de todos los códigos de mayor nivel se aplican en un procedimiento almacenado o desencadenador.

• A menos que se restablezcan de forma implícita o explícita, las opciones SET que se han establecido para una conexión se aplican después de conectarse a una base de datos distinta.

Nota Una consideración adicional es que cuando un usuario se conecta a una base de datos, algunas opciones se pueden establecer a ON (activada) automáticamente, en función de los valores especificados por el uso anterior de la opción de servidor user options o los valores que se aplican a todas las conexiones ODBC y OLE DB.

Opción SET con acceso directo

Transact-SQL proporciona la instrucción SET ANSI_DEFAULTS como acceso directo para establecer estas opciones estándar de SQL-92:

• SET ANSI_NULLS • SET CURSOR_CLOSE_ON_COMMIT



• SET ANSI_NULL_DFLT_ON • SET IMPLICIT_TRANSACTIONS • SET ANSI_PADDING • SET QUOTED_IDENTIFIER • SET ANSI_WARNINGS

El acceso directo restablece los valores de estas opciones. Cualquier opción individual establecida una vez que se ha utilizado el acceso directo anula el valor correspondiente establecido por el mismo.

Nota SET ANSI_DEFAULTS no establece todas las opciones necesarias para cumplir el estándar SQL-92.



3.2.2 Opciones de base de datos

En esta tabla se enumeran en orden alfabético las opciones de base de datos y las correspondientes opciones SET y de servidor que se admiten en Microsoft SQL Server.

Opción de base de datos Opción SETOpción de servidor

Valor predeterminad

oANSI null default (valor NULL ANSI predeterminado)

ANSI_NULL_DFLT_ONANSI_NULL_DFLT_OFF

user options asigna valor predeterminado

OFF

ANSI nulls (Valores NULL ANSI)

ANSI_NULLSuser options asigna valor predeterminado

OFF

ANSI warnings (Advertencias ANSI)

ANSI_WARNINGSuser options asigna valor predeterminado

OFF

auto create statistics (crear estadísticas automáticamente)

Ninguno Ninguno ON

auto update statistics (actualizar estadísticas automáticamente)

Ninguno Ninguno ON

autoclose (cerrar automáticamente)

Ninguno Ninguno FALSE

autoshrink (reducción automática)


concat null yields null (el resultado de la concatenación con null es null)

CONCAT_NULL_YIELDS_NULLNinguno OFF

cursor close on commit (cierre de cursor al confirmar)


user options asigna valor predeterminado

OFF

dbo use only (sólo para uso del dbo)


default to local cursor (toma como predeterminado el cursor local)


merge publish (publicación de mezcla)


offline (sin conexión) Ninguno Ninguno FALSEpublished (publicado) Ninguno Ninguno FALSEquoted identifier (identificador entre comillas)

QUOTED_IDENTIFIERuser options asigna valor predeterminado

OFF

read only (de sólo lectura)


recursive triggers (desencadenadores recursivos)


select into/ bulkcopy (select into o copia masiva)


single user (un único usuario)




subscribed (suscrito) Ninguno Ninguno TRUEtorn page detection (detección de página rasgada)

Ninguno TRUE

trunc. log on chkpt. (truncar registro en punto de comprobación)

Ninguno Ninguno TRUE

Las opciones predeterminadas de base de datos para una base de datos nueva son las que se han definido en la base de datos model. En las instalaciones nuevas de SQL Server, la configuración de las bases de datos model y master es la misma.Un cambio en una opción de base de datos obliga a que se tenga que volver a compilar todo lo que hay en la caché.

Opciones y contexto de base de datos

El contexto de base de datos de las secuencias de comandos y los lotes dentro de las mismas viene determinado por la conexión más reciente. La conexión se puede establecer explícitamente con la instrucción USE en Transact-SQL y con métodos implícitos y explícitos en otros entornos, como OBDC y OLE DB.

Cuando se ejecuta un procedimiento almacenado desde un lote o desde otro procedimiento almacenado, la ejecución se hace con las opciones establecidas en ese momento en la base de datos que contiene el procedimiento almacenado. Por ejemplo, cuando el procedimiento almacenado db1.dbo.sp1 llama al procedimiento almacenado db2.dbo.sp2, sp1 se ejecuta con la opción de nivel de compatibilidad actual de la base de datos db1 y sp2 se ejecuta con la opción de nivel de compatibilidad actual de la base de datos db2.

Cuando una instrucción de Transact-SQL se refiere a objetos que residen en varias bases de datos, se le aplica el contexto de base de datos actual y de conexión actual (la base de datos definida con la instrucción USE, si se trata de un lote, o la que contiene el procedimiento almacenado en el caso de un procedimiento almacenado).



3.2.3 Opciones de servidor

En esta tabla se enumeran en orden alfabético las opciones de servidor y las opciones correspondientes de base de datos y SET que se admiten en Microsoft SQL Server .

Opción de servidor Opción SETOpción de

base de datosValor

predeterminadoaffinity mask (máscara de afinidad) Ninguno Ninguno 0

allow updates (permitir actualizaciones) Ninguno Ninguno OFF

cost threshold for parallelism (umbral de costo del paralelismo)

Ninguno Ninguno 5

cursor threshold (umbral del cursor) Ninguno Ninguno -1

default language (idioma predeterminado) Ninguno Ninguno 0

default sortorderid (id. predeterminado de orden)

Ninguno Ninguno 52

extended memory size (tamaño de memoria extendida)

Ninguno Ninguno 0

fill factor (factor de relleno) Ninguno Ninguno 0

index create memory (memoria para creación de índices)

Ninguno Ninguno 2048

language in cache (idioma en caché) Ninguno Ninguno 3

language neutral full-text (texto independiente del idioma)

Ninguno Ninguno 0

lightweight pooling (agrupación compacta) -1

locks (bloqueos) Ninguno Ninguno 0

max async io (máx. de E/S asincrónica) Ninguno Ninguno 32

max degree of parallelism (máximo grado de paralelismo)

Ninguno Ninguno 0

max server memory (memoria máxima del servidor)


max text repl size (tamaño máximo de texto reemplazado)


max worker threads (máx. de subprocesos secundarios)

Ninguno Ninguno 255

media retention (conservación de medio) Ninguno Ninguno 0

min memory per query (mín. de memoria por consulta)


min server memory (memoria mínima del servidor)

Ninguno Ninguno 0

nested triggers (desencadenadores anidados) Ninguno Ninguno 1

network packet size (tamaño del paquete de red)


open objects (objetos abiertos) Ninguno Ninguno 0

priority boost (aumento de prioridad) Ninguno Ninguno 0

query governor cost limit (límite del administrador de consultas)

QUERY_GOVERNOR_COST_LIMIT

Ninguno 0

query wait (espera de consulta) Ninguno Ninguno 600

recovery interval (intervalo de recuperación) Ninguno Ninguno 5

remote access (acceso remoto) Ninguno Ninguno 1

remote login timeout (tiempo de espera de inicio de sesión remoto)

Ninguno Ninguno 30

remote proc trans (transacción de procedimiento remoto)

Ninguno Ninguno 0

remote query timeout (tiempo de espera de consulta remota)

Ninguno Ninguno 0

resource timeout (tiempo de espera de Ninguno Ninguno 10



recurso)scan for startup procs (buscar procesos de inicio)

Ninguno Ninguno 0

set working set size (establecer el tamaño del conjunto de trabajo)

Ninguno Ninguno 0

show advanced options (mostrar opciones avanzadas)

Ninguno Ninguno 1

spin counter (contador de giro) Ninguno Ninguno 0

time slice (división de tiempo) Ninguno Ninguno 100

Unicode comparison style (estilo de comparación en Unicode)

Ninguno Ninguno 1

Unicode locale id (Id. local de Unicode) Ninguno Ninguno 1033

user connections (conexiones de usuario) Ninguno Ninguno 0

user options (opciones de usuario) ANSI_NULL_DFLT_ONANSI_NULL_DFLT_OFF

ANSI null default (valor NULL ANSI

predeterminado)

OFF

ANSI_NULLSValores NULL

ANSI (ANSI nulls)

OFF

ANSI_PADDING Ninguno ON

ANSI_WARNINGSAdvertencias ANSI (ANSI warnings)

OFF


Cierre de cursor al confirmar

(cursor close on commit)

OFF

IMPLICIT_TRANSACTIONS Ninguno OFF

QUOTED_IDENTIFIER

Identificador entre comillas

(quoted identifier)

OFF

ARITHABORT Ninguno OFF

ARITHIGNORE Ninguno OFF

DISABLE_DEF_CNST_CHK Ninguno OFF

NOCOUNT Ninguno OFF

extended memory size (tamaño de memoria extendida)

Ninguno Ninguno 0



3.2.4 Sugerencias

En esta tabla se enumeran las opciones disponibles para las sugerencias de combinación, de consulta y de tabla en Microsoft SQL Server .

Tipo sugerencia

OpciónDescripción

Valor predeterminado

CombinaciónLOOP | HASH | MERGE | REMOTE

Especifica la estrategia que utilizar al combinar las filas de dos tablas.

Elegido por SQL Server.

Consulta { HASH | ORDER } GROUPEspecifica si se utiliza hash u orden para calcular los agregados GROUP BY y COMUTE.


Consulta{ MERGE | HASH | CONCAT } UNION

Especifica la estrategia que utilizar para todas las operaciones UNION de la consulta.


Consulta FAST enteroOptimiza la consulta para la recuperación del número especificado de filas.

No hay tal optimización.

Consulta FORCE ORDERRealiza combinaciones en el orden en que las tablas aparecen en la consulta


Consulta ROBUST PLANCrea un plan que tiene en cuenta el tamaño máximo posible de fila.


Tabla FASTFIRSTROWTiene el mismo efecto que especificar la sugerencia de consulta FAST 1.

No hay tal optimización.

Tabla INDEX =Indica a SQL Server que utilice los índices especificados de una tabla.


Tabla

HOLDLOCK | SERIALIZABLE | REPEATABLEREAD | READCOMMITTED | READUNCOMMITTED| NOLOCK

Hace que se establezcan (o no) ciertos bloqueos para una tabla y anula los bloqueos que se utilizarían para exigir el nivel de aislamiento de la transacción actual.

Los bloqueos necesarios para la transacción actual.

Tabla

ROWLOCK| PAGLOCK| TABLOCK| TABLOCKX

Especifica el tamaño de los bloqueos compartidos que se toman para esta tabla.


Tabla READPAST Salta todas las filas bloqueadas de una vez. Espera filas bloqueadas.

Tabla UPDLOCKToma bloqueos actualizados en lugar de compartidos.

Toma bloqueos compartidos.



3.3.5 Opción del nivel de compatibilidad de la base de datos

Transact-SQL proporciona el procedimiento almacenado sp_dbcmptlevel que establece ciertos comportamientos de base de datos para que sean compatibles con las versiones anteriores de Microsoft SQL Server .

Una regla especial se aplica a la relación entre la opción del nivel de compatibilidad de la base de datos, la opción de base de datos concat null yields null (la concatenación con null es null) y la opción SET CONCAT_NULL-YIELDS_NULL. La configuración de concat null yields null y CONCAT_NULL_YIELDS_NULL se pasan por alto cuando el valor del nivel de compatibilidad es para una versión anterior a la 7.0.

El nivel de compatibilidad afecta a los comportamientos de la base de datos especificada, no a todo el servidor. Para obtener más información, consulte sp_dbcmptlevel .

3.3.6 Comportamiento cuando ARITHABORT y ARITHIGNORE están activadas

Cuando utilice la versión 2.50.0121 o posterior del controlador ODBC de Microsoft SQL Server , ARITHABORT asumirá la prioridad si están activadas las opciones de proceso de consultas ARITHABORT y ARITHIGNORE.

ARITHABORT y ARITHIGNORE son dos opciones distintas; el hecho de activar una no implica la desactivación automática de la otra. Por ejemplo, si una aplicación contiene estas instrucciones, ambas opciones están activadas:

SET ARITHABORT ONSET ARITHIGNORE ONGO

Los procedimientos almacenados que emitan una instrucción SET ARITHIGNORE ON seguirán provocando que los clientes muestren el comportamiento propio de SET ARITHABORT ON si el cliente había activado ARITHABORT antes de llamar al procedimiento almacenado.

Los procedimientos pueden hacer lo siguiente para garantizar que ARITHIGNORE esté siempre activa, independientemente de la configuración del cliente para ARITHABORT:

CREATE PROCEDURE example ASSET ARITHABORT OFFSET ARITHIGNORE ON-- Statements making up the stored procedure go here.GO

Siempre que se ejecute una instrucción SET en un procedimiento almacenado, la nueva configuración permanecerá activa el tiempo que dure el procedimiento. Cuando finalice el procedimiento, la configuración de la conexión para esa opción volverá a su estado anterior a la ejecución del procedimiento. Con el código mostrado anteriormente, la opción ARITHABORT se desactiva durante la ejecución del procedimiento para que se active la opción ARITHIGNORE. A continuación, restablece la configuración definida por la aplicación cliente cuando finaliza el procedimiento.



3.3 Implementación y el mantenimiento de bases de datos.

Un sistema de base de datos de cliente-servidor consta de dos componentes: programas que proporcionan una interfaz para que los usuarios del cliente puedan tener acceso a los datos y la estructura de base de datos que administra y almacena los datos en el servidor. Por ejemplo, si utiliza Microsoft SQL Server para crear una aplicación de cuentas corrientes, deberá configurar una estructura de base de datos para administrar los datos de las transacciones de las cuentas y una aplicación que actúe como la interfaz de usuario para la base de datos con que los usuarios tendrán acceso a la información de las cuentas corrientes.

Para crear una base de datos deberá conocer cómo diseñar, crear y mantener cada uno de esos componentes para asegurar un funcionamiento óptimo de la base de datos.

Una base de datos de Microsoft SQL Server consta de una colección de tablas con datos y otros objetos como vistas, índices, procedimientos almacenados y desencadenadores, que se definen para poder llevar a cabo distintas operaciones con datos. Los datos almacenados en una base de datos suelen estar relacionados con un tema o un proceso determinados como, por ejemplo, la información de inventario para el almacén de una fábrica.

SQL Server puede trabajar con un gran número de bases de datos y cada una de ellas puede almacenar datos interrelacionados o datos no relacionados con los de las otras bases de datos. Por ejemplo, un servidor podría tener una base de datos en la que se almacenen datos del personal y otra en la que se almacenen datos relacionados con los productos. Por otra parte, puede utilizarse una base de datos para almacenar datos acerca de pedidos actuales de los clientes y otra base de datos relacionada puede almacenar pedidos anteriores de los clientes que se utilicen para la elaboración de los informes anuales.

Antes de crear una base de datos, es importante entender las partes que la componen y cómo diseñarlas para asegurar que la base de datos funcione correctamente una vez implementada.

Importante Se recomienda encarecidamente ( o sea que no la vallan a regar) no crear objetos de usuario, como tablas, vistas, procedimientos almacenados o desencadenadores, en la base de datos master. La base de datos master contiene las tablas del sistema con la información del sistema que utiliza SQL Server, como los valores de las opciones de configuración.

3.3.1 Componentes de una base de datos

Una base de datos de Microsoft SQL Server consta de una colección de tablas en las que se almacena un conjunto específico de datos estructurados. Una tabla contiene una colección de filas (en ocasiones denominadas registros o tuplas) y de columnas (también denominadas atributos). Cada columna de la tabla se ha diseñado para almacenar un determinado tipo de información (por ejemplo, fechas, nombres, importes en moneda o números). Las tablas contienen diversos tipos de controles (restricciones, reglas, desencadenadores, valores predeterminados y tipos de datos personalizados por los usuarios), que aseguran la validez de los datos. Las tablas pueden presentar índices, similares a los de los libros, que permiten localizar las filas rápidamente. Se puede agregar restricciones de integridad referencial declarativa (DRI) a las tablas con el fin de asegurar la coherencia de los datos interrelacionados que se encuentran en tablas distintas. Asimismo, una base de datos puede almacenar procedimientos que utilicen código de programación de Transact-SQL para realizar operaciones con los datos que contiene la base de datos, por ejemplo, almacenar vistas que permiten el acceso personalizado a los datos de las tablas.



3.3.2 Archivos y grupos de archivos

Microsoft SQL Server crea una base de datos mediante un conjunto de archivos del sistema operativo. Todos los datos y objetos de la base de datos, como las tablas, los procedimientos almacenados, los desencadenadores y las vistas, se almacenan exclusivamente en los siguientes archivos del sistema operativo:

• Principal Este archivo contiene la información de inicio para la base de datos y se utiliza para almacenar datos. Cada base de datos tiene un archivo de datos principal.

• Secundario Estos archivos contienen todos los datos que no caben en el archivo principal. Las bases de datos no necesitan archivos de datos secundarios si el archivo principal puede contener todos los datos de la base de datos. Algunas bases de datos pueden ser muy grandes y necesitar varios archivos de datos secundarios, o bien utilizar archivos secundarios en unidades de disco distintas para distribuir los datos en varios discos.

• Registro de transacciones Estos archivos contienen la información de registro que se utiliza para recuperar la base de datos. Cada base de datos debe tener al menos un archivo de registro.

Por ejemplo, puede crearse una base de datos sencilla, ventas, con un archivo principal que contenga todos los datos y objetos, y un archivo de registro que contenga la información del registro de transacciones. Por otra parte, puede crearse una base de datos más compleja, pedidos, compuesta por un archivo principal y cinco archivos secundarios; los datos y objetos de la base de datos se reparten entre los seis archivos, y cuatro archivos de registro adicionales contienen la información del registro de transacciones.

Los grupos de archivos permiten agrupar archivos con fines administrativos y de asignación y ubicación de datos. Por ejemplo, pueden crearse tres archivos (datos1.ndf, datos2.ndf y datos3.ndf) en tres unidades de disco, respectivamente, para asignarlos posteriormente al grupo de archivos grupoa1. A continuación, se puede crear específicamente una tabla en el grupo de archivos grupoa1. Las consultas de datos de la tabla se distribuirán por los tres discos, con lo que mejorará el rendimiento. Puede obtenerse el mismo incremento en el rendimiento con un archivo único creado en un conjunto de bandas RAID (matriz redundante de discos económicos). No obstante, los archivos y los grupos de archivos le permiten agregar nuevos archivos o discos con gran facilidad. Además, si la base de datos supera el tamaño máximo establecido para un archivo de Microsoft Windows NT®, puede utilizar archivos de datos secundarios para que la base de datos pueda seguir creciendo.

Reglas para la definición de archivos o grupos de archivos

Éstas son, entre otras, las reglas para la definición de archivos y grupos de archivos: • Un archivo o un grupo de archivos no puede ser utilizado por más de una base de datos.

Por ejemplo, los archivos ventas.mdf y ventas.ndf, que contienen datos y objetos de la base de datos ventas, no pueden ser utilizados por otra base de datos.

• Un archivo puede pertenecer únicamente a un grupo de archivos. • Los datos y la información del registro de transacciones no pueden pertenecer al mismo

archivo o grupo de archivos. • Los archivos del registro de transacciones nunca pueden formar parte de un grupo de

archivos.



3.3.2.1 Grupos de archivos predeterminados

Una base de datos consta de un grupo de archivos principal y de uno o varios grupos de archivos definidos por el usuario.

El grupo de archivos que contiene el archivo principal se denomina grupo de archivos principal. Cuando se crea una base de datos, el grupo de archivos principal contiene el archivo de datos principal y todos los archivos que no hayan sido asignados a otros grupos de archivos. Todas las tablas del sistema se encuentran en el grupo de archivos principal. Si el grupo de archivos principal se queda sin espacio, no se podrá agregar más información del catálogo a las tablas del sistema. El grupo de archivos principal sólo se llenará si el crecimiento automático está desactivado o si todos los discos que almacenan los archivos del grupo de archivos principal se quedan sin espacio. Si es así, vuelva a activar el crecimiento automático o mueva los archivos a otros discos para dejar espacio libre.

Los grupos de archivos definidos por el usuario son todos los creados específicamente por el usuario durante la creación de la base de datos o durante una modificación posterior. Si se llena un grupo de archivos definido por el usuario, sólo se verían afectadas las tablas de usuario asignadas específicamente a dicho grupo de archivos.

En cualquier momento, se designa un grupo de archivos como el grupo de archivos predeterminado (DEFAULT). Cuando se crean objetos en la base de datos sin especificar a qué grupo de archivos pertenecen, se asignan al grupo de archivos predeterminado. El grupo de archivos predeterminado debe ser lo suficientemente grande como para dar cabida a todos los objetos no asignados a un grupo de archivos definido por el usuario. En principio, el grupo de archivos principal será el grupo de archivos predeterminado.

El grupo de archivos predeterminado puede cambiarse mediante la instrucción ALTER DATABASE. Si se cambia el grupo de archivos predeterminado, todos los objetos no asignados a un grupo de archivos específico en el momento de su creación serán asignados a los archivos de datos del nuevo grupo de archivos predeterminado. No obstante, los objetos y las tablas del sistema no pasan a asignarse al nuevo grupo de archivos predeterminado, sino que siguen estando asignados al grupo de archivos principal.

El cambio del grupo de archivos predeterminado impide que los objetos de usuario que no se hayan creado específicamente en un grupo de archivos definido por un usuario compitan por el espacio con los objetos y las tablas del sistema.

3.3.2.2 Usar archivos y grupos de archivos

Los grupos de archivos utilizan una estrategia de relleno proporcional entre todos los archivos de cada grupo de archivos. A medida que se escriben datos en el grupo de archivos, Microsoft SQL Server escribe una cantidad proporcional al espacio libre del archivo en cada archivo del grupo, en lugar de escribir todos los datos en el primer archivo hasta que esté completo antes de pasar al archivo siguiente. Por ejemplo, si el archivo a1 tiene 100 MB de espacio libre y el archivo a2 tiene 200 MB libres, por cada cantidad de datos que se asigne al archivo a1, se asignará el doble al archivo a2 y así sucesivamente. De ese modo, los dos archivos se llenarán aproximadamente al mismo tiempo y se conseguirá una crear banda simple.

Cuando se llenan todos los archivos de un grupo de archivos, SQL Server expande automáticamente los archivos por turnos para que quepan más datos (siempre y cuando la base de datos esté configurada para crecer automáticamente). Por ejemplo, un grupo de archivos consta de tres archivos configurados para crecer automáticamente. Cuando se agota el espacio



de todos los archivos del grupo de archivos, sólo se expande el primer archivo. Cuando se llena el primer archivo y no se pueden escribir más datos en el grupo de archivos, se expande el segundo archivo. Cuando se llena el segundo archivo y no pueden escribirse más datos en el grupo de archivos, se expande el tercer archivo. Si se llena el tercer archivo y no se pueden escribir más datos en el grupo de archivos, se vuelve a expandir el primer archivo, y así sucesivamente.

El uso de archivos y grupos de archivos permite mejorar el rendimiento de la base de datos al permitir crear la base de datos en varios discos, varios controladores de disco o sistemas RAID (matriz redundante de discos independientes). Por ejemplo, si su equipo tiene cuatro discos, puede crear una base de datos que contenga tres archivos de datos y un archivo de registro, y mantener un archivo en cada disco. Cuando se produce un acceso a los datos, hay cuatro cabezales de lectura y escritura que pueden tener acceso a los datos a la vez, con lo que se aceleran las operaciones de la base de datos.

Además, los archivos y los grupos de archivos permiten la distribución de los datos, ya que puede crearse una tabla en un grupo de archivos específico. De ese modo se aumenta el rendimiento, dado que todas las E/S para una tabla específica pueden dirigirse a un disco determinado. Por ejemplo, una tabla que se utilice muy a menudo puede colocarse en un archivo de un grupo determinado de archivos y ubicarse en un disco. Otras tablas menos utilizadas de la base de datos pueden colocarse en archivos distintos de otro grupo de archivos, en un segundo disco.

Éstas son algunas recomendaciones generales referentes a los archivos y a los grupos de archivos:

• La mayor parte de las bases de datos funcionarán correctamente con un solo archivo de datos y un solo archivo de registro de transacciones.

• Si utiliza varios archivos, cree un segundo grupo de archivos para el archivo adicional y conviértalo en el grupo de archivos predeterminado. De ese modo, el archivo principal sólo contendrá objetos y tablas del sistema.

• Para aumentar al máximo el rendimiento, cree archivos o grupos de archivos en tantos discos físicos como estén disponibles y distribuya en grupos de archivos distintos los objetos que compitan intensamente por el espacio.

• Utilice grupos de archivos para disponer los objetos en discos físicos determinados. • Disponga en grupos de archivos distintos las diferentes tablas que se utilicen en las

mismas consultas de combinación. De ese modo mejorará el rendimiento, debido a la búsqueda que las operaciones de E/S realizan en paralelo en los discos para localizar datos combinados.

• Distribuya en grupos de archivos distintos las tablas de acceso frecuente y los índices no agrupados que pertenezcan a esas tablas. De ese modo mejorará el rendimiento, dado que las operaciones de E/S se realizan en paralelo si los archivos se encuentran en discos físicos distintos.

• No coloque el archivo o archivos de registro en el mismo disco físico que los demás archivos y grupos de archivos.



3.3.3.3 Usar archivos y grupos de archivos para administrar el crecimiento de las bases de datos

Cuando cree una base de datos mediante archivos y grupos de archivos, deberá especificar un tamaño inicial para el archivo. Microsoft SQL Server crea los archivos de datos y para ello se basa en el tamaño que se especifique. A medida que se agregan datos a la base de datos, estos archivos se van llenando. Sin embargo, debe tener presente si la base de datos va a crecer, y cómo, por encima del espacio inicial asignado, si se agregan más datos a la base de datos de los que caben en los archivos.

De forma predeterminada, SQL Server permite que los archivos de datos crezcan tanto como sea necesario hasta que se agote el espacio de disco. Por lo tanto, si los archivos de la base de datos no pudieran crecer más allá de los límites especificados cuando se creó la base de datos, deberá especificarse en el momento de su creación mediante el Administrador corporativo de SQL Server o la instrucción CREATE DATABASE.

Por otra parte, SQL Server le permite crear archivos de datos que pueden crecer automáticamente cuando se llenan, pero sólo hasta un tamaño máximo definido previamente. Así se puede evitar que las unidades de disco se queden sin espacio.

Recomendaciones

Cuando cree una base de datos, defina el mayor tamaño posible para los archivos de datos y tenga en cuenta la cantidad de datos máxima prevista para la base. Permita que los archivos de datos crezcan automáticamente, pero establezca un límite de crecimiento mediante la especificación de un tamaño máximo de crecimiento de los archivos de datos que deje algo de espacio disponible en el disco duro. De ese modo, la base de datos podrá crecer si se agregan más datos de los previstos, pero sin llegar a agotar completamente el espacio disponible en la unidad de disco. Si se supera el tamaño inicial del archivo de datos y el archivo empieza a crecer automáticamente, vuelva a realizar una previsión del tamaño máximo de la base de datos, agregue más espacio de disco (si es preciso) y cree más archivos o grupos de archivos y agréguelos a la base de datos.No obstante, si se establece que la base de datos no pueda crecer más allá de su tamaño inicial, configure el tamaño de crecimiento máximo de la base de datos con el valor cero. Así, los archivos de la base de datos no podrán crecer. Si los archivos de la base de datos se llenan, no podrán agregarse más datos hasta que se agreguen más archivos de datos a la base de datos o se expandan los archivos existentes.

Fragmentación de archivos

Al permitirse que los archivos crezcan automáticamente, se puede producir una fragmentación de esos archivos si un gran número de archivos comparten el mismo disco. Por lo tanto, se recomienda crear los archivos o los grupos de archivos en tantos discos físicos locales distintos como haya disponibles. Distribuya en grupos de archivos distintos los objetos que compitan de forma intensa por el espacio.

3.3.4 Grupos de archivos de sólo lectura.

Microsoft SQL Server permite marcar los grupos de archivos como de sólo lectura. Puede marcarse como de sólo lectura cualquier grupo de archivos, incluso el grupo de archivos principal. Un grupo de archivos marcado como de sólo lectura no puede ser modificado de ninguna forma. Si el grupo de archivos principal se marca como de sólo lectura, no se crearán nuevos objetos en



la base de datos. Por ejemplo, la creación de un nuevo objeto, como una tabla, una vista, un registro, un procedimiento almacenado o una recompilación automática de un procedimiento almacenado, actualiza las tablas del sistema. Esta actualización no sería posible si el grupo de archivos principal estuviera marcado como de sólo lectura.

Coloque las tablas que no deban modificarse (como las de datos históricos) en uno o varios grupos de archivos y, a continuación, márquelos como de sólo lectura. De ese modo, se evitarán actualizaciones accidentales. Puede hacer una copia de seguridad del grupo de archivos de sólo lectura y restaurarla en otro servidor en el que se ejecute SQL Server, sin preocuparse por la recuperación de los registros de transacciones.



3.3.4 Registros de transacciones

Una base de datos de Microsoft SQL Server tiene, como mínimo, un archivo de datos y un archivo de registro de transacciones. Los datos y la información del registro de transacciones nunca se mezclan en el mismo archivo, y cada archivo es utilizado por una sola base de datos.

SQL Server utiliza el registro de transacciones de cada base de datos para recuperar las transacciones. El registro de transacciones consiste en una serie de registros de todas las modificaciones de la base de datos y las transacciones que se han realizado en las modificaciones. En el registro de transacciones figura el inicio de cada transacción. También se registran los cambios de los datos y se facilita suficiente información para deshacer las modificaciones (si fuera necesario posteriormente) realizadas durante la transacción. Para algunas operaciones largas, como la de CREATE INDEX, el registro de transacciones sólo registra que se llevó a cabo la transacción. El registro crece continuamente a medida que se producen operaciones en la base de datos y éstas se registran. El registro de transacciones registra la asignación y cancelación de asignación de páginas y la confirmación o anulación de cada transacción. Esto permite a SQL Server aplicar (confirmar) o anular (deshacer) cada transacción de las siguientes maneras:

• Una transacción se confirma cuando usted aplica un registro de transacciones. SQL Server copia la imagen posterior de cada modificación en la base de datos o vuelve a ejecutar instrucciones como CREATE INDEX. Estas acciones se aplican en la misma secuencia que la de las acciones originales. Al finalizar este proceso, la base de datos se encuentra en el mismo estado en que estaba en el momento en que se realizó la copia de seguridad del registro de transacciones.

• Una transacción se deshace si invierte una transacción incompleta. SQL Server copia las imágenes previas de todas las modificaciones de la base de datos desde BEGIN TRANSACTION. Si encuentra registros de transacciones que indiquen que se ejecutó la instrucción CREATE INDEX, realizará las operaciones necesarias para invertir lógicamente la instrucción. Estas imágenes previas y las inversiones de CREATE INDEX se aplican en orden inverso al de la secuencia original.

En un punto de comprobación, SQL Server se asegura de que todos los registros de transacciones y todas las páginas de la base de datos que hayan sufrido modificaciones se escriban en el disco. Durante el proceso de recuperación de cada base de datos que se produce cuando se reinicia SQL Server, debe rehacerse una transacción únicamente cuando no se sabe si todas las modificaciones de los datos de la transacción se escribieron realmente en el disco desde la caché del búfer de SQL Server. Dado que un punto de comprobación fuerza a todas las páginas modificadas a grabarse en el disco, representa el punto en el que la recuperación de inicio debe empezar a rehacer transacciones. Debido a que se garantiza que todas las páginas modificadas antes del punto de comprobación están en el disco, no es necesario rehacer ninguna operación que se haya realizado antes del punto de comprobación.

3.3.4.1 Operaciones no registradas

Si la opción de la base de datos select into/bulkcopy (select into o copia masiva) está configurada con el valor TRUE (verdadero), Microsoft SQL Server no registrará los detalles completos de las operaciones siguientes en el registro de transacciones:

• Operaciones de carga masiva



• Instrucciones SELECT INTO • Instrucciones WRITETEXT • Instrucciones UPDATETEXT

Aunque estas operaciones no se registren, siempre se registran determinados cambios de las operaciones. Todas estas operaciones asignan una o varias páginas nuevas para contener los datos que agregan. Las asignaciones de páginas se registran, pero no así los detalles de los datos agregados en las páginas. SQL Server puede deshacer estas operaciones no registradas al invertir las asignaciones de páginas escritas en el registro. SQL Server no puede confirmar las operaciones, ya que en el registro no constan los datos que se deberían agregar en las páginas nuevas.

Como no es posible confirmar las operaciones no registradas, estas operaciones invalidan una secuencia de copias de seguridad del registro de transacciones. Debe realizarse una copia de seguridad completa o incremental de la base de datos después de una operación no registrada para comenzar una nueva secuencia de copias de seguridad del registro. Por lo tanto, si se produce una de estas operaciones, SQL Server permite que se realice una copia de seguridad del registro de transacciones, pero avisa de que debe realizarse antes una copia de seguridad de la base de datos con el fin de preservar los cambios en el caso de que deba restaurarse la base de datos.

3.3.4.2 Archivos de registro virtuales

Cada archivo de registro de transacciones se divide lógicamente en segmentos más pequeños, denominados archivos de registro virtuales. Los archivos de registro virtuales son las unidades de truncamiento del registro de transacciones. Cuando un archivo de registro virtual ya no contiene registros para transacciones activas, puede truncarse con el fin de que haya espacio suficiente para registrar nuevas transacciones.

El tamaño mínimo de un archivo de registro virtual es de 256 KB. El tamaño mínimo de un registro de transacciones es de 512 KB, lo que proporciona dos archivos de registro virtuales de 256 KB. El número y el tamaño de los archivos de registro virtuales en un archivo de transacciones se incrementa a medida que lo hace el archivo de registro. Un archivo de registro de pequeño tamaño puede tener un número reducido de pequeños archivos de registro virtuales (por ejemplo, un archivo de registro de 5 MB puede estar compuesto por cinco archivos virtuales de 1 MB). Un archivo de registro de gran tamaño tendrá archivos de registro virtuales más grandes (por ejemplo, un archivo de registro de 500 MB puede contener diez archivos de registro virtuales de 50 MB).

Microsoft SQL Server intenta evitar que haya muchos archivos de registro virtuales de pequeño tamaño. El número de archivos de registro virtuales crece mucho más lentamente que su tamaño. Si un archivo de registro crece en pequeños incrementos, tenderá a tener muchos archivos de registro virtuales de pequeño tamaño. Si el archivo de registro crece en incrementos mayores, SQL Server creará un número inferior de archivos de registro virtual de mayor tamaño. Por ejemplo, si el registro de transacciones está creciendo en incrementos de 1 MB, los archivos de registro virtuales serán menores y más numerosos que los de un registro de transacciones que crezca en incrementos de 50 MB. Un número elevado de archivos de registro virtuales puede aumentar el tiempo necesario para recuperar la base de datos.

A medida que se escribe en el registro, el final del registro crece y pasa de un archivo de registro virtual al siguiente. Si hay más de un archivo de registro físico para una base de datos, el final del registro crece a través de cada archivo de registro virtual antes de volver al primer archivo de registro virtual del primer archivo físico. El registro empezará a crecer automáticamente sólo cuando se hayan llenado todos los archivos de registro.



3.3.5 Consideraciones sobre el diseño de Base de Datos

Normalización

El diseño lógico de la base de datos, que incluye las tablas y sus relaciones, es la clave de una base de datos relacional optimizada. Un buen diseño lógico de la base de datos puede asentar los cimientos de un rendimiento óptimo de la aplicación y de la base de datos. Un diseño lógico deficiente puede comprometer el rendimiento de todo el sistema.

La normalización de un diseño lógico de base de datos implica la utilización de métodos formales para separar los datos en varias tablas relacionadas. Las bases de datos normalizadas se caracterizan por tener un mayor número de tablas estrechas (con pocas columnas). Un número escaso de tablas anchas (con más columnas) suele ser característico de las bases de datos no normalizadas.

Por lo general, una normalización razonable permitirá mejorar el rendimiento. Cuando se disponga de índices útiles, el optimizador de consultas de Microsoft SQL Server será una herramienta eficiente en la selección rápida y eficaz de combinaciones entre tablas.

La normalización ofrece diversas ventajas: • Mayor rapidez en la ordenación y en la creación de índices. • Un número mayor de índices agrupados. • Índices más estrechos y compactos. • Menos índices por tabla, con lo que se mejora el rendimiento de las instrucciones

INSERT, UPDATE y DELETE. • Menos valores NULL y reducción de las posibilidades de incoherencia, con lo que la base

de datos resulta más compacta.

A medida que progresa la normalización, aumentará el número y la complejidad de las combinaciones necesarias para recuperar los datos. Un número muy elevado de combinaciones relacionales complejas entre demasiadas tablas puede afectar al rendimiento. Una normalización razonable suele incluir un número reducido de consultas que se ejecutan con regularidad y utilizan combinaciones en las que intervienen más de cuatro tablas.

A veces, el diseño lógico de la base de datos es fijo y su remodelación resulta inviable. No obstante, incluso en esos casos puede normalizarse de forma selectiva una tabla de gran tamaño para crear tablas más pequeñas. Si el acceso a la base de datos se realiza mediante procedimientos almacenados, este cambio del esquema puede llevarse a cabo sin que afecte a las aplicaciones. De lo contrario, también puede crearse una vista que oculte a las aplicaciones el cambio de esquema.

En la teoría del diseño de bases de datos relacionales, las reglas de normalización identifican ciertos atributos que deben estar presentes o ausentes en una base de datos bien diseñada. Aunque una discusión completa de las reglas de normalización se sale del objetivo de este tema, hay algunas reglas que pueden ayudarle a mejorar el diseño de una base de datos:

• Una tabla debe tener un identificador. La regla fundamental en la teoría del diseño de bases de datos es que cada tabla tenga un sólo identificador de filas, una columna o un conjunto de columnas que puedan utilizarse para diferenciar a un registro de cualquier otro de la tabla. Cada tabla debe tener una columna de identificador, y el valor de cada identificador no debe ser compartido por dos registros. La columna o columnas que sirvan como identificador único de fila para una tabla constituyen la clave principal de la tabla.



• Una tabla sólo debe almacenar datos para un único tipo de entidad. Si intenta almacenar demasiada información en una tabla, la confiabilidad y la eficiencia en la administración de los datos de la tabla pueden verse afectadas. En el ejemplo anterior de la base de datos pubs, la información acerca de los títulos y de los editores se almacena en dos tablas distintas. Aunque es posible incluir columnas para la información acerca de los libros y de los editores en la tabla de títulos, este tipo de diseño entraña diversos problemas. La información acerca del editor debe ser agregada y almacenada de forma redundante para cada libro publicado por un editor. Con este sistema, la base de datos utiliza más espacio. Si cambia la dirección del editor, debe realizarse el cambio en cada libro. Cuando se quita de la tabla de títulos el último libro de un editor, se pierde la información de ese editor.

En la base de datos pubs, se almacena la información de los libros y editores en las tablas de títulos y editores. La información acerca del editor debe especificarse una sola vez y vincularse a cada libro. Cuando se modifica la información relativa al editor, deberá cambiarse únicamente en un punto, y se mantendrá allí aunque no haya títulos de ese editor en la base de datos.

• En una tabla deben evitarse las columnas que acepten valores NULL. Las tablas pueden tener columnas definidas para permitir valores NULL. Un valor NULL indica que no hay ningún valor. Si bien puede resultar útil permitir valores NULL en determinados casos, es preferible no utilizarlos muy a menudo, dado que necesitan un tratamiento especial que aumenta la complejidad de las operaciones con datos. Si tiene una tabla con varias columnas que aceptan valores NULL y varias filas tienen valores NULL en las columnas, conviene que considere la posibilidad de colocar esas columnas en otra tabla vinculada con la tabla principal. Si almacena los datos en dos tablas distintas, el diseño de la tabla principal será simple pero seguirá permitiendo almacenar ocasionalmente ese tipo de información.

• Una tabla no debe tener valores ni columnas que se repitan. La tabla para un elemento de la base de datos no debe contener una lista de valores para una información específica. Por ejemplo, en un libro que figura en la base de datos pubs pueden haber colaborado dos autores. Si sólo hay una columna para el nombre del autor en la tabla titles, esto supone un problema. Una solución consistiría en almacenar el nombre de los dos autores en la misma columna, pero eso dificultaría mostrar una lista de autores. Otra solución posible sería cambiar la estructura de la tabla para agregar otra columna para el nombre del segundo autor, pero esta solución sólo es válida cuando se trata de dos autores. Sería necesario agregar otra columna en los casos en que tres autores colaboraran en la creación de un libro.

Si cree que necesita almacenar una lista de valores en una sola columna, o si tiene varias columnas para representar el mismo tipo de datos (au_lname1, au_lname2, etc.), conviene que considere la colocación de los datos duplicados en otra tabla e incluya un vínculo con la tabla principal. La base de datos pubs tiene una tabla para la información acerca de los libros y otra en la que se almacenan únicamente los identificadores de los libros y de los autores. Este diseño permite la inclusión de un número indeterminado de autores para el mismo libro sin necesidad de modificar la definición de la tabla, y no asigna espacio de almacenamiento sin utilizar para los libros de un solo autor.



Integridad de los datos

La integridad de los datos garantiza la calidad de los datos de la base de datos. Por ejemplo, si se especifica para un empleado el valor de employee_id (IdEmpleado) “123”, la base de datos no debe permitir que ningún otro empleado tenga el mismo valor de identificador. Si tiene una columna employee_rating (clasificaciónEmpleado) para la que se prevea valores entre el 1 y el 5, la base de datos no debe aceptar el valor 6. Si en la tabla hay una columna dept_id (IdDepto) en la que se almacene el número de departamento del empleado, la base de datos sólo debe permitir valores que correspondan a los números de departamento de la compañía.

Dos pasos importantes en el diseño de las tablas son la identificación de valores válidos para una columna y la determinación de cómo forzar la integridad de los datos en la columna. Hay cuatro categorías de integridad de datos:

• Integridad de entidad • Integridad de dominio • Integridad referencial • Integridad definida por el usuario.

Hay varias maneras de forzar cada tipo de integridad.Tipo de integridad Opciones recomendadas

EntidadRestricción PRIMARY KEYRestricción UNIQUEPropiedad IDENTITY

Dominio

Definición predeterminada (DEFAULT)Restricción FOREIGN KEYRestricción CHECKNOT NULL

ReferencialRestricción FOREIGN KEYRestricción CHECK

Definidos por el usuarioTodas las restricciones en columnas y tablas de CREATE TABLEProcedimientos almacenadosDesencadenadores

Integridad de entidad

La integridad de entidad define una fila como entidad única para una tabla determinada. La integridad de entidad fuerza la integridad de la columna o columnas de los identificadores o la clave principal de una tabla (mediante índices, restricciones UNIQUE, restricciones PRIMARY KEY o propiedades IDENTITY).

Integridad de dominio

La integridad de dominio viene dada por la validez de las entradas para una columna determinada. Puede forzar la integridad de dominio si restringe el tipo (mediante tipos de datos), el formato (mediante las reglas y las restricciones CHECK), o el intervalo de valores posibles (mediante restricciones FOREIGN KEY, restricciones CHECK, definiciones DEFAULT, definiciones NOT NULL y reglas).

Integridad referencial

La integridad referencial protege las relaciones definidas entre las tablas cuando se crean o se eliminan registros. En Microsoft SQL Server, la integridad referencial se basa en las relaciones



entre las claves externas y las claves principales o entre las claves externas y las claves únicas. La integridad referencial garantiza que los valores clave son coherentes en las distintas tablas. Para conseguir esa coherencia, es preciso que no haya referencias a valores inexistentes y que, si cambia el valor de una clave, todas las referencias a ella se cambien en consecuencia en toda la base de datos.

Cuando se fuerza la integridad referencial, SQL Server impide a los usuarios: • Agregar registros a una tabla relacionada si no hay ningún registro asociado en la tabla

principal. • Cambiar valores en una tabla principal de manera que queden registros huérfanos en una

tabla relacionada. • Eliminar registros de una tabla principal cuando hay registros relacionados coincidentes.

Por ejemplo, con las tablas sales (compras) y titles (títulos) de la base de datos pubs, la integridad referencial se basa en la relación entre la clave externa (title_id) de la tabla sales y la clave principal (title_id) de la tabla titles.¡Error! Marcador no definido.

Integridad definida por el usuario

La integridad definida por el usuario le permite definir reglas de la compañía específicas que no pertenecen a ninguna otra categoría de integridad. Todas las categorías de integridad son compatibles con la integridad definida por el usuario.

Rendimiento de la base de datosCuando diseñe una base de datos, deberá asegurarse de que realice todas las operaciones importantes rápida y correctamente. Algunos problemas de rendimiento pueden resolverse cuando la base de datos ya se utiliza en la producción, pero otros pueden derivar de un diseño deficiente de la base de datos, y sólo es posible corregirlos si se cambia su estructura y diseño.

Cuando diseñe e implemente una base de datos, deberá identificar las tablas de gran tamaño y los procesos más complejos que vaya a realizar la base de datos, y prestar atención especial al rendimiento al diseñar esas tablas. Considere también los efectos que puede tener en el rendimiento el aumento del número de usuarios con acceso a la base de datos.

Los siguientes cambios, entre otros, pueden contribuir a mejorar el rendimiento:

• Si una tabla que contiene cientos de miles de filas tiene que resumirse en un informe diario, puede agregar una o varias columnas que contengan datos previamente agregados para utilizarlos únicamente en el informe.

• Se puede aplicar una normalización exhaustiva en las bases de datos, lo que significa que se definen un gran número de tablas pequeñas interrelacionadas. Cuando la base de datos procese los datos de estas tablas, deberá realizar muchas más operaciones para combinar los datos relacionados. Este procesamiento adicional puede repercutir negativamente en el rendimiento de la base de datos. En esos casos, una reducción de la normalización de la base de datos para simplificar procesos complejos puede contribuir a mejorar el rendimiento.

Además de un diseño adecuado de la base de datos, el uso correcto de los índices, sistemas RAID (matriz redundante de discos independientes) y los grupos de archivos es importante para conseguir un buen rendimiento.



Consideraciones acerca del hardware

Por lo general, cuanto mayor sea la base de datos, habrá más requisitos de hardware, aunque el número de sesiones o usuarios simultáneos, el rendimiento de las transacciones y el tipo de operaciones que se realicen en la base de datos también determinarán dichos requisitos. Por ejemplo, los requisitos de hardware de una base de datos que contenga datos que se actualicen con poca frecuencia (para una biblioteca escolar, por ejemplo), serán inferiores a los requisitos de hardware de un almacén de datos de 1 terabyte (TB) que contenga datos de acceso frecuente de ventas, productos y clientes de una gran compañía. Además de los requisitos de almacenamiento en disco, se necesitará más memoria y procesadores más rápidos para que el almacén de datos permita colocar más datos en memoria caché y para que las consultas con referencias a grandes cantidades de datos sean procesadas con rapidez por Microsoft SQL Server.

MantenimientoDespués de crear una base de datos, y cuando se hayan agregado y estén operativos todos los objetos y datos, será necesario realizar determinadas operaciones de mantenimiento. Por ejemplo, es importante realizar copias de seguridad de la base de datos periódicamente. Es posible que también necesite crear algunos índices adicionales para mejorar el rendimiento. Estas cuestiones deben tenerse en cuenta a la hora de diseñar la base de datos, con el fin de reducir los efectos en los usuarios, el tiempo necesario para realizar la tarea y el esfuerzo dedicado. A continuación, se ofrecen algunas indicaciones para el mantenimiento:

• Diseñar la base de datos para que sea lo más pequeña posible y excluya la información redundante. (La normalización de la base de datos puede ayudarle a conseguirlo). Por ejemplo, si reduce el tamaño de la base de datos, puede reducir también el tiempo necesario para realizar una copia de seguridad o, lo que es aún más importante, para restaurar la base de datos. Esto es especialmente importante durante una operación de restauración porque la base de datos no está disponible mientras está siendo restaurada.

• Diseñar particiones de tablas en vez de tablas únicas, si la tabla debe contener un gran número de filas. Por ejemplo, una tabla que contenga todas las transacciones realizadas con tarjeta de crédito que recibe un banco debe dividirse en varias tablas en las que se distribuyan los datos por meses, por ejemplo. Así se puede facilitar el mantenimiento de los índices, en el caso de que tuvieran que agregarse nuevos índices para mejorar el rendimiento. Puede que sea necesario crear el índice sólo para los datos de los últimos tres meses, debido a que ya no se hace referencia a los datos más antiguos. Cuanto mayor sea la tabla, más tiempo se necesitará para crear nuevos índices.

Microsoft SQL Server proporciona el Asistente para planes de mantenimiento de bases de datos con el fin de automatizar muchas de estas tareas, con lo que se reduce o se elimina el trabajo necesario para el mantenimiento de la base de datos.

3.3.6 Estimar el tamaño de una base de datosCuando diseñe la base de datos, puede que necesite realizar una estimación del tamaño que tendrá la base de datos cuando esté llena. Esta estimación puede ayudarle a determinar la configuración de hardware que necesitará para:

• Conseguir el rendimiento que necesitan sus aplicaciones. • Asegurar la cantidad física adecuada de espacio en disco para almacenar los datos y los

índices.

Asimismo, la estimación del tamaño de la base de datos puede ayudarle a determinar si el diseño de su base de datos necesita reajustes. Por ejemplo, puede determinar que el tamaño estimado



es demasiado grande para realizar una implementación práctica en su organización y que se necesita un mayor grado de normalización. Por el contrario, el tamaño estimado puede ser menor del esperado, con lo que podrá reducir la normalización de la base de datos para mejorar el rendimiento de las consultas.

Para realizar una estimación del tamaño de una base de datos, efectúe una estimación de cada tabla por separado y sume los valores obtenidos. El tamaño de una tabla depende de si tiene índices y, si los tiene, qué tipo de índices.

Estimar el tamaño de una tabla

Los siguientes pasos permiten estimar la cantidad de espacio necesario para almacenar los datos en una tabla:

1. Especifique el número de filas que habrá en la tabla. Número de filas de la tabla = númFilas

2. Si la definición de la tabla contiene columnas de longitud fija y de longitud variable, calcule el espacio que ocupa cada uno de estos grupos de columnas en la fila de datos. El tamaño de una columna depende del tipo y de la longitud especificados para los datos. Número de columnas = númCols Suma de los bytes de todas las columnas de longitud fija = datosTñoFijo Número de columnas de longitud variable = númColsVariables Tamaño máximo de todas las columnas de longitud variable = tñoMáxVar

3. Si hay columnas de longitud fija en la tabla, una parte de la fila, conocida como el mapa de bits nulo, se reserva para administrar la aceptación de valores nulos en las columnas. Calcule su tamaño: Mapa de bits nulo (mapaBitsNulo) = 2 + (( númCols + 7) / 8 ) Sólo debe utilizarse la parte entera de la expresión anterior; descarte el resto.

4. Si hay columnas de longitud variable en la tabla, determine cuánto espacio se utiliza para almacenar las columnas de la fila: Tamaño total de las columnas de longitud variable (datosTñoVar) = 2 + (númColsVariables x 2) + tñoMáxVar Si no hay columnas de longitud variable, establezca datosTñoVar al valor 0. En esta fórmula, se supone que todas las columnas de longitud variable están llenas al 100 %. Si prevé que va a utilizarse un porcentaje inferior del espacio de almacenamiento de las columnas de longitud variable, puede ajustar el resultado en función de ese porcentaje para obtener una estimación más precisa del tamaño de la tabla.

5. Calcule el tamaño de la fila: Tamaño total de la fila (tñoFila) = datosTñoFijo + datosTñoVar + mapaBitsNulo +4 El valor final 4 representa al encabezado de la fila de datos.

6. A continuación, calcule el número de filas por página (8096 bytes disponibles por página): Número de filas por página (filasPorPág) = ( 8096 ) / (tñoFila + 2) Dado que las filas no abarcan varias páginas, el número de filas por página debe redondearse a la fila completa anterior.

7. Si va a crear un índice agrupado en la tabla, calcule el número de filas libres reservadas por página según el factor de relleno especificado. Si no va a crear ningún índice agrupado, establezca factorRelleno al valor 100. Número de filas libres por página (filasLibresPorPág) = 8096 x ((100 - factorRelleno) / 100) / tñoFila El factor de relleno que se utiliza en el cálculo es un valor entero y no un porcentaje. Dado que las filas no abarcan varias páginas, el número de filas por página debe redondearse a la fila completa anterior.

8. Calcule el número de páginas necesarias para almacenar todas las filas: Número de páginas (númPágs) = númFilas / (filasPorPág - filasLibresPorPág) El número de páginas estimado debe redondearse a la siguiente página completa.



9. Finalmente, calcule la cantidad de espacio necesario para almacenar los datos en una tabla (8192 bytes por página): Tamaño de la tabla (bytes) = 8192 x númPágs

Estimar el tamaño de una tabla sin un índice agrupado

Los siguientes pasos permiten estimar la cantidad de espacio necesario para almacenar los datos y los índices no agrupados adicionales en una tabla que no contiene un índice agrupado:

1. Calcule el espacio utilizado para almacenar datos. 2. Calcule el espacio utilizado para almacenar cada índice no agrupado adicional. 3. Sume los valores calculados.

Para cada cálculo, especifique el número de filas que habrá en la tabla. El número de filas de la tabla influirá directamente en el tamaño de la tabla.Número de filas de la tabla = númFilas

Calcular el espacio utilizado para almacenar datos

Para calcular el espacio utilizado para almacenar datos, consulte Estimar el tamaño de una tabla. Anote el valor calculado:Espacio utilizado para almacenar datos = espacioDatosUtilizado

Calcular el espacio utilizado para almacenar cada índice no agrupado adicional

Los siguientes pasos permiten estimar el tamaño de un índice no agrupado en una tabla que no contiene un índice agrupado:

1. Si la definición del índice contiene columnas de longitud fija y de longitud variable, calcule el espacio que ocupa cada uno de estos grupos de columnas en la fila del índice. El tamaño de una columna depende del tipo y de la longitud especificados para los datos. Para obtener más información, consulte Tipos de datos Número de columnas de la clave del índice = númColsClave Suma de los bytes de todas las columnas de clave de longitud fija = tñoFijoClave Número de columnas de longitud variable de la clave del índice = númColsVarClave Tamaño máximo de todas las columnas de clave de longitud variable = tñoVarMáxClave

2. Si hay columnas de longitud fija en el índice, una parte de la fila del índice se reserva para el mapa de bits nulo. Calcule su tamaño: Mapa de bits nulo del índice (mapaBitsNuloÍnd) = 2+ (( númColsClave + 7) / 8 ) Sólo debe utilizarse la parte entera de la expresión anterior; descarte el resto.

3. Si hay columnas de longitud variable en el índice, determine cuánto espacio se utiliza para almacenar las columnas de la fila del índice: Tamaño total de las columnas de longitud variable (tñoVarClave) = 2 + (númColsVarClave x 2) + tñoVarMáxClave Si no hay columnas de longitud variable, establezca tñoVarClave al valor 0. En esta fórmula, se supone que todas las columnas de clave de longitud variable están llenas al cien por cien. Si prevé que va a utilizarse un porcentaje inferior del espacio de almacenamiento de las columnas de clave de longitud variable, puede ajustar el resultado en función de ese porcentaje para obtener una estimación más precisa del tamaño del índice.

4. Calcule el tamaño de la fila del índice: Tamaño total de la fila del índice (tñoFilaÍnd) = tñoFijoClave + tñoVarClave + mapaBitsNuloÍnd + 1 + 8

5. A continuación, calcule el número de filas de índice por página (8096 bytes libres por página):



Número de filas de índice por página (filasÍndPorPág) = ( 8096 ) / (tñoFilaÍnd + 2) Dado que las filas de índice no abarcan varias páginas, el número de filas de índice por página debe redondearse a la fila completa anterior.

6. Calcule el número de filas de índice libres reservadas por página de hoja según el factor de relleno especificado para el índice no agrupado. Para obtener más información, consulte Factor de relleno. Número de filas de índice libres por página de hoja (filasÍndLibresPorPág) = 8096 x ((100 - factorRelleno) / 100) / tñoFilaÍnd El factor de relleno que se utiliza en el cálculo es un valor entero y no un porcentaje. Dado que las filas de índice no abarcan varias páginas, el número de filas de índice por página debe redondearse a la fila completa anterior.

7. A continuación, calcule el número de páginas necesarias para almacenar todas las filas en cada nivel del índice: Número de páginas (nivel 0) (númPágsNivel0) = númFilas / (filasÍndPorPág - filasÍndLibresPorPág) Número de páginas (nivel 1) (númPágsNivel1) = númPágsNivel0 / filasÍndPorPág Repita el segundo cálculo, pero divida el número de páginas calculado a partir del nivel anterior n por filasÍndPorPág hasta que el número de páginas para un nivel n dado (númPágsNiveln) sea igual a una (página raíz). Por ejemplo, para calcular el número de páginas necesarias para el segundo nivel del índice: Número de páginas (nivel 2) (númPágsNivel2) = númPágsNivel1 / filasÍndPorPág Para cada nivel, el número estimado de páginas debe redondearse a la siguiente página completa. Sume el número de páginas necesarias para almacenar cada nivel del índice: Número total de páginas (númPágsÍnd) = númPágsNivel0 + númPágsNivel1 + númPágsNivel2 + … + númPágsNiveln

8. Finalmente, calcule el tamaño del índice (8192 bytes por página): Tamaño del índice no agrupado (bytes) = 8192 x númPágsÍnd

Calcular el tamaño de la tabla

Calcule el tamaño de la tabla:Tamaño total de la tabla (bytes) = espacioDatosUtilizado + Tamaño del índice no agrupado + …n

Estimar el tamaño de una tabla con un índice agrupado

Los siguientes pasos permiten estimar la cantidad de espacio necesario para almacenar los datos y los índices no agrupados adicionales en una tabla que contiene un índice agrupado:

1. Calcule el espacio utilizado para almacenar datos. 2. Calcule el espacio utilizado para almacenar el índice agrupado. 3. Calcule el espacio utilizado para almacenar cada índice no agrupado adicional. 4. Sume los valores calculados.

Para cada cálculo, especifique el número de filas que habrá en la tabla. El número de filas de la tabla influirá directamente en el tamaño de la tabla.Número de filas de la tabla = númFilas

Calcular el espacio utilizado para almacenar datos

Para calcular el espacio utilizado para almacenar datos, consulte Estimar el tamaño de una tabla. Anote el valor calculado:



Espacio utilizado para almacenar datos = espacioDatosUtilizado

Calcular el espacio utilizado para almacenar el índice agrupado

Los siguientes pasos permiten estimar la cantidad de espacio necesario para almacenar el índice agrupado:

1. La definición del índice agrupado puede contener columnas de longitud fija y de longitud variable. Para estimar el tamaño del índice agrupado, deberá especificar el espacio que ocupa cada uno de estos grupos de columnas en la fila del índice. Número de columnas de la clave del índice = númColsClaveAgr Suma de los bytes de todas las columnas de clave de longitud fija = tñoFijoClaveAgr Número de columnas de longitud variable de la clave del índice = númColsVarClaveAgr Tamaño máximo de todas las columnas de clave de longitud variable = tñoVarMáxClaveAgr

2. Si hay columnas de longitud fija en el índice agrupado, una parte de la fila del índice se reserva para el mapa de bits nulo. Calcule su tamaño: Mapa de bits nulo del índice (mapaBitsNuloÍndAgr) = 2 + (( númColsClaveAgr + 7) / 8 ) Sólo debe utilizarse la parte entera de la expresión anterior; descarte el resto.

3. Si hay columnas de longitud variable en el índice, determine cuánto espacio se utiliza para almacenar las columnas de la fila del índice: Tamaño total de las columnas de longitud variable (tñoVarClaveAgr) = 2 + (númColsVarClaveAgr x 2) + tñoVarMáxClaveAgr Si no hay columnas de longitud variable, establezca tñoVarClaveAgr al valor 0. En esta fórmula, se supone que todas las columnas de la clave de longitud variable están llenas al cien por cien. Si prevé que va a utilizarse un porcentaje inferior del espacio de almacenamiento de las columnas de la clave de longitud variable, puede ajustar el resultado en función de ese porcentaje para obtener una estimación más precisa del tamaño del índice.

4. Calcule el tamaño de la fila del índice: Tamaño total de la fila del índice (tñoFilaÍndAgr) = tñoFijoClaveAgr + tñoVarClaveAgr + mapaBitsNuloÍndAgr + 1 + 8

5. A continuación, calcule el número de filas de índice por página (8096 bytes libres por página): Número de filas de índice por página (filasÍndAgrPorPág) = ( 8096 ) / (tñoFilaÍndAgr + 2) Dado que las filas de índice no abarcan varias páginas, el número de filas de índice por página debe redondearse a la fila completa anterior.

6. A continuación, calcule el número de páginas necesarias para almacenar todas las filas en cada nivel del índice: Número de páginas (nivel 0) (númPágsNivelAgr0) = (espacioDatosUtilizado / 8192) / filasÍndAgrPorPág Número de páginas (nivel 1) (númPágsNivelAgr1) = númPágsNivelAgr0 / filasÍndAgrPorPág Repita el segundo cálculo, pero divida el número de páginas calculado a partir del nivel anterior n por filasÍndAgrPorPág hasta que el número de páginas para un nivel n dado (númPágsNivelAgrn) sea igual a una (página raíz del índice). Por ejemplo, para calcular el número de páginas necesarias para el segundo nivel del índice: Número de páginas (nivel 2) (númPágsNivelAgr2) = númPágsNivelAgr1 / filasÍndAgrPorPág Para cada nivel, el número estimado de páginas debe redondearse a la siguiente página completa. Sume el número de páginas necesarias para almacenar cada nivel del índice: Número total de páginas (númPágsÍndAgr) = númPágsNivelAgr0 + númPágsNivelAgr1 +númPágsNivelAgr2 + … + númPágsNivelAgrn

7. Calcule el tamaño del índice agrupado (8192 bytes por página):



Tamaño del índice agrupado (bytes) = 8192 x númPágsÍndAgr

Calcular el espacio utilizado para almacenar cada índice no agrupado adicional

Los siguientes pasos permiten estimar la cantidad de espacio necesario para almacenar cada índice no agrupado adicional:

1. La definición del índice no agrupado puede contener columnas de longitud fija y de longitud variable. Para estimar el tamaño del índice no agrupado, deberá calcular el espacio que ocupa cada uno de estos grupos de columnas en la fila del índice. Número de columnas de la clave del índice = númColsClave Suma de los bytes de todas las columnas de la clave de longitud fija = tñoFijoClave Número de columnas de longitud variable de la clave del índice = númColsVarClave Tamaño máximo de todas las columnas de clave de longitud variable = tñoVarMáxClave

2. Si hay columnas de longitud fija en el índice, una parte de la fila del índice se reserva para el mapa de bits nulo. Calcule su tamaño: Mapa de bits nulo del índice (mapaBitsNuloÍnd) = 2 + (( númColsClave + 7) / 8 ) Sólo debe utilizarse la parte entera de la expresión anterior; descarte el resto.

3. Si hay columnas de longitud variable en el índice, determine cuánto espacio se utiliza para almacenar las columnas de la fila del índice: Tamaño total de las columnas de longitud variable (tñoVarClave) = 2 + (númColsVarClave x 2) + tñoVarMáxClave Si no hay columnas de longitud variable, establezca tñoVarClave al valor 0. En esta fórmula, se supone que todas las columnas de la clave de longitud variable están llenas al cien por cien. Si prevé que va a utilizarse un porcentaje inferior del espacio de almacenamiento de las columnas de la clave de longitud variable, puede ajustar el resultado en función de ese porcentaje para obtener una estimación más precisa del tamaño del índice.

4. Calcule el tamaño de la fila del índice que no es una hoja: Tamaño total de la fila del índice no de hoja (tñoFilaÍndNH) = tñoFijoClave + tñoVarClave + mapaBitsNuloÍnd + 1 + 8

5. A continuación, calcule el número de filas de índice que no es hoja por página: Número de filas de índice no de hoja por página (filasÍndNHPorPág) = ( 8096 ) / (tñoFilaÍndNH + 2) Dado que las filas de índice no abarcan varias páginas, el número de filas de índice por página debe redondearse a la fila completa anterior.

6. Calcule el tamaño de la fila del índice de hoja: Tamaño total de la fila del índice de hoja (tñoFilaÍnd) = tñoFilaÍndAgr + tñoFijoClave + tñoVarClave + mapaBitsNuloÍnd + 1 El valor final 1 representa el encabezado de la fila del índice. tñoFilaÍndAgr es el tamaño total de la fila del índice para la clave del índice agrupado.

7. A continuación, calcule el número de filas de índice de nivel de hoja por página: Número de filas de índice de nivel de hoja por página (filasÍndPorPág) = ( 8096 ) / (tñoFilaÍnd + 2) Dado que las filas de índice no abarcan varias páginas, el número de filas de índice por página debe redondearse a la fila completa anterior.

8. Calcule el número de filas de índice libres reservadas por página según el factor de relleno especificado para el índice no agrupado. Para obtener más información, consulte Factor de relleno. Número de filas de índice libres por página (filasÍndLibresPorPág) = 8096 x ((100 - factorRelleno) / 100) / tñoFilaÍnd El factor de relleno que se utiliza en el cálculo es un valor entero y no un porcentaje. Dado que las filas de índice no abarcan varias páginas, el número de filas de índice por página debe redondearse a la fila completa anterior.



9. A continuación, calcule el número de páginas necesarias para almacenar todas las filas en cada nivel del índice: Número de páginas (nivel 0) (númPágsNivel0) = númFilas / (filasÍndPorPág - filasÍndLibresPorPág) Número de páginas (nivel 1) (númPágsNivel1) = númPágsNivel0 / filasÍndNHPorPág Repita el segundo cálculo, pero divida el número de páginas calculado a partir del nivel anterior n por filasÍndNHPorPág hasta que el número de páginas para un nivel n dado (númPágsNiveln) sea igual a una (página raíz). Por ejemplo, para calcular el número de páginas necesarias para los niveles segundo y tercero del índice: Número de páginas de datos (nivel 2) (númPágsNivel2) = númPágsNivel1 / filasÍndNHPorPág Número de páginas de datos (nivel 3) (númPágsNivel3) = númPágsNivel2 / filasÍndNHPorPág Para cada nivel, el número estimado de páginas debe redondearse a la siguiente página completa. Sume el número de páginas necesarias para almacenar cada nivel del índice: Número total de páginas (númPágsÍnd) = númPágsNivel0 + númPágsNivel1 +númPágsNivel2 + … + númPágsNiveln

10. Finalmente, calcule el tamaño del índice no agrupado: Tamaño del índice no agrupado (bytes) = 8192 x númPágsÍnd

Calcular el tamaño de la tabla

Calcule el tamaño de la tabla:Tamaño total de la tabla (bytes) = espacioDatosUtilizado + Tamaño del índice agrupado + Tamaño del índice no agrupado + …n



3.4 Crear Bases de datos

Crea una nueva base de datos y los archivos que se utilizan para almacenar la base de datos o adjunta una base de datos desde los archivos de una base de datos creada anteriormente.

Sintaxis

CREATE DATABASE nombreBaseDatos[ ON [PRIMARY][ <filespec> [,…n] ][, <grupoArchivos> [,…n] ]][ LOG ON { <filespec> [,…n]} ][ FOR LOAD | FOR ATTACH ]<filespec> ::=( [ NAME = nombreArchivoLógico, ]FILENAME = 'nombreArchivoSO'[, SIZE = tamaño][, MAXSIZE = { tamañoMáximo | UNLIMITED } ][, FILEGROWTH = incrementoCrecimiento] ) [,…n]<grupoArchivos>::=FILEGROUP nombreGrupoArchivos <filespec> [,…n]

Argumentos

nombreBaseDatos

Es el nombre de la nueva base de datos. Los nombres de base de datos deben ser únicos en un servidor y deben seguir las reglas de los identificadores. nombreBaseDatos puede tener hasta 128 caracteres, a menos que no se especifique ningún nombre lógico para el registro. Si no se especifica ningún nombre lógico de archivo de registro, Microsoft SQL Server genera un nombre lógico al anexar un sufijo a nombreBaseDatos. Esto limita nombreBaseDatos a 123 caracteres, por lo que el nombre lógico generado del archivo de registro es menor de 128 caracteres.

ON

Especifica que los archivos de disco utilizados para almacenar la parte de datos de la base de datos (archivos de datos) se han definido explícitamente. La palabra clave va seguida de una lista delimitada por comas de elementos <filespec> que definen los archivos de datos del grupo de archivos principal. A continuación de la lista de archivos del grupo de archivos principal se puede colocar una lista opcional, delimitada por comas, de elementos <grupoArchivos> que definen los grupos de archivos de usuario y sus archivos.

PRIMARY

Especifica que la lista <filespec> asociada define el archivo principal. El grupo de archivos principal contiene todas las tablas del sistema de base de datos. También contiene todos los objetos no asignados a los grupos de archivos de usuario. La primera entrada <filespec> del grupo de archivos principal pasa a ser el archivo principal, que es el archivo que contiene el inicio lógico de la base de datos y las tablas del sistema. Una base de datos sólo puede tener un archivo principal. Si no se especifica PRIMARY, el primer archivo enumerado en la instrucción CREATE DATABASE se convierte en el archivo principal.

n



Es un marcador de posición que indica que se pueden especificar múltiples archivos para la nueva base de datos.

LOG ON

Especifica que los archivos del disco utilizados para almacenar el registro de la base de datos (archivos de registro) se han definido explícitamente. La palabra clave va seguida de una lista delimitada por comas de elementos <filespec> que definen los archivos de registro. Si no se especifica LOG ON, se crea automáticamente un único archivo de registro con un nombre generado por el sistema y un tamaño que es el 25 por ciento de la suma de los tamaños de todos los archivos de datos de la base de datos.

FOR LOAD

Esta cláusula se mantiene por compatibilidad con las versiones anteriores de Microsoft SQL Server. La base de datos se crea con la opción de base de datos dbo use only activada y el estado se establece en "cargando". Esto no es necesario en SQL Server versión 7.0 porque la instrucción RESTORE puede volver a crear una base de datos como parte de la operación de restauración.

Si adjunta una base de datos a un servidor distinto del que se separó la base de datos y la base de datos separada estaba habilitada para duplicación, debe ejecutar sp_removedbreplication para quitar la duplicación de la base de datos.

FOR ATTACH

Especifica que se ha adjuntado una base de datos desde un conjunto existente de archivos del sistema operativo. Debe haber una entrada <filespec> que especifique el primer archivo principal. De las restantes entradas <filespec>, las únicas necesarias son las de cualquier otro archivo que tenga una ruta de acceso distinta de cuando se creó la base de datos por primera vez o se adjuntó por última vez. Debe especificarse una entrada <filespec> para estos archivos. La base de datos que se está adjuntando debe haberse creado mediante la misma página de códigos y ordenación que SQL Server. Utilice el procedimiento almacenado del sistema sp_attach_db en lugar de emplear CREATE DATABASE FOR ATTACH directamente. Utilice CREATE DATABASE FOR ATTACH sólo cuando deba especificar más de 16 elementos <filespec>.

NAME

Especifica el nombre lógico del archivo definido por <filespec>. El parámetro NAME no se requiere cuando se especifica FOR ATTACH.

nombreArchivoLógico

Es el nombre utilizado para hacer referencia al archivo en las instrucciones Transact-SQL que se ejecuten después de que se haya creado la base de datos. nombreArchivoLógico debe ser único en la base de datos y debe seguir las reglas de los identificadores. El nombre puede ser un carácter o una constante Unicode, o un identificador regular o delimitado.

FILENAME

Especifica el nombre de archivo del sistema operativo del archivo definido por <filespec>.

'nombreArchivoSO'

Es la ruta de acceso y nombre de archivo que el sistema operativo utiliza cuando crea el archivo físico definido por <filespec>. La ruta de acceso de nombreArchivoSO debe especificar un



directorio en el servidor en el que está instalado SQL Server. nombreArchivoSO no puede especificar un directorio en un sistema comprimido de archivos.

Si el sistema se crea en una partición sin formato, nombreArchivoSO sólo debe indicar la letra de la unidad de una partición sin formato existente. En cada partición sin formato sólo se puede crear un archivo. Los archivos de las particiones sin formato no aumentan automáticamente; por tanto, los parámetros MAXSIZE y FILEGROWTH no son necesarios cuando nombreArchivoSO especifica una partición sin formato.

SIZE

Especifica el tamaño del archivo definido en <filespec>. Cuando en <filespec> no se especifica un parámetro SIZE para el archivo principal, SQL Server utiliza el tamaño del archivo principal de la base de datos model. Cuando en <filespec> no se especifica un parámetro SIZE para un archivo secundario o de registro, SQL Server hace el archivo de 1 MB.

tamaño

Es el tamaño inicial del archivo definido en <filespec>. Se pueden utilizar los sufijos KB y MB para especificar si se trata de kilobytes o megabytes; el valor predeterminado es MB. Especifique un número entero; no incluya decimales. El valor mínimo de tamaño es 512 KB. Si no se especifica tamaño, el valor predeterminado es 1 MB. El tamaño especificado para el archivo principal debe tener al menos el tamaño del archivo principal de la base de datos model.

MAXSIZE

Especifica el tamaño máximo al que puede aumentar el archivo definido en <filespec>.

tamañoMáximo

Es el tamaño máximo al que puede aumentar el archivo definido en <filespec>. Se pueden utilizar los sufijos KB y MB para especificar si se trata de kilobytes o megabytes; el valor predeterminado es MB. Especifique un número entero; no incluya decimales. Si tamañoMáximo no se especifica, el archivo aumenta hasta que el disco esté lleno.

Nota El registro del sistema S/B de Microsoft Windows NT avisa al administrador del sistema SQL Server cuando un disco esté a punto de llenarse.

UNLIMITED

Especifica que el archivo definido en <filespec> aumenta hasta que el disco esté lleno.

FILEGROWTH

Especifica el incremento de crecimiento del archivo definido en <filespec>. El valor FILEGROWTH de un archivo no puede exceder del valor MAXSIZE.

incrementoCrecimiento

Es la cantidad de espacio que se agrega al archivo cada vez que se necesita espacio. Especifique un número entero; no incluya decimales. Un valor 0 indica que no hay aumento de tamaño. El valor se puede especificar en MB, KB o %. Si se especifica un número sin los sufijos



MB, KB o %, el valor predeterminado es MB. Cuando se especifica %, el tamaño de incremento de crecimiento es el porcentaje especificado del tamaño del archivo en el momento en que tiene lugar el incremento. Si no se especifica FILEGROWTH, el valor predeterminado es 10% y el valor mínimo es 64 KB. El tamaño especificado se redondea al múltiplo de 64 KB más cercano.

Observaciones

Puede utilizar una instrucción CREATE DATABASE para crear una base de datos y los archivos que almacenan la base de datos. SQL Server implementa la instrucción CREATE DATABASE en dos pasos:

1. SQL Server utiliza una copia de la base de datos model para inicializar la base de datos y sus metadatos.

2. SQL Server rellena el resto de la base de datos con páginas vacías, excepto las páginas que tengan datos internos que registren cómo se emplea el espacio en la base de datos.

Cualquier objeto definido por el usuario de la base de datos model se copiará a todas las bases de datos recién creadas. Puede agregar a la base de datos model cualquier objeto (como tablas, procedimientos almacenados, tipos de datos, etc.) que desee tener en todas las bases de datos.

Cada base de datos nueva hereda los valores opcionales de la base de datos model (a menos que se especifique FOR ATTACH). Por ejemplo, la opción de base de datos select into o copia masiva se ha establecido como OFF en model y en cualquier base de datos nueva que se cree. Si utiliza sp_dboption para cambiar las opciones de la base de datos model, estos valores de opción entrarán en efecto para cualquier base de datos nueva que se cree. Si se especifica FOR ATTACH en la instrucción CREATE DATABASE, la nueva base de datos hereda los valores opcionales de la base de datos original.

En un servidor se puede especificar un máximo de 32767 bases de datos.

Para almacenar una base de datos se emplean tres tipos de archivos: • El archivo principal contiene la información de inicio de la base de datos. El archivo

principal se utiliza también para almacenar datos. Cada base de datos tiene un único archivo principal.

• Los archivos secundarios almacenan todos los datos que no caben en el archivo principal de datos. Las bases de datos no necesitan archivos de datos secundarios si el archivo principal es suficientemente grande para contener todos los datos de la base de datos. Otras bases de datos pueden ser suficientemente grandes para necesitar múltiples archivos de datos secundarios o pueden utilizar archivos secundarios en discos separados para repartir los datos entre múltiples discos.

• Los archivos del registro de transacciones contienen la información del registro que se utiliza para recuperar la base de datos. Debe haber al menos un archivo de registro de transacciones para cada base de datos, aunque puede haber más de uno. El tamaño mínimo de un archivo de registro de transacciones es de 512 KB.

Cada base de datos tiene al menos dos archivos, un archivo principal y un archivo de registro de transacciones.

Aunque nombreArchivoSO puede ser cualquier nombre de archivo válido del sistema operativo, el nombre reflejará más claramente el propósito del archivo si utiliza las siguientes extensiones recomendadas.

Tipo de archivo Extensión de nombre de archivo recomendadaArchivo de datos principal .mdfArchivo de datos secundario .ndfArchivo de registro de transacciones .ldf



Nota Cada vez que se cree una base de datos de usuario, debe hacerse una copia de seguridad de la base de datos master.

No es posible especificar fracciones en los parámetros SIZE, MAXSIZE y FILEGROWTH. Para especificar una fracción de un megabyte en los parámetros de tamaño, conviértalos a kilobytes; para ello, multiplique el número por 1024. Por ejemplo, especifique 1536 KB en lugar de 1,5 MB (1,5 por 1024 es igual a 1536).

Cuando se especifica una instrucción individual CREATE DATABASE nombreBaseDatos sin parámetros adicionales, la base de datos se crea con el mismo tamaño que la base de datos model.

Todas las bases de datos tienen al menos un grupo de archivos principal. Todas las tablas del sistema se encuentran en el grupo de archivos principal. Una base de datos puede tener también grupos de archivos definidos por el usuario. Si se crea un objeto con una cláusula ON grupoArchivos que especifica un grupo de archivos definido por el usuario, todas las páginas del objeto se asignan desde el grupo de archivos especificado. Las páginas de todos los objetos de usuario creados sin una cláusula ON grupoArchivos, o con una cláusula ON DEFAULT, se asignan desde el grupo de archivos predeterminado. Cuando se crea una base de datos por primera vez, el grupo de archivos principal es el grupo de archivos predeterminado. Con ALTER DATABASE, se puede especificar que un grupo de archivos definido por el usuario sea el grupo de archivos predeterminado:

ALTER DATABASE nombreBaseDatos MODIFY FILEGROUP nombreGrupoArchivos DEFAULT

Cada base de datos tiene un propietario con capacidad para realizar actividades especiales en la base de datos. El propietario es el usuario que crea la base de datos. El propietario de la base de datos se puede cambiar mediante sp_changedbowner.

Para mostrar un informe de una base de datos o de todas las bases de datos de un servidor con SQL Server, ejecute sp_helpdb. Para obtener un informe acerca del espacio utilizado en una base de datos, emplee sp_spaceused. Para obtener un informe de los grupos de archivos de una base de datos, utilice sp_helpfilegroup, y utilice sp_helpfile para obtener el informe de los archivos de la base de datos.

Las versiones anteriores de SQL Server utilizaban las instrucciones DISK INIT para crear los archivos de la base de datos antes de que se ejecutara la instrucción CREATE DATABASE. Por motivos de compatibilidad con las versiones anteriores de SQL Server, la instrucción CREATE DATABASE puede crear también una nueva base de datos con archivos o dispositivos que se crearon con la instrucción DISK INIT.

Permisos

De forma predeterminada, los permisos de CREATE DATABASE son los de los miembros de las funciones fijas de servidor sysadmin y dbcreator. Los miembros de las funciones fijas de servidor sysadmin y securityadmin pueden conceder permisos CREATE DATABASE a otros inicios de sesión. Los miembros de las funciones fijas de servidor sysadmin y dbcreator pueden agregar otros inicios de sesión a la función dbcreator. El permiso CREATE DATABASE debe concederse explícitamente; no se concede mediante la instrucción GRANT ALL.

El permiso CREATE DATABASE se limita normalmente a unos cuantos inicios de sesión para mantener el control de la utilización de los discos del equipo que ejecuta SQL Server.



Ejemplos

A. Crear una base de datos que especifique los archivos de registro de datos y de transacciones

Este ejemplo crea una base de datos llamada Sales. Debido a que no se utiliza la palabra clave PRIMARY, el primer archivo (Sales_dat) se convierte, de forma predeterminada, en el archivo principal. Como no se especifican MB ni KB en el parámetro SIZE del archivo Sales_dat, de forma predeterminada, dicho parámetro indica MB y el tamaño se asigna en megabytes. El tamaño del archivo Sales_log se asigna en megabytes porque se ha indicado explícitamente el sufijo MB en el parámetro SIZE.

USE masterGOCREATE DATABASE SalesON ( NAME = Sales_dat,FILENAME = 'c:\mssql7\data\saledat.mdf',SIZE = 10,MAXSIZE = 50,FILEGROWTH = 5 )LOG ON( NAME = 'Sales_log',FILENAME = 'c:\mssql7\data\salelog.ldf',SIZE = 5MB,MAXSIZE = 25MB,FILEGROWTH = 5MB )GO

B. Crear una base de datos mediante la especificación de múltiples archivos de registro de datos y de transacciones

Este ejemplo crea una base de datos llamada Archive con tres archivos de datos de 100 MB y dos archivos de registro de transacciones de 100 MB. El archivo principal es el primer archivo de la lista y se especifica explícitamente con la palabra clave PRIMARY. Los archivos de registro de transacciones se especifican a continuación de las palabras clave LOG ON. Observe las extensiones que se emplean para los archivos de la opción FILENAME: .mdf se utiliza para los archivos principales, .ndf para los archivos secundarios y .ldf para los archivos de registro de transacciones.

USE masterGOCREATE DATABASE Archive ONPRIMARY ( NAME = Arch1,FILENAME = 'c:\mssql7\data\archdat1.mdf',SIZE = 100MB,MAXSIZE = 200,FILEGROWTH = 20),( NAME = Arch2,FILENAME = 'c:\mssql7\data\archdat2.ndf',SIZE = 100MB,MAXSIZE = 200,FILEGROWTH = 20),( NAME = Arch3,FILENAME = 'c:\mssql7\data\archdat3.ndf',SIZE = 100MB,



MAXSIZE = 200,FILEGROWTH = 20)LOG ON ( NAME = Archlog1,FILENAME = 'c:\mssql7\data\archlog1.ldf',SIZE = 100MB,MAXSIZE = 200,FILEGROWTH = 20),( NAME = Archlog2,FILENAME = 'c:\mssql7\data\archlog2.ldf',SIZE = 100MB,MAXSIZE = 200,FILEGROWTH = 20)GO

C. Crear una base de datos individual

En este ejemplo se crea una base de datos llamada Products y se especifica un único archivo. De forma predeterminada, el archivo especificado se convierte en el archivo principal; se crea automáticamente un archivo de registro de transacciones de 1 MB. Como no se especifica MB ni KB en el parámetro SIZE del archivo principal, el tamaño del archivo principal se asigna en megabytes. Ya que no existe <filespec> para el archivo de registro de transacciones, éste no tiene MAXSIZE y puede crecer hasta llenar todo el espacio disponible en el disco.

USE masterGOCREATE DATABASE ProductsON ( NAME = prods_dat,FILENAME = 'c:\mssql7\data\prods.mdf',SIZE = 4,MAXSIZE = 10,FILEGROWTH = 1 )GO

D. Crear una base de datos sin especificar los archivos

Este ejemplo crea una base de datos llamada mytest y crea los archivos principal y de registro de transacciones correspondientes. Debido a que la instrucción no tiene elementos <filespec>, el archivo principal de la base de datos tiene el tamaño del archivo principal de la base de datos model. El registro de transacciones tiene el tamaño del archivo del registro de transacciones de la base de datos model. Como no se ha especificado MAXSIZE, los archivos pueden crecer hasta llenar todo el espacio disponible en disco.

CREATE DATABASE mytest

E. Crear una base de datos sin especificar SIZE

Este ejemplo crea una base de datos llamada products2. De forma predeterminada, el archivo prods2_dat se convierte en el archivo principal, con un tamaño igual al tamaño del archivo principal de la base de datos model. El archivo de registro de transacciones se crea automáticamente y es un 25 por ciento del tamaño del archivo principal, o 512 KB, el que sea mayor. Como no se ha especificado MAXSIZE, los archivos pueden crecer hasta llenar todo el espacio disponible en disco.



USE masterGOCREATE DATABASE Products2ON ( NAME = prods2_dat,FILENAME = 'c:\mssql7\data\prods2.mdf' )GO

F. Crear una base de datos con grupos de archivos

Este ejemplo crea una base de datos llamada sales con tres grupos de archivos: • El grupo de archivos principal con los archivos Spri1_dat y Spri2_dat. El incremento de

FILEGROWTH de estos archivos se especifica como el 15%. • Un grupo de archivos llamado SalesGroup1 con los archivos SGrp1Fi1 y SGrp1Fi2. • Un grupo de archivos llamado SalesGroup2 con los archivos SGrp2Fi1 y SGrp2Fi2.

CREATE DATABASE SalesON PRIMARY( NAME = SPri1_dat,FILENAME = 'c:\mssql7\data\SPri1dat.mdf',SIZE = 10,MAXSIZE = 50,FILEGROWTH = 15% ),( NAME = SPri2_dat,FILENAME = 'c:\mssql7\data\SPri2dt.ndf',SIZE = 10,MAXSIZE = 50,FILEGROWTH = 15% ),FILEGROUP SalesGroup1( NAME = SGrp1Fi1_dat,FILENAME = 'c:\mssql7\data\SG1Fi1dt.ndf',SIZE = 10,MAXSIZE = 50,FILEGROWTH = 5 ),( NAME = SGrp1Fi2_dat,FILENAME = 'c:\mssql7\data\SG1Fi2dt.ndf',SIZE = 10,MAXSIZE = 50,FILEGROWTH = 5 ),FILEGROUP SalesGroup2( NAME = SGrp2Fi1_dat,FILENAME = 'c:\mssql7\data\SG2Fi1dt.ndf',SIZE = 10,MAXSIZE = 50,FILEGROWTH = 5 ),( NAME = SGrp2Fi2_dat,FILENAME = 'c:\mssql7\data\SG2Fi2dt.ndf',SIZE = 10,MAXSIZE = 50,FILEGROWTH = 5 )LOG ON( NAME = 'Sales_log',FILENAME = 'c:\mssql7\data\salelog.ldf',SIZE = 5MB,



MAXSIZE = 25MB,FILEGROWTH = 5MB )GO

G. Adjuntar una base de datos

El ejemplo B creó una base de datos llamada Archive con los siguientes archivos físicos:

c:\mssql7\data\archdat1.mdfc:\mssql7\data\archdat2.ndfc:\mssql7\data\archdat3.ndfc:\mssql7\data\archlog1.ldfc:\mssql7\data\archlog2.ldf

La base de datos puede separarse con el procedimiento almacenado sp_detach_db y, después, puede volverse a adjuntar mediante CREATE DATABASE con la cláusula FOR ATTACH:

sp_detach_db ArchiveGOCREATE DATABASE ArchiveON PRIMARY (FILENAME = 'c:\mssql7\data\archdat1.mdf')FOR ATTACHGO

H. Utilizar particiones sin formato

Este ejemplo crea una base de datos llamada Employees con particiones sin formato. Las particiones sin formato deben existir cuando se ejecuta la instrucción y en cada partición sin formato sólo puede almacenarse un archivo.

USE masterGOCREATE DATABASE EmployeesON ( NAME = Empl_dat,FILENAME = 'f:',SIZE = 10,MAXSIZE = 50,FILEGROWTH = 5 )LOG ON( NAME = 'Sales_log',FILENAME = 'g:',SIZE = 5MB,MAXSIZE = 25MB,FILEGROWTH = 5MB )GO

3.5 Creación de TablasLas tablas son objetos de la base de datos que contienen todos sus datos. Una tabla se define mediante una colección de columnas. En las tablas, los datos se organizan con arreglo a un formato de filas y columnas, similar al de una hoja de cálculo. Cada fila representa a un registro único, y cada columna representa a un campo dentro de un registro. Por ejemplo, en una tabla



que contenga los datos de los empleados de una compañía puede haber una fila para cada empleado y distintas columnas en las que figuren detalles de los empleados tales como el número de empleado, el nombre, la dirección, el puesto que ocupa y su número de teléfono particular.

Cuando diseñe una base de datos, deberá decidir qué tablas necesita, qué tipo de datos van destinados a cada tabla, quién puede tener acceso a cada tabla, etc. Cuando cree tablas y trabaje con ellas, seguirá tomando decisiones más específicas acerca de las mismas.

El método más eficiente para crear una tabla consiste en definir todo lo que se necesita en la tabla al mismo tiempo, incluidas las restricciones para los datos y los componentes adicionales. No obstante, también puede crear una tabla básica, agregar algunos datos y trabajar con la tabla durante algún tiempo. Así, tendrá ocasión de ver cuáles son los tipos de transacciones más habituales y qué tipos de datos se utilizan con más frecuencia antes de confirmar un diseño más estable que incluya restricciones, índices, valores predeterminados, reglas y otros objetos.

Puede ser una buena idea que esboce sus planes en papel antes de crear una tabla y sus objetos.

Entre las decisiones que deben tomarse, se incluyen: • Los tipos de datos que debe contener la tabla. • Las columnas de la tabla y los tipos de datos para cada columna (así como su longitud, si

es preciso). • Qué columnas aceptan valores NULL. • Si deben utilizarse (y cuándo) restricciones o valores predeterminados y reglas. • Los tipos de índices necesarios, dónde se necesitan y qué columnas son claves

principales y claves externas.

La asignación de un tipo de datos para cada columna es uno de los primeros pasos que deberá seguir para diseñar una tabla. Los tipos de datos definen qué valores están permitidos en cada columna. Para asignar un tipo de datos a una columna, puede utilizar tipos de datos de Microsoft SQL Server o crear sus propios tipos de datos a partir de los del sistema. Por ejemplo, si sólo desea incluir nombres en una columna, puede asignar un tipo de datos de carácter para la misma. Asimismo, si desea que una columna sólo contenga números, puede asignar un tipo de datos numérico.

Exigir la integridad de los datos

Los tipos de datos del sistema y los definidos por el usuario pueden utilizarse para exigir la integridad de los datos, ya que los datos que se agregan o que se modifican deben ajustarse al tipo especificado en la instrucción original CREATE TABLE. Por ejemplo, no podrá almacenar un nombre en una columna definida con un tipo de datos datetime, porque una columna datetime sólo acepta fechas válidas. Por lo general, mantenga datos de tipo numérico en las columnas numéricas, sobre todo si deben realizarse cálculos con ellos más adelante.

Columnas de numeración automática y de identificadores

En una tabla sólo puede crearse una columna de identificadores que contenga valores secuenciales generados por el sistema para identificar de forma única a cada fila de la tabla. Por ejemplo, una columna de identificadores puede generar números únicos de recibos personalizados de los clientes automáticamente para una aplicación, a medida que se insertan filas en la tabla. Las columnas de identificadores contienen valores únicos dentro de la tabla en la



que son definidas. Esto significa que otras tablas que contengan columnas de identificadores pueden tener los mismos valores de identidad que utiliza otra tabla. No obstante, esta coincidencia no suele constituir un problema, ya que los valores de los identificadores suelen utilizarse únicamente dentro del contexto de una tabla; las columnas de identificadores no están relacionadas con las columnas de identificadores que se encuentren en otras tablas.

En cada tabla sólo se puede crear una columna de identificadores exclusivos globales; esta columna contendrá valores únicos para todos los equipos del mundo que estén conectados por red. Una columna que ofrezca la garantía de contener valores exclusivos globales suele resultar de utilidad cuando es necesario mezclar datos similares de varios sistemas de bases de datos (por ejemplo, en un sistema de facturación que se alimente de los datos de las distintas filiales de una compañía repartidas por todo el mundo). Cuando se mezclan los datos en la sede central de la compañía para su consolidación y con el fin de elaborar informes, la utilización de valores exclusivos globales impide que coincidan los números de facturación o los identificadores de dos clientes en países diferentes.

Microsoft® SQL Server™ utiliza columnas de identificadores exclusivos globales para la duplicación de mezcla con el fin de garantizar que las filas tengan una identificación exclusiva en distintas copias de la tabla.

SQL Server utiliza las propiedades IDENTITY y ROWGUIDCOL para implementar columnas de identificadores.

Utilizar restricciones, valores predeterminados y valores NULL

Para diseñar las tablas, es necesario identificar los valores válidos para una columna y decidir cómo se debe exigir la integridad de los datos de la columna. Microsoft® SQL™ Server proporciona varios mecanismos para exigir la integridad de los datos de una columna:

• Las restricciones de clave principal (PRIMARY KEY). • Las restricciones de clave externa (FOREIGN KEY). • Las restricciones de no duplicados (UNIQUE). • Las restricciones de comprobación (CHECK). • Las definiciones de valores predeterminados (DEFAULT). • La aceptación de NULL

3.5.1 Restricciones PRIMARY KEY

Una restricción PRIMARY KEY única se puede: • Crear cuando se crea la tabla, durante el proceso de definición de la misma. • Agregar a una tabla existente, siempre que no exista ya otra restricción PRIMARY KEY

(una tabla sólo puede tener una restricción PRIMARY KEY). • Modificar o eliminar, si ya existe. Por ejemplo, es posible que desee que la restricción

PRIMARY KEY de la tabla haga referencia a otras columnas o bien modificar el orden de la columna, el nombre del índice, la opción de agrupamiento o el factor de relleno de la restricción PRIMARY KEY. No se puede cambiar la longitud de una columna definida con una restricción PRIMARY KEY.

Nota Para modificar una restricción PRIMARY KEY mediante Transact-SQL o SQL-DMO, antes deberá eliminar la restricción PRIMARY KEY existente y, a continuación, volver a crearla con la nueva definición.



Cuando se agrega una restricción PRIMARY KEY a una o a varias columnas de la tabla, Microsoft SQL Server comprueba los datos que hay en las columnas para asegurarse de que sigan las reglas de las claves principales:

• Que no haya ningún valor Null. • Que no haya ningún valor duplicado.

Si se agrega una restricción PRIMARY KEY a una columna con valores duplicados o valores NULL, SQL Server devuelve un error y no agrega la restricción. No se puede agregar una restricción PRIMARY KEY que no cumpla estas reglas.

3.5.2 Restricciones FOREIGN KEY

Las restricciones FOREIGN KEY se pueden: • Crear cuando se crea la tabla, durante el proceso de definición de la misma. • Agregar a una tabla ya existente, siempre que la restricción FOREIGN KEY esté

vinculada a una restricción PRIMARY KEY o UNIQUE de otra o de la misma tabla. Una tabla puede contener varias restricciones FOREIGN KEY.

• Modificar o eliminar si ya existen restricciones FOREIGN KEY. Por ejemplo, es posible que desee que la restricción FOREIGN KEY de la tabla haga referencia a otras columnas. No se puede cambiar la longitud de una columna definida con una restricción FOREIGN KEY.

Nota Para modificar una restricción FOREIGN KEY mediante Transact-SQL o SQL-DMO, antes deberá eliminar la restricción FOREIGN KEY existente y, a continuación, volver a crearla con la nueva definición.

Cuando se agrega una restricción FOREIGN KEY a una o a varias columnas de la tabla, Microsoft® SQL Server™ comprueba de forma predeterminada los datos que hay en las columnas para asegurarse de que estén todos los valores, excepto NULL, en las columnas de la restricción PRIMARY KEY o UNIQUE a la que se hace referencia. Sin embargo, se puede impedir que SQL Server compruebe los datos de la columna con la nueva restricción y exigirle que agregue la nueva restricción, independientemente de los datos que haya en la columna. Esta opción resulta de utilidad cuando los datos existentes ya cumplen con la nueva restricción FOREIGN KEY o cuando una regla de empresa requiere que se exija la restricción sólo a partir de ese punto.

No obstante, debe actuar con precaución cuando agregue una restricción sin comprobar los datos existentes porque así se omiten los controles de SQL Server que garantizan la integridad de los datos de la tabla.

Deshabilitar restricciones FOREIGN KEY

Es posible deshabilitar las restricciones FOREIGN KEY existentes para: • Las instrucciones INSERT y UPDATE, de modo que los datos de la tabla puedan ser

modificados sin ser validados por las restricciones. Deshabilite una restricción FOREIGN KEY para las instrucciones INSERT y UPDATE si los nuevos datos infringen la restricción o si la restricción sólo se aplica a los datos que ya se encuentran en la base de datos.



• Procesos de duplicación. Deshabilite una restricción FOREIGN KEY durante la duplicación si la restricción es específica para la base de datos de origen. Cuando se duplica una tabla, la definición de la tabla y los datos se copian desde la base de datos de origen a una base de datos de destino. Estas dos bases de datos suelen encontrarse en dos servidores distintos (aunque no necesariamente). Si las restricciones FOREIGN KEY son específicas para la base de datos de origen pero no están deshabilitadas durante la duplicación, puede que impidan innecesariamente que se escriban nuevos datos en la base de datos de destino.

•Elimine una restricción FOREIGN KEY para que no se exija la integridad referencial entre las columnas de clave externa y las columnas de la clave principal (o de restricción UNIQUE) relacionadas que se encuentran en otra tabla.

SQL Server crea automáticamente un índice único para exigir que la restricción PRIMARY KEY sea única. Si aún no existe un índice agrupado en la tabla o no se ha especificado explícitamente, se crea un índice agrupado único para exigir la restricción PRIMARY KEY.

Importante No se puede eliminar una restricción PRIMARY KEY si una restricción FOREIGN KEY de otra tabla está haciendo referencia a ella; antes, es preciso eliminar la restricción FOREIGN KEY.

3.5.3 Restricciones de no duplicados (UNIQUE)

Las restricciones UNIQUE se pueden: • Crear cuando se crea la tabla, durante el proceso de definición de la misma. • Agregar a una tabla existente, siempre que la columna o la combinación de columnas a

las que afecta la restricción UNIQUE sólo contenga valores exclusivos o NULL. Una tabla puede contener varias restricciones UNIQUE.

• Modificar o eliminar si ya existen. Por ejemplo, es posible que desee que la restricción UNIQUE de la tabla haga referencia a otras columnas o que desee cambiar el tipo de agrupación de los índices.

Nota Para modificar una restricción UNIQUE mediante Transact-SQL o SQL-DMO, antes deberá eliminar la restricción UNIQUE existente y, a continuación, volver a crearla con la nueva definición.

Cuando se agrega una restricción UNIQUE a una o a varias columnas de una tabla, Microsoft® SQL Server™ comprueba de forma predeterminada los datos que hay en las columnas para asegurarse de que todos los valores, excepto los valores NULL, sean únicos. Si se agrega una restricción UNIQUE a una columna que contiene valores duplicados, SQL Server devuelve un error y no agrega la restricción.

SQL Server crea automáticamente un índice UNIQUE para exigir, de acuerdo con la restricción UNIQUE, que no haya duplicados. Por lo tanto, si se intenta insertar una fila duplicada, SQL Server devolverá un mensaje de error para indicar que se ha infringido la restricción UNIQUE y no agregará la fila a la tabla. A menos que se especifique explícitamente un índice agrupado, se creará de forma predeterminada un índice único, no agrupado, para exigir la restricción UNIQUE.

Elimine una restricción UNIQUE para anular el requisito de que sean únicos los valores de una columna o de una combinación de columnas incluida en la restricción. No es posible eliminar una restricción UNIQUE si la columna asociada se utiliza como clave de texto de la tabla.



3.5.4 Restricciones CHECK

Las restricciones CHECK se pueden: • Crear cuando se crea la tabla, durante el proceso de definición de la misma. • Agregar a una tabla ya existente. Las tablas y las columnas pueden contener varias

restricciones CHECK. • Modificar o eliminar si ya existen. Por ejemplo, puede modificar la expresión utilizada por

la restricción CHECK en una columna de la tabla.

Nota Para modificar una restricción CHECK mediante Transact-SQL o SQL-DMO, antes deberá eliminar la restricción CHECK existente y, a continuación, volver a crearla con la nueva definición.

Cuando se agrega una restricción CHECK a una tabla ya existente, puede aplicarse a los nuevos datos o bien ampliarse también a los datos ya existentes. De forma predeterminada, la restricción CHECK se aplica a los datos existentes y a los nuevos datos. Puede resultar útil aplicar la restricción sólo a los datos nuevos cuando los datos existentes ya cumplen la nueva restricción CHECK o cuando una regla de empresa requiere que se exija la restricción únicamente a partir de ahora.

Por ejemplo, una restricción anterior podía requerir que los códigos postales estuvieran limitados a cinco cifras, mientras que una nueva restricción requiere que los códigos postales sean de nueve cifras. Los datos que figuran en los antiguos códigos postales de cinco cifras siguen siendo válidos y coexisten con los nuevos datos de los nuevos códigos postales, que tienen nueve cifras. Por lo tanto, la nueva restricción sólo debe comprobarse con los nuevos datos.

No obstante, conviene actuar con precaución cuando se agrega una restricción sin comprobar los datos existentes ya que, de ese modo, se omiten los controles de Microsoft® SQL Server™ que exigen las reglas de integridad para la tabla.

Deshabilitar restricciones CHECK

Se puede deshabilitar las restricciones CHECK para: • Las instrucciones INSERT y UPDATE, de modo que los datos de la tabla puedan ser

modificados sin ser validados por las restricciones. Deshabilite una restricción CHECK durante las instrucciones INSERT y UPDATE si los nuevos datos no cumplen la restricción o si la restricción debe aplicarse únicamente a los datos que ya se encuentren en la base de datos.

• Procesos de duplicación. Deshabilite una restricción CHECK durante la duplicación si la restricción es específica para la base de datos de origen. Cuando se duplica una tabla, la definición de la tabla y los datos se copian desde la base de datos de origen a una base de datos de destino. Estas dos bases de datos suelen encontrarse en dos servidores distintos (aunque no necesariamente). Si las restricciones CHECK específicas para la base de datos de origen no están deshabilitadas, puede que impidan innecesariamente que se escriban datos nuevos en la base de datos de destino.

Elimine una restricción CHECK para quitar las limitaciones acerca de los valores aceptables para las columnas incluidas en la expresión de la restricción.



3.5.5 Dfiniciones DEFAULT

Las definiciones DEFAULT se pueden: • Crear cuando se crea la tabla, durante el proceso de definición de la misma. • Agregar a una tabla ya existente. Cada columna de una tabla puede contener una sola

definición DEFAULT. • Modificar o eliminar, si ya existen definiciones DEFAULT. Por ejemplo, puede modificar el

valor que se inserta en una columna cuando no se escribe ningún valor.

Nota Para modificar una definición DEFAULT mediante Transact-SQL o SQL-DMO, antes deberá eliminar la definición DEFAULT existente y, a continuación, volver a crearla con la nueva definición.

No se puede crear definiciones DEFAULT para columnas definidas con: • Un tipo de datos timestamp. • Una propiedad IDENTITY o ROWGUIDCOL. • Una definición DEFAULT o un objeto DEFAULT ya existentes.

Nota El valor predeterminado debe ser compatible con el tipo de datos de la columna a la que se aplica la definición DEFAULT. Por ejemplo, el valor predeterminado para una columna int debe ser un número entero, no una cadena de caracteres.

Cuando se agrega una definición DEFAULT a una columna ya existente en una tabla, Microsoft® SQL Server™ aplica de forma predeterminada el nuevo valor predeterminado a las nuevas filas de datos que se agregan a la tabla; los datos existentes que se hayan insertados mediante la definición DEFAULT anterior no se ven afectados. No obstante, cuando agregue una nueva columna a una tabla ya existente, puede especificar que SQL Server inserte en la nueva columna el valor predeterminado (especificado mediante la definición DEFAULT) en vez de un valor Null para las filas existentes en la tabla.

Cuando elimine una definición DEFAULT, SQL Server insertará un valor Null en vez del valor predeterminado si no se inserta ningún valor para las nuevas filas de la columna. No obstante, no se realizan cambios en los datos existentes en la tabla.

3.5.6 Columnas de identificadores

En cada tabla sólo se puede crear una columna de identificadores y una columna de identificadores exclusivos globales.

Propiedad de identidad (IDENTITY)

Se puede implementar las columnas de identificadores mediante la propiedad de identidad, que permite que el programador de la aplicación especifique un número de identidad para la primera fila insertada en la tabla (propiedad inicialización de identidad (identity seed)) y un incremento (incremento de identidad (identity increment)) que debe agregarse al valor inicial para determinar los números de identidad sucesivos. Cuando se insertan valores en una tabla con una columna de identificadores, Microsoft® SQL Server™ genera automáticamente el siguiente valor de identidad mediante la suma del incremento a la inicialización.

Cuando utilice la propiedad IDENTITY para definir una columna de identificadores, tenga en cuenta lo siguiente:



• Una tabla sólo puede tener una columna definida con la propiedad IDENTITY y esa columna sólo se puede definir con los tipos de datos decimal, int, numeric, smallint o tinyint.

• Se pueden especificar los valores de inicialización e incremento. El valor predeterminado es 1 para ambos.

• La columna de identificadores no debe aceptar valores NULL ni contener una definición ni un objeto DEFAULT.

• Es posible hacer referencia a la columna desde una lista de selección mediante la palabra clave IDENTITYCOL después de que se configure la propiedad IDENTITY.

• Es posible utilizar la función OBJECTPROPERTY para determinar si una tabla tiene una columna IDENTITY, y la función COLUMNPROPERTY para determinar el nombre de la columna IDENTITY.

Identificadores exclusivos globales

Aunque la propiedad de identidad (IDENTITY) automatice la numeración de las filas de una tabla, dos tablas distintas con sendas columnas de identificadores pueden generar los mismos valores. Esto es debido a que se garantiza que la propiedad de identidad IDENTITY es única sólo para la tabla en la que se utiliza. Si una aplicación debe generar una columna de identificadores única para toda la base de datos o para todas las bases de datos de todos los equipos conectados en red en todo el mundo, utilice la propiedad ROWGUIDCOL, el tipo de datos uniqueidentifier y la función NEWID.

Cuando utilice la propiedad ROWGUIDCOL para definir una columna de identificadores exclusivos globales, tenga en cuenta lo siguiente:

• Una tabla sólo podrá tener una columna ROWGUIDCOL, y esa columna debe definirse mediante el tipo de datos uniqueidentifier.

• SQL Server no genera valores para la columna de forma automática. Para insertar un valor exclusivo global, cree una definición DEFAULT en la columna que utilice la función NEWID para generar un valor exclusivo global.

• Es posible hacer referencia a la columna desde una lista de selección mediante la palabra clave ROWGUIDCOL, después de que se establezca la propiedad ROWGUIDCOL. Este método es similar al que permite hacer referencia a una columna de identidad (IDENTITY) mediante la palabra clave IDENTITYCOL.

• Se puede utilizar la función OBJECTPROPERTY para determinar si una tabla tiene una columna ROWGUIDCOL y la función COLUMNPROPERTY para determinar el nombre de la columna ROWGUIDCOL.

• Dado que la propiedad ROWGUIDCOL no exige la exclusividad, deberá utilizar la restricción de exclusividad (UNIQUE) para asegurarse de que se insertan valores exclusivos en la columna ROWGUIDCOL.

Nota Si hay una columna de identificadores para una tabla en la que se realizan eliminaciones frecuentemente, pueden quedar espacios entre los valores de identidad; los valores de identidad eliminados no se vuelven a utilizar. Para evitar esos espacios, no utilice la propiedad IDENTITY. En su lugar, cree un desencadenador que, a medida que se inserten filas, determine un nuevo valor de identificador basado en los valores existentes de la columna de identificadores.

3.5.7 SET ANSI_NULLS (T-SQL)

Especifica el comportamiento conforme a SQL-92 de los operadores de comparación Igual a (=) y Diferente de (<>) cuando se utilizan con valores nulos.



Sintaxis

SET ANSI_NULLS {ON | OFF}

Observaciones

El estándar SQL-92 requiere que las comparaciones de igualdad (=) o desigualdad (<>) con un valor nulo se evalúen como FALSE. Cuando SET ANSI_NULLS es ON, una instrucción SELECT con la cláusula WHERE nombreColumna = NULL devolverá cero filas, incluso cuando haya valores nulos en nombreColumna. Una instrucción SELECT con la cláusula WHERE nombreColumna <> NULL devolverá cero filas, incluso cuando haya valores no nulos en nombreColumna.Cuando SET ANSI_NULLS es OFF, los operadores de comparación Igual a (=) y Diferente de (<>) no siguen el estándar de SQL-92. Una instrucción SELECT con la cláusula WHERE nombreColumna = NULL devolverá las filas que tengan valores nulos en nombreColumna. Una instrucción SELECT con la cláusula WHERE nombreColumna <> NULL devolverá las filas con valores no nulos en esa columna.

Nota El hecho de que Microsoft® SQL Server™ interprete una cadena vacía como un carácter espacio o como una auténtica cadena vacía se controla con la opción de nivel de compatibilidad de sp_dbcmptlevel. Si el nivel de compatibilidad es menor o igual que 65, SQL Server interpreta las cadenas vacías como espacios individuales. Si el nivel de compatibilidad es igual a 70, SQL Server interpreta las cadenas vacías como tales. Cuando SET ANSI_NULLS es ON, todas las comparaciones con un valor nulo se evalúan como UNKNOWN. Cuando SET ANSI_NULLS es OFF, la comparación de cualquier dato con un valor nulo se evalúa como TRUE si el valor del dato es NULL. Si no se especifica, se aplica el valor de la opción ANSI nulls de la base de datos actual..

Para que una secuencia de comandos funcione como se pretende, independientemente de la opción de base de datos ANSI nulls o de la opción SET ANSI_NULLS, utilice IS NULL e IS NOT NULL en las comparaciones que puedan contener valores nulos.

En los procedimientos almacenados, SQL Server utiliza el valor de la opción SET ANSI_NULLS establecido en el momento de crear el procedimiento almacenado. En las siguientes ejecuciones del procedimiento almacenado, se restablece y se aplica la opción SET ANSI_NULLS original. Cuando se invoca dentro de un procedimiento almacenado, la opción SET ANSI_NULLS no cambia.

SET ANSI_NULLS debe estar activado para ejecutar consultas distribuidas.

El controlador ODBC de SQL Server y el proveedor de Microsoft OLE DB para SQL Server establecen automáticamente ANSI_NULLS en ON al conectar. Esta opción se puede configurar en los orígenes de datos ODBC, en los atributos de conexión ODBC o en las propiedades de conexión OLE DB establecidas en la aplicación antes de conectar con SQL Server. SET ANSI_NULLS tiene como opción predeterminada OFF en las conexiones desde aplicaciones de biblioteca de base de datos.

Cuando SET ANSI_DEFAULTS es ON, se habilita SET ANSI_NULLS.

La opción SET ANSI_NULLS se establece en tiempo de ejecución, no en tiempo de análisis.

Permisos

De forma predeterminada, todos los usuarios tienen permisos para ejecutar SET ANSI_NULLS.



Por ejemplo

-- El primer proceso por lotes devolverá 2 filas

use pubsset ansi_nulls offgoselect * from titles where price = nullgo

--El segundo proceso por lotes no devolverá ninguna fila

/* Este secuencia de instrucciones ilustra la utilización de ANSI_NULLS*/use pubsset ansi_nulls ongoselect * from titles where price = nullgo

3.5.8 EJEMPLOS

1. Esta secuencia de instrucciones crea dos tablas con una relación compuesta. Clave primaria/Clave externa. Después presenta las restricciones sobre cada tabla.

CREATE TABLE cliente(id_cliente int NOT NULL,num_ubicación smallint NULL,nombre_cliente varchar(50) NOT NULL,CONSTRAINT CLIENTE_EXC UNIQUE CLUSTERED (num_ubicación, id_cliente))

CREATE TABLE pedidos(id_pedido int NOT NULL IDENTITY CONSTRAINT PEDIDO_PK PRIMARY KEY NONCLUSTERED,num_cliente int NOT NULL,ubic_cliente smallint NULL,CONSTRAINT FK_PEDIDO_CLIENTE FOREIGN KEY (ubic_cliente, num_cliente)REFERENCES cliente (num_ubicación, id_cliente))

GO

EXEC sp_helpconstraint clienteEXEC sp_helpconstraint pedidosGO

2.- Esta secuencia de instrucciones crea una tabla con varias restricciones y una clave externa que hace referencia a sí misma. Después muestra las restricciones sobre la tabla.



USE pubsGO

CREATE TABLE empleado(id_empleado int NOT NULL PRIMARY KEY CHECK (id_empleado BETWEEN 0 AND 1000),

nombre_empleado varchar(30) NOT NULL CONSTRAINT sin_números CHECK (nombre_empleado NOT LIKE '%[0-9]%'),

id_admin int NOT NULL REFERENCES empleado(id_empleado),

fecha_introducción datetime NULL CHECK (fecha_introducción >= GETDATE()),

introducido_por int CHECK (introducido_por IS NOT NULL), CONSTRAINT introducido_por_valido CHECK (introducido_por = SUSER_ID(NULL) AND introducido_por <> id_empleado),

CONSTRAINT admin_valido CHECK (id_admin <> id_empleado OR id_empleado=1),

CONSTRAINT fin_de_mes CHECK (DATEPART(DAY, GETDATE()) < 28))GO

EXEC sp_helpconstraint empleadoGO

4.- Esta secuencia de instrucciones crea una tabla con varias restriccione, algunos valores predeterminados y una clave externa de referencia a sí misma. Después muestra las restricciones sobre la tabla.

USE pubsGO




fecha_introducción datetime NULL CHECK (fecha_introducción >= CURRENT_TIMESTAMP),

introducido_por int CHECK (introducido_por IS NOT NULL), CONSTRAINT introducido_por_válido CHECK (introducido_por = SUSER_ID(NULL) AND introducido_por <> id_empleado),



CONSTRAINT admin_válido CHECK (id_admin <> id_empleado OR id_empleado=1),



5.- Esta secuencia de instrucciones decodifica la información de la tabla sysconstraints para presentar información sobre las restricciones de una tabla.

USE ejemploGO

SELECT OBJECT_NAME(constid) 'Nombre de la restricción', constid 'ID de la restricción', CASE (status & 0xF) WHEN 1 THEN 'Clave primaria' WHEN 2 THEN 'Exclusiva' WHEN 3 THEN 'Clave externa' WHEN 4 THEN 'Comprobación' WHEN 5 THEN 'Predeterminado' ELSE 'No definido' END 'Tipo de restricción', CASE (status & 0x30) WHEN 0x10 THEN 'Columna' WHEN 0x20 THEN 'Tabla' ELSE 'ND' END 'Nivel'FROM sysconstraintsWHERE id=OBJECT_ID('tEmpleado')

6.- Esta secuencia de instrucciones crea una tabla con varias restricciones y una clave externa que hace referencia a sí misma. Después muestra las restricciones sobre la tabla.

USE pubsGO




fecha_introducción datetime NULL CHECK (fecha_introducción >= CURRENT_TIMESTAMP),

introducido_por int CHECK (introducido_por IS NOT NULL),



CONSTRAINT introducido_por_válido CHECK (introducido_por = SUSER_ID(NULL) AND introducido_por <> id_empleado),

CONSTRAINT admin_válido CHECK (id_admin <> id_empleado OR id_empleado=1),



7.- La siguientes instrucciones ejemplifican el uso de transacciones.

USE Ejemplogo

if exists (select * from sysobjects where name='SHOW_ERROR' and type='U')DROP TABLE SHOW_ERROR

go

CREATE TABLE SHOW_ERROR(col1 smallint NOT NULL PRIMARY KEY,col2 smallint NOT NULL)go

BEGIN TRANSACTION

INSERT SHOW_ERROR VALUES (1,1)INSERT SHOW_ERROR VALUES (1,2)INSERT SHOW_ERROR VALUES (2,2)

COMMIT TRANSACTIONgo

SELECT * FROM SHOW_ERRORgo

/*Servidor: mensaje 2627, nivel 14, estado 1, línea 1Infracción de la restricción PRIMARY KEY 'PK__mostrar_error__5DCAEF64'. No se puede insertar una clave -----duplicada en el objeto 'mostrar_error'.Se terminó la instrucción.

col1 col2---- ----1 12 2

A continuación se presenta una versión modificada de la transacción que acabamos de ver. Este ejemplo realiza



una comprobación sencilla de errores utilizando la función del sistema incorporada @@error, y anula la transacción, si cualuqiera de las instrucciones tiene como resultado un error.

En este ejemplo no se insertan filas.

*/

if exists (select * from sysobjects where name='SHOW_ERROR' and type='U')DROP TABLE SHOW_ERROR

go


BEGIN TRANSACTIONINSERT SHOW_ERROR VALUES (1,1)

if @@error <> 0 GOTO TRAN_ABORTINSERT SHOW_ERROR VALUES (1,2)

if @@error <> 0 GOTO TRAN_ABORTINSERT SHOW_ERROR VALUES (2,2)

if @@error <> 0 GOTO TRAN_ABORTCOMMIT TRANSACTION-- GOTO ENDIT

TRAN_ABORT:ROLLBACK TRANSACTION

ENDIT:go

SELECT * FROM SHOW_ERRORgo

/* Como algunas personas manejan los errores en las transacciones mal, y como puede ser tedioso añadir comprobaciones de error después de cada comando, la versión 6.5 añadió una nueva instrucción SET que cancela una transacción si se produce cualquier error durante la misma (no existe instrucción WHENEVER en Transact-SQL actualmente, aunque dicha característica resultaría muy útil para situaciones como ésta).

La utilización de SET XACT_ABORT ON hace que se cancele y se anule toda la transacción si se produce un error.

El valor predereminado de esta opción es OFF, que es coherente con la semántica anterior a la versión 6.5, además de con el comportamiento del estándar ANSI. Activando la opción XACT_ABORT ON, ahora podemos volver a ejecutar el ejemplo y ver que no se han insertado filas.

*/if exists (select * from sysobjects where name='SHOW_ERROR' and type='U')

DROP TABLE SHOW_ERRORgo




SET XACT_ABORT ONBEGIN TRANSACTION

INSERT SHOW_ERROR VALUES (1,1)INSERT SHOW_ERROR VALUES (1,2)INSERT SHOW_ERROR VALUES (2,2)

COMMIT TRANSACTIONgo

SET XACT_ABORT OFFSELECT * FROM SHOW_ERRORgo



3.6 Elementos de sintaxis de Transact-SQL

Transact-SQL tiene varios elementos de sintaxis que son utilizados por, o influyen en, la mayor parte de las instrucciones:

Identificadores : Son los nombres de objetos como, por ejemplo, tablas, vistas, columnas, bases de datos y servidores.

Tipos de datos : Definen el tipo de datos que los objetos de datos pueden contener como, por ejemplo, columnas, variables y parámetros. La mayor parte de las instrucciones de Transact-SQL no hacen referencia explícitamente a tipos de datos, sino que sus resultados están influidos por las interacciones entre los tipos de datos de los objetos a los que se hace referencia en la instrucción.

Funciones : Son elementos de sintaxis que toman cero, uno o más valores de entrada y devuelven un valor escalar o un conjunto de valores en forma de tabla. Ejemplos de funciones son la función SUM para sumar varios valores, la función DATEDIFF para determinar el número de unidades de tiempo que separan dos fechas, la función @@SERVERNAME para obtener el nombre del servidor que ejecuta SQL Server o la función OPENQUERY para ejecutar una instrucción SQL en un servidor remoto y recuperar el conjunto de resultados.

Expresiones : Son una unidad de sintaxis que Microsoft SQL Server puede resolver en un valor único. Ejemplos de expresiones son las constantes, las funciones que devuelven un valor único, una referencia a una columna o una variable.

Operadores : Funcionan con una o más expresiones individuales para formar una expresión más compleja. Por ejemplo, combinar el operador - (negativo) con la constante 12 da como resultado la constante -12. El operador * (multiplicación) de la expresión PrecioColumna *1.1 aumenta el precio en un 10 por ciento.

Comentarios: Son fragmentos de texto insertado en instrucciones o secuencias de comandos de Transact-SQL para explicar el objetivo de la instrucción. Los comentarios no son ejecutados por SQL Server.

Palabras clave reservadas : Son palabras reservadas que utiliza SQL Server y no deben emplearse como nombres de objetos de una base de datos.

1.5.1 Conversión de tipos de datos

En Transact-SQL, hay dos niveles posibles de conversión de tipos de datos: • Cuando los datos de un objeto se mueven a, se comparan o se combinan con los datos

de otro objeto, puede que sea necesario convertir los datos desde el tipo de datos de un objeto al tipo de datos del otro.

• Cuando los datos de una columna de resultados, un código devuelto o un parámetro de salida de Transact-SQL se mueven a una variable de programa, deben ser convertidos desde el tipo de datos de Microsoft SQL Server al tipo de datos de la variable.

Hay dos categorías de conversiones de tipo de datos:



• Las conversiones implícitas son transparentes para el usuario. SQL Server convierte automáticamente los datos desde un tipo de datos al otro. Por ejemplo, si un smallint se compara con un int, el smallint se convierte implícitamente a int antes de realizarse la comparación.

• Las conversiones explícitas las realiza el usuario mediante las funciones CAST o CONVERT.

Las funciones CAST y CONVERT convierten un valor (una variable local, una columna u otra expresión) de un tipo de datos a otro. Por ejemplo, la siguiente función CAST convierte el valor numérico $157.27 a una cadena de caracteres ‘$157.27’:CAST ( $157.27 AS VARCHAR(10) )CAST se basa en el estándar SQL-92 y se prefiere antes que CONVERT.Cuando se realizan conversiones desde el tipo de datos de un objeto SQL Server a otro, no se admiten algunas conversiones implícitas y explícitas de tipos de datos. Por ejemplo, un valor nchar no se puede convertir de ninguna forma a un valor image. Un nchar sólo se puede convertir a binary con una conversión explícita, mientras que la conversión implícita a binary no se admite. Un nchar puede ser convertido a nvarchar explícita o implícitamente..

Cuando se realiza una conversión entre una variable de aplicación y una columna de conjunto de resultados, código de retorno, parámetro o marcador de parámetro de SQL Server, la API de base de datos define cuáles son las conversiones de tipos de datos admitidas.

Uso de CAST: CAST(expresión AS tipoDatos)Uso de CONVERT: CONVERT (tipoDatos[(longitud)], expresión [, estilo])

Argumentos

expresión : Es cualquier expresión válida de Microsoft SQL Server.

TipoDatos: Es el tipo de datos destino proporcionado por el sistema. No se pueden utilizar tipos de datos definidos por el usuario.

longitud : Es un parámetro opcional de los tipos de datos nchar, nvarchar, char, varchar, binary o varbinary.

Estilo : Es el estilo del formato de fecha que se desea al convertir datos datetime o smalldatetime a datos de cadenas de caracteres (tipos de datos nchar, nvarchar, char, varchar, nchar o nvarchar), o el formato de cadena cuando se convierten datos float, real, money o smallmoney a datos de cadenas de caracteres (tipos de datos nchar, nvarchar, char, varchar, nchar o nvarchar).



En la siguiente tabla, las dos columnas de la izquierda representan los valores de estilo para la conversión de datetime o smalldatetime en cadenas de caracteres. Agregue 100 al valor de estilo para obtener el año con cuatro cifras, incluido el siglo (yyyy).

Sin el siglo (yy)

Con el siglo (yyyy)

Estándar Entrada/Salida**

- 0 o 100 (*) Predeterminado mon dd yyyy hh:miAM (o PM)1 101 EE.UU. mm/dd/yy2 102 ANSI yy.mm.dd3 103 Británico/Francés dd/mm/yy4 104 Alemán dd.mm.yy5 105 Italiano dd-mm-yy6 106 - dd mon yy7 107 - mon dd, yy8 108 - hh:mm:ss

- 9 o 109 (*)Predeterminado +

milisegundosmon dd yyyy hh:mi:ss:mmmAM (o PM)

10 110 EE.UU. mm-dd-yy11 111 JAPÓN yy/mm/dd12 112 ISO yymmdd

- 13 o 113 (*)Europeo predeterminado +

milisegundosdd mon yyyy hh:mm:ss:mmm(24h)

14 114 - hh:mi:ss:mmm(24h)- 20 o 120 (*) ODBC canónico yyyy-mm-dd hh:mi:ss(24h)

- 21 o 121 (*)ODBC canónico (con

milisegundos)yyyy-mm-dd hh:mi:ss.mmm(24h)

* Los valores predeterminados (estilo 0 o 100, 9 o 109, 13 o 113, 20 o 120, y 21 o 121) siempre devuelven el siglo (yyyy).** Entrada cuando se convierte a datetime; Salida cuando se convierte a cadenas de caracteres.

Importante: De forma predeterminada, SQL Server interpreta los años de dos cifras con el año 2049 como límite. Es decir, el año 49 se interpreta como 2049 y el año 50 se interpreta como 1950. Muchas aplicaciones de cliente, como las basadas en objetos de Automatización OLE, utilizan como año límite el año 2030. SQL Server proporciona una opción de configuración (two digit year cutoff o reducción del año a dos dígitos) que cambia el año límite en SQL Server y permite el tratamiento coherente de las fechas. Sin embargo, el método más seguro es especificar los años con cuatro cifras.

Cuando se convierte a datos de cadenas de caracteres desde smalldatetime, los estilos que incluyen segundos o milisegundos muestran ceros en dichas posiciones. Puede recortar las partes de la fecha que no desee cuando convierta valores datetime o smalldatetime si utiliza la longitud apropiada en el tipo de datos char o varchar.



Esta tabla muestra los valores de estilo para la conversión de float o real a datos de cadenas de caracteres.

Valor Salida0 (predeterminado) 6 cifras como máximo. Utiliza la notación científica cuando es apropiado.

1 Siempre 8 cifras. Utiliza siempre la notación científica.2 Siempre 16 cifras. Utiliza siempre la notación científica.

En la siguiente tabla, la columna de la izquierda representa el valor de estilo para la conversión de money o smallmoney a datos de cadenas de caracteres.

Valor Salida

0 (predeterminado)Sin separadores de millar cada tres cifras a la izquierda del separador decimal y dos cifras a la derecha del separador decimal; por ejemplo, 4235,98.

1Separadores de millar cada tres cifras a la izquierda del separador decimal y dos cifras a la derecha del separador decimal; por ejemplo, 3.510,92.

2Sin separadores de millar cada tres cifras a la izquierda del separador decimal y cuatro cifras a la derecha del separador decimal; por ejemplo, 4235,9819.

Tipos devueltos

Devuelve el mismo valor que el tipo de datos 0.

Observaciones

Las conversiones implícitas son aquellas conversiones que ocurren sin especificar las funciones CAST o CONVERT. Las conversiones explícitas son aquellas conversiones que requieren que se especifique la función CAST (CONVERT). Este gráfico muestra todas las conversiones de tipos de datos explícitas e implícitas permitidas entre los tipos de datos del sistema de SQL Server.

¡Error! Marcador no definido.Nota Como los datos Unicode siempre utilizan un número par de bytes, preste atención al convertir binary o varbinary a tipos de datos aceptados en Unicode, y viceversa. Por ejemplo, esta conversión no devuelve el valor hexadecimal 41, sino 4100:

SELECT CAST(CAST(0x41 AS nvarchar) AS varbinary)

No se acepta la conversión automática de tipos de datos para los tipos de datos text e image. Puede convertir explícitamente datos text en cadenas de caracteres y datos image en binary o varbinary, pero la máxima longitud que puede especificar es 8000. Si intenta una conversión imposible (por ejemplo, si convierte una expresión de cadena de caracteres que incluya letras a int), SQL Server genera un mensaje de error.Al convertir expresiones de caracteres o binarias (char, nchar, nvarchar, varchar, binary o varbinary) en una expresión de un tipo de datos diferente, los datos pueden quedar recortados, se pueden presentar parcialmente o se puede devolver un error porque el resultado sea demasiado corto para ser presentado. Las conversiones a char, varchar, nchar, nvarchar, binary y varbinary se recortan, excepto en las conversiones que se muestran en esta tabla.

Del tipo de datos Al tipo de datos Resultadoint, smallint o tinyint char *

varchar *nchar E

nvarchar E

money, smallmoney, numeric, decimal, float o real

char Evarchar Enchar E



nvarchar E* Resultado con longitud demasiado corta para ser presentada. E Error devuelto porque la longitud del resultado es demasiado corta para ser presentada.

Microsoft SQL Server garantiza que sólo las conversiones circulares, las conversiones que convierten un tipo de datos en otro y después vuelven a convertirlo al tipo de datos original, devolverán los mismos valores de versión a versión. Este ejemplo muestra una conversión circular:

DECLARE @myval decimal (5, 2)SET @myval = 193.57SELECT CAST(CAST(@myval AS varbinary(20)) AS decimal(10,5))-- Or, using CONVERTSELECT CONVERT(decimal(10,5), CONVERT(varbinary(20), @myval))

No intente generar, por ejemplo, valores binary y convertirlos a un tipo de datos de la categoría de tipos de datos numéricos. SQL Server no garantiza que el resultado de una conversión de tipos de datos decimal o numeric a binary sea igual entre distintas versiones de SQL Server.Cuando se convierten tipos de datos que tienen un número diferente de posiciones decimales, el valor queda recortado hasta la cifra de mayor precisión. Por ejemplo, el resultado de SELECT CAST(10,6496 AS int) es 10.Este ejemplo muestra una expresión resultante demasiado corta para ser presentada.USE pubsSELECT SUBSTRING(title, 1, 25) AS Title, CAST(ytd_sales AS char(2))FROM titlesWHERE type = 'trad_cook'

Éste es el conjunto de resultados:Title ------------------------- -- Onions, Leeks, and Garlic * Fifty Years in Buckingham * Sushi, Anyone? * (3 row(s) affected)

Cuando se convierten tipos de datos en los que el tipo de datos destino tiene menos posiciones decimales que el tipo de datos origen, el valor se redondea. Por ejemplo, el resultado de CAST(10,3496 AS money) es $10,35.SQL Server devuelve un mensaje de error cuando se convierten datos char, nchar, varchar o nvarchar a int, float, numeric o decimal; o cuando una cadena vacía (“ “) se convierte a int o float.

Usar datos de cadenas Binary

Cuando se convierten datos binary o varbinary a datos de cadena de caracteres y se especifica un número impar de valores a continuación de la x, SQL Server agrega un 0 (cero) después de la x para tener un número par de valores.Los datos binarios consisten en los caracteres 0 a 9 y A a F (o f), en grupos de dos caracteres cada uno. Las cadenas binarias tienen que estar precedidas por 0x. Por ejemplo, para representar FF, escriba 0xFF. El valor máximo es un valor binario de 8000 bytes, todos ellos establecidos con FF. Los tipos de datos binary no son para datos hexadecimales, sino para patrones de bits. Puede que las conversiones y cálculos de números hexadecimales almacenados como datos binarios no sean confiables.Cuando se especifica la longitud de un tipo de datos binary, cada dos caracteres cuentan como uno. La longitud de 10 significa que hay 10 grupos de dos caracteres.Las cadenas binarias vacías, representadas como 0x, se pueden almacenar como datos binarios.



Ejemplos

A. Utilizar CAST y CONVERT

Los dos ejemplos devuelven los títulos de aquellos libros que tienen un 3 en la primera cifra de las ventas anuales y convierten ytd_sales a char(20).-- Use CAST.USE pubsGOSELECT SUBSTRING(title, 1, 30) AS Title, ytd_salesFROM titlesWHERE CAST(ytd_sales AS char(20)) LIKE '3%'GO-- Use CONVERT.USE pubsGOSELECT SUBSTRING(title, 1, 30) AS Title, ytd_salesFROM titlesWHERE CONVERT(char(20), ytd_sales) LIKE '3%'GOÉste es el conjunto de resultados de las consultas:Title ytd_sales ------------------------------ ----------- Cooking with Computers: Surrep 3876 Computer Phobic AND Non-Phobic 375 Emotional Security: A New Algo 3336 Onions, Leeks, and Garlic: Coo 375 (4 row(s) affected)

B. Utilizar CAST con operadores aritméticos

Este ejemplo calcula una única columna (Copies) dividiendo las ventas anuales totales (ytd_sales) por el precio individual del libro (price). El resultado se convierte al tipo de datos int después de ser redondeado al número entero más próximo. USE pubsGOSELECT CAST(ROUND(ytd_sales/price, 0) AS int) AS 'Copies'FROM titlesGOÉste es el conjunto de resultados:Copies ----------- 205 324 6262 205 102 7440 NULL 383 205 NULL 17 187 16 204 418 18



1263 273 (18 row(s) affected)

C. Utilizar CAST para concatenar

Este ejemplo concatena expresiones que no son de texto ni binarias mediante la función de conversión de tipos de datos CAST.USE pubsGOSELECT 'The price is ' + CAST(price AS varchar(12))FROM titlesWHERE price > 10.00GOÉste es el conjunto de resultados:------------------------- The price is 19.99 The price is 11.95 The price is 19.99 The price is 19.99 The price is 22.95 The price is 20.00 The price is 21.59 The price is 10.95 The price is 19.99 The price is 20.95 The price is 11.95 The price is 14.99 (12 row(s) affected)

D. Utilizar CAST para obtener texto más legible

Este ejemplo utiliza CAST en la lista seleccionada para convertir la columna title a char(50), para que los resultados sean más legibles.USE pubsGOSELECT CAST(title AS char(50)), ytd_salesFROM titlesWHERE type = 'trad_cook'GOÉste es el conjunto de resultados:ytd_sales-------------------------------------------------- ---------Onions, Leeks, and Garlic: Cooking Secrets of the 375Fifty Years in Buckingham Palace Kitchens 15096Sushi, Anyone? 4095(3 row(s) affected)

E. Utilizar CAST con una cláusula LIKE

Este ejemplo convierte una columna int (la columna ytd_sales) a char(20) para que se puede utilizar en una cláusula LIKE.USE pubsGOSELECT title, ytd_salesFROM titlesWHERE CAST(ytd_sales AS char(20)) LIKE '15%'AND type = 'trad_cook'GOÉste es el conjunto de resultados:



title ytd_sales ------------------------------------------------------------ ----------- Fifty Years in Buckingham Palace Kitchens 15096 (1 row(s) affected)

1.5.2 Utilizar funciones

Microsoft SQL Server dispone de funciones integradas para realizar ciertas operaciones rápida y fácilmente. Las categorías en que se dividen las funciones son:

Funciones de agregado:Realizan operaciones que combinan varios valores en uno. Ejemplos son COUNT, SUM, MIN y MAX.

Funciones de configuración :Son funciones escalares que devuelven información acerca de la configuración.

Funciones de cursores :Devuelven información acerca del estado de un cursor.

Funciones de fecha y hora :Tratan valores datetime y smalldatetime.

Funciones matemáticas :Realizan operaciones trigonométricas, geométricas y demás operaciones numéricas.

Funciones de metadatos :Devuelven información acerca de los atributos de las bases de datos y de los objetos de base de datos.

Funciones de conjuntos de filas :Devuelven conjuntos de filas que se pueden usar en el lugar de una referencia de tabla de una instrucción de Transact-SQL.

Funciones de seguridad : Devuelven información acerca de usuarios y funciones.

Funciones de cadena :Tratan valores char, varchar, nchar, nvarchar, binary y varbinary.

Funciones del sistema :Funcionan en o informan acerca de varias opciones y objetos del sistema.

Funciones de estadísticas del sistema :Devuelven información relacionada con el rendimiento de SQL Server.

Funciones de texto e imagen :Tratan valores text e image.

Las funciones se pueden usar o incluir en: • La lista de selección de una consulta que usa una instrucción SELECT para devolver un

valor. SELECT DB_NAME()

• Una condición de búsqueda de una cláusula WHERE de una instrucción SELECT o de modificación de datos (SELECT, INSERT, DELETE o UPDATE) para limitar las filas adecuadas para la consulta. SELECT * FROM [Order Details] WHERE Quantity = (SELECT MAX(Quantity) FROM [Order Details])



• La condición de búsqueda (condición WHERE) de una vista para hacer que la vista se adapte dinámicamente al usuario o entorno en tiempo de ejecución. CREATE VIEW ShowMyEmploymentInfo AS SELECT * FROM Employees WHERE EmployeeID = SUSER_SID() GO

• Cualquier expresión. • Un desencadenador o restricción CHECK para comprobar los valores especificados

cuando se insertan datos. CREATE TABLE SalesContacts (SalesRepID INT PRIMARY KEY CHECK (SalesRepID = SUSER_SID() ), ContactName VARCHAR(50) NULL, ContactPhone VARCHAR(13) NULL)

• Un desencadenador o restricción DEFAULT para suministrar un valor en el caso de que no se especifique ninguno en una instrucción INSERT. CREATE TABLE SalesContacts ( SalesRepID INT PRIMARY KEY CHECK (SalesRepID = SUSER_SID() ), ContactName VARCHAR(50) NULL, ContactPhone VARCHAR(13) NULL, WhenCreated DATETIME DEFAULT GETDATE(), Creator INT DEFAULT SUSER_SID() ) GO

Al utilizar las funciones tome en cuenta los siguiente puntos:

Las funciones se usan siempre con paréntesis, incluso cuando no haya parámetros. Una excepción son las funciones niládicas (funciones que no toman parámetros) usadas con la palabra clave DEFAULT.

Algunas veces, los parámetros que especifican una base de datos, equipo, inicio de sesión o usuario de base de datos son opcionales. Si no se proporcionan, el valor predeterminado es el de la base de datos, equipo host, inicio de sesión o usuario de base de datos actual.

Las funciones se pueden anidar (una función se usa dentro de otra función).

1.5.3 Programar tareas en Transac-SQL

Para realizar procesos que no se pueden llevar a cabo con una sola instrucción de Transact-SQL, Microsoft SQL Server permite agrupar instrucciones de Transact-SQL de varias formas:

• Usar lotes : Un lote es un grupo compuesto por una o varias instrucciones de Transact-SQL que se envían desde una aplicación al servidor como una unidad. SQL Server ejecuta cada lote como una unidad ejecutable individual.

• Utilizar procedimientos almacenados : Un procedimiento almacenado es un grupo de instrucciones de Transact-SQL que han sido definidas y compiladas previamente en el servidor. El procedimiento almacenado puede aceptar parámetros y devolver conjuntos de resultados, códigos de retorno y parámetros de salida a la aplicación que realiza la llamada.

• Utilizar desencadenadores :Un desencadenador es un tipo especial de procedimiento almacenado. No es llamado directamente por las aplicaciones. En su lugar, se ejecuta cuando un usuario realiza una modificación determinada (INSERT, UPDATE o DELETE) en una tabla.

• Utilizar secuencias de comandos : Una secuencia de comandos es una serie de instrucciones de Transact-SQL almacenadas en un archivo. El archivo se puede usar



como entrada para la herramienta osql o para el Analizador de consultas de SQL Server. Las herramientas ejecutarán entonces las instrucciones de Transact-SQL almacenadas en el archivo.

Las siguientes características de SQL Server permiten controlar la utilización de varias instrucciones de Transact-SQL a la vez:

• Instrucciones de control de flujo : Le permiten incluir lógica condicional. Por ejemplo, si el país es Canadá, se realiza una serie de instrucciones de Transact-SQL. Si el país es Reino Unido, se realiza otra serie de instrucciones de Transact-SQL.

• Variables : Le permiten almacenar datos para ser utilizados posteriormente como entrada de una instrucción de Transact-SQL. Por ejemplo, puede que tenga que codificar una consulta que necesite especificar distintos valores de datos en la cláusula WHERE cada vez que se ejecuta la consulta. Puede escribir la consulta para que use variables en la cláusula WHERE y codificar la lógica para que rellene las variables con los datos adecuados. Los parámetros de los procedimientos almacenados son una clase especial de variables.

• Tratamiento de errores : Le permite personalizar la forma en la que SQL Server responde a los problemas. Pueden especificar las acciones apropiadas que se llevarán a cabo cuando se produzcan errores, o generar mensajes de error personalizados que sean más informativos para el usuario que los errores genéricos de SQL Server.

1.5.4 Variables y parámetros

Transact-SQL tiene varias formas de pasar datos entre instrucciones de Transact-SQL. Entre éstas se encuentran:

• Las variables locales de Transact-SQL :Una variable de Transact-SQL es un objeto de lotes y secuencias de comandos de Transact-SQL que puede contener un valor de datos. Una vez que la variable se ha declarado o definido, una instrucción de Transact-SQL de un lote puede establecer la variable a un valor y otra instrucción posterior del lote puede obtener el valor de la variable, por ejemplo: DECLARE @EmpIDVar INT SET @EmpIDVar = 1234 SELECT * FROM Employees WHERE EmployeeID = @EmpIDVar

• Parámetros de Transact-SQL :Un parámetro es un objeto usado para pasar datos entre un procedimiento almacenado y el lote o secuencia de comandos que lo ejecuta. Los parámetros pueden ser de entrada o de salida, como, por ejemplo: CREATE PROCEDURE ParmSample @EmpIDParm INT AS SELECT * FROM Employees WHERE EmployeeID = @EmpIDParm GOEXEC ParmSample @EmpIDParm = 1234 GO

Las aplicaciones usan variables de aplicación y marcadores de parámetros para trabajar con los datos de las instrucciones de Transact-SQL.

• Variables de aplicación :Los lenguajes de programación de aplicaciones como C, C++, Basic y Java tienen sus propias variables para contener datos. Las aplicaciones que usan las API de base de datos tienen que mover los datos devueltos por las instrucciones de Transact-SQL a las variables de aplicación antes de que puedan trabajar con los datos. Esto se hace normalmente en un proceso llamado enlace. La aplicación usa una función de API para enlazar una columna del conjunto de resultados a una variable del programa. Cuando se recupera una fila, el proveedor o controlador de API mueve los datos desde la columna a la variable del programa enlazada.



• Marcadores de parámetros :Los marcadores de parámetros son admitidos por ADO, OLE DB y las API de base de datos basadas en ODBC. Un marcador de parámetro es un signo de interrogación (?) colocado en la posición de una expresión de entrada en una instrucción de Transact-SQL. El marcador de parámetro se enlaza a una variable de aplicación. Esto permite que los datos de variables de aplicación se usen como entradas de las instrucciones de Transact-SQL. Los marcadores de parámetros permiten también que los parámetros de salida y los códigos de retorno de los procedimientos almacenados se enlacen a variables de aplicación. Cuando se ejecuta el procedimiento, los datos de salida se devuelven a las variables enlazadas. La API de las bibliotecas de bases de datos admite también que se enlacen los parámetros de los procedimientos almacenados y los códigos de retorno a las variables del programa.

1.5.5 Control de flujo.

Transact-SQL proporciona palabras especiales que forman parte del llamado lenguaje de control de flujo con el que se controla la ejecución de instrucciones de Transact-SQL, bloques de instrucciones y procedimientos almacenados. Estas palabras se pueden usar en las instrucciones "ad hoc" de Transact-SQL, en los lotes y en los procedimientos almacenados.Sin el lenguaje de control de flujo, las instrucciones independientes de Transact-SQL se ejecutan secuencialmente, tal como se producen. El lenguaje de control de flujo permite que las instrucciones estén conectadas, se relacionen entre ellas y se hagan interdependientes con construcciones similares a las de la programación.Estas palabras para el control de flujo son útiles cuando es necesario dirigir a Transact-SQL para que realice alguna clase de acción. Por ejemplo, use un par de instrucciones BEGIN…END cuando incluya más de una instrucción de Transact-SQL en un bloque lógico. Use un par de instrucciones IF…ELSE cuando una determinada instrucción o bloque de instrucciones tenga que ser ejecutado IF (si) se cumple alguna condición, y deba ejecutarse otra instrucción o bloque de instrucciones si esa condición no se cumple (la condición ELSE).Las instrucciones de control de flujo no pueden dividirse en varios lotes o procedimientos almacenados.Las palabras clave del lenguaje de control de flujo son:

BEGIN…END WAITFORGOTO WHILEIF…ELSE BREAKRETURN CONTINUE

1.5.5.1 BEGIN…END

Las instrucciones BEGIN y END se usan para agrupar varias instrucciones de Transact-SQL en un bloque lógico. Use las instrucciones BEGIN y END en cualquier parte donde una instrucción de control de flujo deba ejecutar un bloque con dos o más instrucciones de Transact-SQL.Por ejemplo, cuando una instrucción IF controla la ejecución de una única instrucción de Transact-SQL, no se necesita ninguna instrucción BEGIN o END:IF (@@ERROR <> 0)SET @ErrorSaveVariable = @@ERRORSi @@ERROR es 0, sólo se salta la instrucción individual SET.Use las instrucciones BEGIN y END para hacer que la instrucción IF salte un bloque de instrucciones cuando el resultado de la evaluación sea FALSE (falso):IF (@@ERROR <> 0)BEGINSET @ErrorSaveVariable = @@ERROR



PRINT 'Error encountered, ' + CAST(@ErrorSaveVariable AS VARCHAR(10))ENDLas instrucciones BEGIN y END deben usarse como un par: no se puede usar una sin la otra. La instrucción BEGIN aparece sola en una línea, seguida de un bloque de instrucciones de Transact-SQL. Finalmente, la instrucción END aparece sola en una línea para indicar el fin del bloque.Las instrucciones BEGIN y END se usan cuando:

• Es necesario que un bucle WHILE incluya un bloque de instrucciones. • Es necesario que un elemento de una función CASE incluya un bloque de instrucciones. • Es necesario que una cláusula IF o ELSE incluya un bloque de instrucciones

1.5.5.2 GOTO

La instrucción GOTO provoca que, en la ejecución de un lote de Transact-SQL, se salte a una etiqueta. Ninguna de las instrucciones situadas entre la instrucción GOTO y la etiqueta se ejecutarán. El nombre de la etiqueta se define con la sintaxis:nombreEtiqueta:No abuse de la utilización de la instrucción GOTO. Una utilización excesiva de esta instrucción puede hacer que resulte difícil entender la lógica de un lote de Transact-SQL. La lógica desarrollada con GOTO casi siempre se puede implementar con las instrucciones de control de flujo. La mejor utilización de GOTO se produce cuando se necesita romper la anidación profunda de instrucciones de control de flujo.La etiqueta que constituye el objetivo de un GOTO sólo identifica el destino del salto. No hace nada para aislar las instrucciones que le siguen de las instrucciones que le preceden. Cualquier usuario que ejecute las instrucciones situadas justo antes de la etiqueta se la saltará y ejecutará las instrucciones posteriores a la misma. Esto ocurrirá a menos que las instrucciones que preceden a la etiqueta sean a su vez instrucciones de control de flujo como, por ejemplo, RETURN.

Esto es un ejemplo de un GOTO:IF (SELECT SYSTEM_USER()) = 'payroll' GOTO Vete_aUPDATE ‘una tabla’DELETE ‘una tabla’--si la condición es verdadera se ignorán las dos --intsrucciones anteriores-- statements following the GOTO are executed.Vete_a:--Sigue el flujo del programa

1.5.5.3 IF…ELSE

La instrucción IF se usa para probar una condición. El control de flujo resultante depende de si se especifica o no la instrucción ELSE opcional:

• IF especificado sin ELSE. Cuando la instrucción IF da como resultado TRUE (verdadero), se ejecuta la instrucción o bloque de instrucciones que sigue a la instrucción IF. Cuando la instrucción IF da como resultado FALSE (falso), se salta la instrucción o bloque de instrucciones que sigue a la instrucción IF.

• IF especificado con ELSE. Cuando la instrucción IF da como resultado TRUE, se ejecuta la instrucción o bloque de instrucciones que siguen a IF y el control salta al punto posterior a la instrucción o bloque de instrucciones que sigue a ELSE. Cuando la instrucción IF da como resultado FALSE, se salta la instrucción o bloque de instrucciones que sigue a IF y se ejecuta la instrucción o bloque de instrucciones que sigue a la instrucción ELSE opcional.



Por ejemplo, si un procedimiento almacenado ha estado guardando los códigos de error devueltos por @@ERROR durante una transacción, podría tener una instrucción IF similar a la siguiente al final del procedimiento:IF (@ErrorSaveVariable <> 0)

BEGINPRINT 'Errores encontrados, va pa tras.'CAST(@ErrorSaveVariable AS VARCHAR(10))ROLLBACK

ENDELSE

BEGINPRINT 'No existen errores, aceptamos trasacción.'COMMIT

ENDRETURN @ErrorSaveVariable

1.5.5.4 RETURN

La instrucción RETURN termina incondicionalmente una consulta, procedimiento almacenado o lote. Ninguna de las instrucciones de un procedimiento almacenado o lote que siga a la instrucción RETURN se ejecutará.Cuando se usa en un procedimiento almacenado, la instrucción RETURN puede especificar un valor entero para devolver a la aplicación, lote o procedimiento que realiza la llamada. Si no se especifica ningún valor en la instrucción RETURN, un procedimiento almacenado devuelve el valor 0.La mayor parte de los procedimientos almacenados siguen la convención de usar el código de retorno para indicar si el procedimiento almacenado se ha ejecutado correctamente o no. Los procedimientos almacenados devuelven el valor 0 cuando no se encontraron errores. Cualquier valor distinto de cero indica que se produjo un error. Por ejemplo:USE NorthwindGO-- Create a procedure that takes one input parameter-- and returns one output parameter and a return code.CREATE PROCEDURE SampleProcedure @EmployeeIDParm INT,@MaxQuantity INT OUTPUTAS-- Declare and initialize a variable to hold @@ERROR.DECLARE @ErrorSave INTSET @ErrorSave = 0-- Do a SELECT using the input parameter.SELECT FirstName, LastName, TitleFROM EmployeesWHERE EmployeeID = @EmployeeIDParm-- Save any nonzero @@ERROR value.IF (@@ERROR <> 0)SET @ErrorSave = @@ERROR-- Set a value in the output parameter.SELECT @MaxQuantity = MAX(Quantity)FROM [Order Details]IF (@@ERROR <> 0)SET @ErrorSave = @@ERROR-- Returns 0 if neither SELECT statement had-- an error, otherwise returns the last error.RETURN @ErrorSaveGO



Un lote o procedimiento almacenado de Transact-SQL que ejecuta un procedimiento almacenado puede recuperar el código de retorno en una variable de tipo entero:DECLARE @ReturnStatus INTDECLARE @MaxQtyVariable INTEXECUTE @ReturnStatus = SampleProcedure @EmployeeIDParm = 9,@MaxQtyVariable = @MaxQuantity OUTPUT-- Show the values returned.PRINT ' 'PRINT 'Return code = ' + CAST(@ReturnStatus AS CHAR(10))PRINT 'Maximum Quantity = ' + CAST(@MaxQtyVariable AS CHAR(10))GOLas aplicaciones que llaman a un procedimiento almacenado pueden enlazar a una variable de tipo entero el marcador de parámetro que corresponda al código de retorno.

1.5.5.5 WAITFOR

La instrucción WAITFOR suspende la ejecución de una conexión hasta que: Haya pasado un intervalo especificado de tiempo. Se haya alcanzado una hora especificada del día.

La instrucción WAITFOR se especifica con una de estas dos cláusulas: La palabra clave DELAY seguida de una cantidadTiempoQuePasar antes de que se complete la instrucción WAITFOR. El tiempo que puede pasar antes de la finalización de la instrucción WAITFOR puede ser de hasta 24 horas. La palabra clave TIME seguida de una horaDeEjecución que especifica cuándo se completa la instrucción WAITFOR.

En este ejemplo se usa la palabra clave DELAY para esperar dos segundos antes de realizar una instrucción SELECT:WAITFOR DELAY '00:00:02'SELECT EmployeeID FROM Northwind.dbo.EmployeesEn este ejemplo se usa la palabra clave TIME para esperar hasta las 10 p.m. para realizar una comprobación de la base de datos especificada pubs con el fin de asegurar que todas las páginas están asignadas y se usan correctamente.USE pubsBEGINWAITFOR TIME '22:00'DBCC CHECKALLOCENDLa desventaja de la instrucción WAITFOR es que la conexión de la aplicación permanece suspendida hasta que finaliza WAITFOR. El mejor uso de WAITFOR se produce cuando se necesita suspender el procesamiento de una aplicación o procedimiento almacenado durante un tiempo limitado. La utilización del Agente SQL Server o de SQL-DMO para programar una tarea constituye un método más adecuado para ejecutar una acción a una hora determinada del día.

1.5.5.6 WHILE…BREAK o CONTINUE

La instrucción WHILE repite una instrucción o bloque de instrucciones mientras la condición especificada siga siendo verdadera.Con WHILE se usan normalmente dos instrucciones de Transact-SQL: BREAK o CONTINUE. La instrucción BREAK sale del bucle WHILE más profundo, y la instrucción CONTINUE reinicia un bucle WHILE. Un programa podría ejecutar una instrucción BREAK si, por ejemplo, no hubiera más filas que procesar. Una instrucción CONTINUE podría ejecutarse si, por ejemplo, la ejecución del código debiera continuar.



Nota Si una instrucción SELECT se usa como condición de la instrucción WHILE, la instrucción SELECT debe ir entre paréntesis.

En este ejemplo se usa una instrucción WHILE para controlar el número de recopilaciones realizadas:USE NorthwindGODECLARE abc CURSOR FORSELECT * FROM ShippersOPEN abcFETCH NEXT FROM abcWHILE (@@FETCH_STATUS = 0)FETCH NEXT FROM abcCLOSE abcDEALLOCATE abcGOOtras pruebas válidas de la condición WHILE podrían ser las siguientes:WHILE (@ACounterVariable < 100)- O bien -WHILE EXISTS(SELECT au_lname FROM authors WHERE au_fname = 'Anne')

1.5.5.5 CASE

La función CASE es una expresión especial de Transact-SQL que permite que se muestre un valor alternativo dependiendo del valor de una columna. Este cambio es temporal, con lo que no hay cambios permanentes en los datos. Por ejemplo, la función CASE puede mostrar California en un conjunto de resultados de una consulta de las filas que tengan el valor CA en la columna state.La función CASE está compuesta de:

• La palabra clave CASE. • El nombre de columna que se va a transformar. • Cláusulas WHEN que especifican las expresiones que se van a buscar y cláusulas THEN

que especifican las expresiones que las van a reemplazar. • La palabra clave END. • Una cláusula AS opcional que define un alias de la función CASE.

En este ejemplo se muestra, en el conjunto de resultados de la consulta, el nombre completo del estado en el que vive cada autor:SELECT au_fname, au_lname, CASE stateWHEN 'CA' THEN 'California'WHEN 'KS' THEN 'Kansas'WHEN 'TN' THEN 'Tennessee'WHEN 'OR' THEN 'Oregon'WHEN 'MI' THEN 'Michigan'WHEN 'IN' THEN 'Indiana'WHEN 'MD' THEN 'Maryland'WHEN 'UT' THEN 'Utah'END AS StateNameFROM pubs.dbo.authorsORDER BY au_lname



1.6 TransaccionesUna transacción es una secuencia de operaciones realizadas como una sola unidad lógica de trabajo. Una unidad lógica de trabajo debe exhibir cuatro propiedades, conocidas como propiedades ACID (atomicidad, coherencia, aislamiento y durabilidad), para ser calificada como transacción:

Atomicidad :Una transacción debe ser una unidad atómica de trabajo, tanto si se realizan todas sus modificaciones en los datos, como si no se realiza ninguna de ellas.

Coherencia :Cuando finaliza, una transacción debe dejar todos los datos en un estado coherente. En una base de datos relacional, se debe aplicar todas las reglas a las modificaciones de la transacción para mantener la integridad de todos los datos. Todas las estructuras internas de datos, como índices de árbol B o listas doblemente vinculadas, deben estar correctos al final de la transacción.

Aislamiento :Las modificaciones realizadas por transacciones simultáneas se deben aislar de las modificaciones llevadas a cabo por otras transacciones simultáneas. Una transacción ve los datos en el estado en que estaban antes de que otra transacción simultánea los modificara o después de que la segunda transacción se haya concluido, pero no ve un estado intermedio. Esto se conoce como seriabilidad debido a que su resultado es la capacidad de volver a cargar los datos iniciales y reproducir una serie de transacciones para finalizar con los datos en el mismo estado en que estaban después de realizar las transacciones originales.

Durabilidad :Una vez concluida una transacción, sus efectos son permanentes en el sistema. Las modificaciones persisten aún en el caso de producirse un error del sistema.

Especificar y exigir transacciones

Los programadores de SQL son los responsables de iniciar y finalizar las transacciones en puntos que exijan la coherencia lógica de los datos. El programador debe definir la secuencia de modificaciones de datos que los dejan en un estado coherente en relación a las reglas corporativas de la organización. A continuación, el programador incluye estas instrucciones de modificación en una sola transacción de forma que Microsoft SQL Server puede exigir la integridad física de la misma.Es responsabilidad de un sistema de base de datos corporativo como SQL Server proporcionar los mecanismos que aseguren la integridad física de cada transacción. SQL Server proporciona:

• Servicios de bloqueo que preservan el aislamiento de la transacción. • Servicios de registro que aseguran la durabilidad de la transacción. Aún en el caso de que

falle el hardware del servidor, el sistema operativo o el propio SQL Server, SQL Server utiliza registros de transacciones, al reinicio, para deshacer automáticamente las transacciones incompletas en el momento en que se produjo el error en el sistema.

• Características de administración de transacciones que exigen la atomicidad y coherencia de la transacción. Una vez iniciada una transacción, debe concluirse correctamente o SQL Server deshará todas las modificaciones de datos realizadas desde que se inició la transacción.

1.6.1 Controlar las transacciones.

Las aplicaciones controlan las transacciones principalmente al especificar cuándo se inicia y finaliza una transacción. Esto se puede especificar mediante la utilización de instrucciones de



Transact-SQL o funciones de la API de base de datos. El sistema también debe ser capaz de controlar correctamente los errores que terminan una transacción antes de que se concluya.Las transacciones se administran en las conexiones. Cuando se inicia una transacción en una conexión, todas las instrucciones de Transact-SQL ejecutadas en esa conexión forman parte de la transacción hasta que la transacción finaliza.

Puede iniciar transacciones en Microsoft SQL Server como transacciones explícitas, de confirmación automática o implícitas.

Transacciones explícitas:Inicie una transacción de forma explícita mediante la instrucción BEGIN TRANSACTION.

Transacciones de confirmación automática :Éste es el modo predeterminado de SQL Server. Cada instrucción individual de Transact-SQL se confirma cuando termina. No tiene que especificar instrucciones para controlar las transacciones.

Transacciones implícitas :Establezca el modo de transacción implícita a través de una función de la API o la instrucción SET IMPLICIT_TRANSACTIONS ON de Transact-SQL . La siguiente instrucción inicia automáticamente una nueva transacción. Cuando se concluye la transacción, la instrucción de Transact-SQL siguiente inicia una nueva transacción.

Los modos de conexión se administran en las conexiones. Si una transacción cambia de un modo de transacción a otro, no tiene efecto sobre los modos de transacción de otras conexiones.

Finalizar transacciones

Puede finalizar las transacciones con la instrucción COMMIT o la instrucción ROLLBACK.

COMMIT

Si una transacción es correcta, confírmela. La instrucción COMMIT garantiza que todas las modificaciones de la transacción se convierten en una parte permanente de la base de datos. La instrucción COMMIT también libera recursos que utiliza la transacción como, por ejemplo, los bloqueos.

ROLLBACK

Si se produce un error en una transacción o el usuario decide cancelar la transacción, deshaga la transacción. La instrucción ROLLBACK deshace todas las modificaciones realizadas en la transacción al devolver los datos al estado en que estaban al inicio de la transacción. La instrucción ROLLBACK también libera los recursos que mantiene la transacción.

Especificar los límites de la transacción

Puede identificar si las transacciones de SQL Server se inician y finalizan con instrucciones de Transact-SQL o con funciones y métodos de la API.

Instrucciones de Transact-SQL

Utilice las instrucciones BEGIN TRANSACTION, COMMIT TRANSACTION, COMMIT WORK, ROLLBACK TRANSACTION, ROLLBACK WORK y SET IMPLICIT_TRANSACTIONS para delinear transacciones. Se utilizan principalmente en aplicaciones de Bibliotecas de bases de datos y en secuencias de comandos de



Transact-SQL, como las secuencias de comandos que se ejecutan con el programa del símbolo del sistema osql.

Funciones y métodos de la API

Las API de bases de datos, como ODBC, OLE DB y ADO contienen funciones o métodos utilizados para delinear transacciones. Éstos son los principales mecanismos utilizados para controlar transacciones en una aplicación de SQL Server.

Cada transacción se debe administrar solamente mediante uno de estos métodos. La utilización de ambos métodos en la misma transacción puede conducir a resultados no definidos. Por ejemplo, no debe iniciar una transacción con las funciones de la API de ODBC y después utilizar la instrucción COMMIT de Transact-SQL para concluir la transacción. De esta forma, no notificaría al controlador ODBC de SQL Server que se confirmó la transacción. En este caso, utilice la función SQLEndTran de ODBC para finalizar la transacción.

Errores al procesar la transacción

Si un error grave impide la terminación correcta de una transacción, SQL Server deshace automáticamente la transacción y libera todos los recursos que mantiene la transacción. Si se interrumpe la conexión de red del cliente con SQL Server, las transacciones pendientes de la conexión se deshacen cuando la red notifica a SQL Server la interrupción. Si la aplicación cliente falla o si el equipo cliente se bloquea o se reinicia, también se interrumpe la conexión y SQL Server deshace las conexiones pendientes cuando la red le notifica la interrupción. Si el cliente cierra la aplicación, se deshacen las transacciones pendientes.Si se produce el error de una instrucción en tiempo de ejecución (como una infracción de restricciones) en un archivo por lotes, el comportamiento predeterminado de SQL Server consiste en deshacer solamente la instrucción que generó el error. Puede modificar este comportamiento con la instrucción SET XACT_ABORT. Una vez ejecutada la instrucción SET XACT_ABORT ON, los errores de instrucciones en tiempo de ejecución hacen que se deshaga automáticamente la transacción actual. Los errores de compilación como, por ejemplo, un error de sintaxis no se ven afectados por la instrucción SET XACT_ABORT.Es responsabilidad del programador codificar la aplicación para especificar la acción correcta (COMMIT o ROLLBACK) si se produce un error de compilación o en tiempo de ejecución.

1.6.2 Transacciones explícitas

Una transacción explícita es aquella en que se define explícitamente el inicio y el final de la transacción. Las transacciones explícitas también recibían el nombre de transacciones definidas por el usuario o especificadas por el usuario en versiones anteriores de Microsoft SQL Server .Las aplicaciones de bibliotecas de base de datos y secuencias de comandos de Transact-SQL utilizan las instrucciones de Transact-SQL BEGIN TRANSACTION, COMMIT TRANSACTION, COMMIT WORK, ROLLBACK TRANSACTION o ROLLBACK WORK para definir transacciones explícitas.

BEGIN TRANSACTION :Marca el punto de inicio de una transacción explícita de una conexión.

COMMIT TRANSACTION o COMMIT WORK :Se utiliza para finalizar una transacción correctamente si no hubo errores. Todas las modificaciones de datos realizadas en la transacción se convierten en parte permanente de la base de datos. Los recursos mantenidos por la transacción se liberan.



ROLLBACK TRANSACTION o ROLLBACK WORK :Se utiliza para eliminar una transacción en la que se encontraron errores. Se devuelven todos los datos que modifica la transacción al estado en que estaba al inicio de la transacción. Los recursos mantenidos por la transacción se liberan.

También puede utilizar transacciones explícitas en OLE DB. Llame al método ITransactionLocal::StartTransaction para iniciar una transacción. Llame al método ITransaction::Commit o ITransaction::Abort con FALSE establecido en fRetener para finalizar la transacción sin iniciar automáticamente otra transacción.En ADO, utilice el método BeginTrans en un objeto Connection para iniciar una transacción explícita. Para finalizar la transacción, llame a los métodos CommitTrans o RollbackTrans del objeto Connection.La API de ODBC no acepta transacciones explícitas, sólo acepta transacciones de confirmación automática y transacciones implícitas.El modo de transacciones explícitas se mantiene solamente durante la transacción. Cuando la transacción termina, la conexión vuelve al modo de transacción en que estaba antes de iniciar la transacción explícita, es decir, el modo implícito o el modo de confirmación automática.

1.6.3 Transacciones de confirmación automática

El modo de confirmación automática es el modo predeterminado de administración de transacciones de Microsoft SQL Server . Toda instrucción de Transact-SQL se confirma o se deshace cuando termina. Si una instrucción termina correctamente, se confirma; si encuentra un error, se deshace. Una conexión de SQL Server funciona en modo de confirmación automática siempre que no se suplante el modo predeterminado mediante transacciones explícitas o implícitas. El modo de confirmación automática es también el modo predeterminado para la biblioteca de bases de datos, ODBC, OLE DB y ADO.Una conexión de SQL Server funcionará en modo de confirmación automática hasta que la instrucción BEGIN TRANSACTION inicie una transacción explícita o se active el modo de transacciones implícitas. Cuando la transacción explícita se confirma o se deshace, o cuando se desactiva el modo de transacciones implícitas, SQL Server vuelve al modo de confirmación automática.

Errores de compilación y en tiempo de ejecución

En el modo de confirmación automática, a veces parece que SQL Server ha deshecho un proceso por lotes completo en vez de deshacer solamente una instrucción SQL. Esto sólo sucede si se trata de un error de compilación, no en el caso de un error en tiempo de ejecución. Los errores de compilación impiden que SQL Server genere un plan de ejecución, por lo que no se ejecuta ninguna instrucción del proceso por lotes. Aunque parezca que se ha deshecho todas las instrucciones anteriores a la que generó el error, el error impidió que se ejecutara ninguna instrucción del proceso por lotes. En este ejemplo, no se ejecutó ninguna de las instrucciones INSERT del tercer proceso por lotes debido a un error de compilación. Parece que se han deshecho las dos primeras instrucciones INSERT cuando, en realidad, nunca se ejecutaron.USE pubsGOCREATE TABLE TestBatch (Cola INT PRIMARY KEY, Colb CHAR(3))GOINSERT INTO TestBatch VALUES (1, 'aaa')INSERT INTO TestBatch VALUES (2, 'bbb')INSERT INTO TestBatch VALUSE (3, 'ccc') /* Syntax error */GOSELECT * FROM TestBatch /* Returns no rows */GO



En este ejemplo, la tercera instrucción INSERT genera un error de clave principal duplicada en tiempo de ejecución. Las dos primeras instrucciones INSERT eran correctas y se han confirmado, por lo que permanecen después de producirse el error en tiempo de ejecución.USE pubsGOCREATE TABLE TestBatch (Cola INT PRIMARY KEY, Colb CHAR(3))GOINSERT INTO TestBatch VALUES (1, 'aaa')INSERT INTO TestBatch VALUES (2, 'bbb')INSERT INTO TestBatch VALUES (1, 'ccc') /* Duplicate key error */GOSELECT * FROM TestBatch /* Returns rows 1 and 2 */GOSQL Server versión 7.0 introduce la resolución demorada de nombres, en la que no se resuelven los nombres de los objetos hasta la ejecución. Las versiones anteriores de SQL Server resolvían los nombres en tiempo de compilación. Algunos errores que eran de compilación y evitaban la ejecución de un proceso por lotes en versiones anteriores de SQL Server son errores en tiempo de ejecución en SQL Server 7.0. En este ejemplo, se ejecutaron y confirmaron las dos primeras instrucciones INSERT y las dos filas permanecen en la tabla TestBatch después de que la tercera instrucción INSERT generara un error en tiempo de ejecución al hacer referencia a una tabla que no existe.USE pubsGOCREATE TABLE TestBatch (Cola INT PRIMARY KEY, Colb CHAR(3))GOINSERT INTO TestBatch VALUES (1, 'aaa')INSERT INTO TestBatch VALUES (2, 'bbb')INSERT INTO TestBch VALUES (3, 'ccc') /* Table name error */GOSELECT * FROM TestBatch /* Returns rows 1 and 2 */GO

1.7 CursoresLas operaciones de una base de datos relacional actúan en un conjunto completo de filas. El conjunto de filas que devuelve una instrucción SELECT está compuesto de todas las filas que satisfacen las condiciones de la cláusula WHERE de la instrucción. Este conjunto completo de filas que devuelve la instrucción se conoce como el conjunto de resultados. Las aplicaciones, especialmente las aplicaciones interactivas en línea, no siempre pueden trabajar de forma efectiva con el conjunto de resultados completo como una unidad. Estas aplicaciones necesitan un mecanismo que funcione con una fila o un pequeño bloque de filas a la vez. Los cursores son una extensión de los conjuntos de resultados que proporcionan dicho mecanismo. Los cursores amplían el procesamiento de los resultados debido a que:

• Permiten situarse en filas específicas del conjunto de resultados. • Recuperan una fila o bloque de filas de la posición actual en el conjunto de resultados. • Aceptan modificaciones de los datos de las filas en la posición actual del conjunto de

resultados • Aceptan diferentes grados de visibilidad de los cambios que realizan otros usuarios en los

datos de la base de datos que se presentan en el conjunto de resultados. • Proporcionan instrucciones de Transact-SQL en secuencias de comandos,

procedimientos almacenados y acceso de desencadenadores a los datos de un conjunto de resultados.

Pedir un cursor

Microsoft SQL Server acepta dos métodos para pedir un cursor:



• Transact-SQL El lenguaje Transact-SQL admite una sintaxis para utilizar cursores modelados a partir de la sintaxis de cursores de SQL-92.

• Funciones de cursores de interfaces de programación de aplicaciones (API) de bases de datos. SQL Server admite la funcionalidad de cursores de las siguientes API de bases de datos:

• ADO (Microsoft ActiveX Data Object) • OLE DB • ODBC (Conectividad abierta de bases de datos) • Bibliotecas de bases de datos

Una aplicación nunca debe mezclar estos dos métodos de petición de cursores. Una aplicación que ha utilizado la API para especificar comportamientos de cursores no debe ejecutar una instrucción DECLARE CURSOR de Transact-SQL para pedir también un cursor de Transact-SQL. Una aplicación sólo debe ejecutar DECLARE CURSOR si ha devuelto todos los atributos de cursores de la API a su configuración predeterminada.Si no se ha pedido un cursor de Transact-SQL ni un cursor de la API, la configuración predeterminada de SQL Server consiste en devolver un conjunto de resultados completo, conocido como conjunto de resultados predeterminado, a la aplicación.

Proceso de cursores

Los cursores de Transact-SQL y los cursores de la API tienen una sintaxis diferente, pero se utiliza el siguiente proceso general con todos los cursores de SQL Server:

1. Asocie un cursor con el conjunto de resultados de una instrucción Transact-SQL y defina las características del cursor como, por ejemplo, si se puede actualizar las filas del cursor.

2. Ejecute la instrucción de Transact-SQL para llenar el cursor. 3. Recupere las filas del cursor que desea ver. La operación de recuperar una fila o un

bloque de filas de un cursor recibe el nombre de recopilación. Realizar series de recopilaciones para obtener filas con desplazamientos adelante o hacia atrás recibe el nombre de desplazamiento.

4. Opcionalmente, realice operaciones de modificación (actualización o eliminación) en la fila de la posición actual del cursor.

5. Cierre el cursor.

1.7.1 Cursores de Transact-SQL

Los cursores de Transact-SQL se utilizan principalmente en procedimientos almacenados, desencadenadores y secuencias de comandos de Transact-SQL en los que el contenido de un conjunto de resultados está disponible para otras instrucciones de Transact-SQL.El proceso típico para utilizar un cursor de Transact-SQL en un procedimiento almacenado o desencadenador es:

1. Declare las variables de Transact-SQL que contendrán los datos que devuelva el cursor. Declare una variable para cada columna del conjunto de resultados. Declare las variables lo suficientemente grandes como para que contengan los valores que devuelve la columna y con un tipo de datos que se pueda convertir implícitamente desde el tipo de datos de la columna.

2. Asocie un cursor de Transact-SQL con una instrucción SELECT mediante la instrucción DECLARE CURSOR. La instrucción DECLARE CURSOR también define las características del cursor como, por ejemplo, el nombre del cursor y si el cursor es de sólo lectura o de desplazamiento sólo hacia delante.

3. Utilice la instrucción OPEN para ejecutar la instrucción SELECT y llenar el cursor. 4. Utilice la instrucción FETCH INTO para recopilar filas individuales y mover los datos de

cada columna a la variable especificada. Otras instrucciones de Transact-SQL pueden hacer referencia a estas variables para tener acceso a los valores de los datos



recopilados. Los cursores de Transact-SQL no admiten la recopilación de bloques de columnas.

5. Cuando haya terminado con el cursor, utilice la instrucción CLOSE. Cerrar un cursor libera algunos recursos, como el conjunto de resultados del cursor y sus bloqueos en la fila actual, pero la estructura del cursor sigue disponible para procesarla si vuelve a emitir una instrucción OPEN. Dado que el cursor sigue presente, no puede volver a utilizar el nombre del cursor en este momento. La instrucción DEALLOCATE libera completamente todos los recursos asignados al cursor, incluido el nombre del cursor. Una vez que se ha cancelado la asignación de un cursor, debe emitir una instrucción DECLARE para volver a generar el cursor.

Supervisar la actividad de cursores de Transact-SQL

Puede utilizar el procedimiento almacenado del sistema sp_cursor_list para obtener una lista de los cursores visibles en la conexión actual y sp_describe_cursor, sp_describe_cursor_columns y sp_describe_cursor_tables para determinar las características de un cursor.Una vez abierto el cursor, la función @@CURSOR_ROWS o la columna cursor_rows que devuelve sp_cursor_list o sp_describe_cursor indican el número de filas del cursor.Tras cada instrucción FETCH, se actualiza @@FETCH_STATUS para reflejar el estado de la última recopilación. También puede obtener esta información de estado en la columna fetch_status que devuelve sp_describe_cursor. @@FETCH_STATUS informa de condiciones como, por ejemplo, si se recopila más allá de la primera o última fila del cursor. @@FETCH_STATUS es global para la conexión y se restablece por cada recopilación que se realiza en cualquier cursor abierto en la conexión. Si va a necesitar el estado posteriormente, guarde @@FETCH_STATUS en una variable de usuario antes de ejecutar otra instrucción en la conexión. Aunque la siguiente instrucción no sea FETCH, puede ser una instrucción INSERT, UPDATE o DELETE que activa el desencadenador. Éste contiene instrucciones FETCH que restablecen @@FETCH_STATUS. La columna fetch_status que devuelve sp_describe_cursor es específica del cursor especificado y no se ve afectada por las instrucciones FETCH que hagan referencia a otros cursores. Sin embargo, sp_describe_cursor se ve afectada por las instrucciones FETCH que hacen referencia al mismo cursor, por lo que se debe utilizar con cuidado.Cuando se completa la instrucción FETCH, se dice que el cursor está ubicado en la fila recopilada. La fila recopilada se conoce como la fila actual. Si no se declaró el cursor como de sólo lectura, puede ejecutar una instrucción UPDATE o DELETE con la cláusula WHERE CURRENT OF nombreCursor para modificar la fila actual.El nombre que asigna a un cursor de Transact-SQL la instrucción DECLARE CURSOR puede ser global o local. Cualquier lote, procedimiento almacenado o desencadenador que se ejecute en la misma conexión puede hacer referencia a nombres de cursores globales. No se puede hacer referencia a nombres de cursores locales fuera del lote, procedimiento almacenado o desencadenador en que se declaró el cursor. Por lo tanto, los cursores locales de los desencadenadores y procedimientos almacenados están protegidos contra referencias no deseadas fuera del procedimiento almacenado o desencadenador.

Utilizar la variable cursor

Microsoft SQL Server también admite variables con el tipo de datos cursor. Se puede asociar un cursor con una variable de tipo cursor mediante dos métodos:/* Use DECLARE @local_variable, DECLARE CURSOR and SET. */DECLARE @MyVariable CURSORDECLARE MyCursor CURSOR FORSELECT LastName FROM Northwind.dbo.EmployeesSET @MyVariable = MyCursor/* Use DECLARE @local_variable and SET */DECLARE @MyVariable CURSORSET @MyVariable = CURSOR SCROLL KEYSET FORSELECT LastName FROM Northwind.dbo.Employees



Tras asociar un cursor a una variable de tipo cursor, se puede utilizar la variable cursor en lugar del nombre del cursor en las instrucciones de cursor de Transact-SQL. El tipo de datos cursor también se puede asignar a los parámetros de salida de un procedimiento almacenado y asociarlo a un cursor. Esto permite que los procedimientos almacenados expongan cursores locales de una forma controlada.

Hacer referencia a cursores de Transact-SQL

Sólo se puede hacer referencia a nombres de cursores de Transact-SQL y variables mediante instrucciones de Transact-SQL; no se les puede hacer referencia desde funciones de la API de OLE DB, ODBC, ADO y bibliotecas de bases de datos. Por ejemplo, si utiliza DECLARE CURSOR y OPEN en un cursor de Transact-SQL, no hay forma de utilizar las funciones SQLFetch o SQLFetchScroll de ODBC para recopilar una fila del cursor de Transact-SQL. La aplicaciones que necesitan procesamiento de cursores y utilizan estas API deben utilizar la compatibilidad de cursor integrada en la API de base de datos en lugar de cursores de Transact-SQL.Puede utilizar cursores de Transact-SQL en aplicaciones si utiliza FETCH y enlaza cada columna que devuelve FETCH a una variable de programa. Sin embargo, dado que la instrucción FETCH de Transact-SQL no admite lotes, ésta es la forma menos eficaz de devolver datos a una aplicación. Recopilar cada fila requiere un viaje de ida y vuelta al servidor. Es más eficaz utilizar la funcionalidad de cursor integrada en la API de la base de datos que admitir la recopilación de lotes de filas.Los cursores de Transact-SQL son extremadamente eficaces cuando se incluyen en procedimientos almacenados y desencadenadores. Esto se debe a que todo se compila en un plan de ejecución en el servidor y no hay tráfico de red asociado con la recopilación de filas.

Recopilar y desplazarLa operación que consiste en recuperar una fila de un cursor recibe el nombre de recopilación. Éstas son las opciones de recopilación:

• FETCH FIRST Recopila la primera fila del cursor.

• FETCH NEXT Recopila la fila siguiente a la última fila recopilada.

• FETCH PRIOR Recopila la fila anterior a la última fila recopilada.

• FETCH LAST Recopila la última fila del cursor.

• FETCH ABSOLUTE n Recopila la enésima fila a partir de la primera fila del cursor, si n es un entero positivo. Si n es un entero negativo, se recopila la fila que está n filas antes del final del cursor. Si n es 0, no se recopila ninguna fila.

• FETCH RELATIVE n Recopila la fila que está n filas a partir de la última fila recopilada. Si n es positivo, se recopila la fila que está n filas después de la última fila recopilada. Si n es negativo, se recopila la fila que está n filas delante de la última fila recopilada. Si n es 0, se recopila de nuevo la misma fila.

Cuando se abre un cursor, la posición de la fila actual del cursor está lógicamente delante de la primera fila. Esto hace que las diferentes opciones de recopilación tengan el siguiente comportamiento si se trata de la primera recopilación que se realiza tras abrir el cursor:

• FETCH FIRST Recopila la primera fila del cursor.

• FETCH NEXT Recopila la primera fila del cursor.

• FETCH PRIOR No recopila una fila.

• FETCH LAST



Recopila la última fila del cursor. • FETCH ABSOLUTE n

Recopila la enésima fila a partir de la primera fila del cursor, si n es un entero positivo. Si n es un entero negativo, se recopila la fila que está n filas delante del final del cursor (por ejemplo, n = -1 devuelve la última fila del cursor). Si n es 0, no se recopila ninguna fila.

• FETCH RELATIVE n Recopila la enésima fila del cursor, si n es positivo. No se recopila ninguna fila si n es negativo o 0.

Los cursores de Transact-SQL están limitados a recopilar una fila cada vez. Los cursores de servidor de la API admiten la recopilación de bloques de filas en cada recopilación. Un cursor que admite la recopilación de varias filas a la vez recibe el nombre de cursor de bloque.

Clasificaciones de cursores

Se puede clasificar un cursor por las opciones de recopilación que admite: • Desplazamiento sólo hacia delante

Se debe recopilar las filas en serie desde la primera a la última fila. FETCH NEXT es la única operación de recopilación permitida.

• Desplazable Se puede recopilar las filas aleatoriamente desde cualquier posición del cursor. Se permiten todas las operaciones de recopilación (excepto que los cursores dinámicos no admiten la recopilación absoluta).

Los cursores desplazables son especialmente útiles para las aplicaciones en pantalla. Se puede asignar un cursor a una cuadrícula o cuadro de lista de la aplicación. A medida que el usuario se desplaza hacia delante y hacia atrás en la cuadrícula, la aplicación utiliza recopilaciones de desplazamiento para recopilar las filas del cursor que desea ver el usuario.

1.7.2 Tipos de cursores

ODBC, ADO y la biblioteca de bases de datos definen cuatro tipos de cursores que admite Microsoft SQL Server . Con SQL Server versión 7.0, se ha ampliado la instrucción DECLARE CURSOR para que pueda especificar cuatro tipos de cursor para cursores de Transact-SQL. Estos cursores varían en su capacidad para detectar cambios en el conjunto de resultados y en los recursos, como la memoria y espacio de tempdb, que consumen. Un cursor puede detectar cambios en las filas sólo cuando intenta volver a recopilar dichas filas; no hay forma de que el origen de datos notifique al cursor las modificaciones realizadas en las filas actualmente recopiladas. La capacidad de un cursor para detectar las cambios también está influida por el nivel de aislamiento de la transacción.Los cuatro tipos de cursores de servidor de la API que admite SQL Server son:

• Cursores estáticos • Cursores dinámicos • Cursores de desplazamiento sólo hacia delante • Cursores controlados por conjunto de claves

Los cursores estáticos detectan pocos o ningún cambio pero consumen relativamente pocos recursos al desplazarse, aunque almacenan el cursor completo en tempdb. Los cursores dinámicos detectan todos los cambios pero consumen más recursos al desplazarse, aunque realizan el uso más ligero de tempdb. Los cursores controlados por conjunto de claves se encuentran entre los anteriores: detectan la mayor parte de los cambios pero con un consumo menor que los cursores dinámicos.Aunque los modelos de cursor de la API de bases de datos consideran un cursor de desplazamiento sólo hacia delante como un cursor de distinto tipo, SQL Server no hace esta distinción. SQL Server considera que las opciones de desplazamiento sólo hacia delante y de desplazamiento son las que se puede aplicar a los cursores estáticos, controlados por conjunto de claves y dinámicos.



1.7.3 DECLARE CURSOR

Define los atributos de un cursor de servidor Transact-SQL, como su comportamiento de desplazamiento y la consulta utilizada para generar el conjunto de resultados sobre el que opera el cursor. DECLARE CURSOR acepta la sintaxis basada en el estándar SQL-92 y la sintaxis de un conjunto de extensiones de Transact-SQL.

Sintaxis de SQL-92

DECLARE nombreCursor [INSENSITIVE] [SCROLL] CURSORFOR instrucciónSELECT[FOR {READ ONLY | UPDATE [OF listaColumnas [,...n]]}]

Sintaxis extendida de Transact-SQL

DECLARE nombreCursor CURSOR[LOCAL | GLOBAL][FORWARD_ONLY | SCROLL][STATIC | KEYSET | DYNAMIC | FAST_FORWARD][READ_ONLY | SCROLL_LOCKS | OPTIMISTIC][TYPE_WARNING]FOR instrucciónSELECT[FOR UPDATE [OF nombreColumna [,...n]]]

Argumentos de SQL-92

nombreCursor : Se trata del nombre del cursor de servidor Transact-SQL que se va a definir. El argumento nombreCursor debe seguir las reglas de los identificadores.

INSENSITIVE :Define un cursor que hace una copia temporal de los datos que utiliza. Todas las peticiones al cursor se responden desde esta tabla temporal de tempdb; por tanto, las modificaciones realizadas en las tablas base no se reflejarán en los datos devueltos por las recuperaciones realizadas en el cursor y además el cursor no admite modificaciones. Cuando se utiliza la sintaxis de SQL-92, si se omite INSENSITIVE, las eliminaciones y actualizaciones confirmadas realizadas en las tablas subyacentes (por cualquier usuario) se reflejan en las siguientes recuperaciones.

SCROLL : Especifica que están disponibles todas las opciones de recuperación (FIRST, LAST, PRIOR, NEXT, RELATIVE, ABSOLUTE). Si no se especifica SCROLL en una instrucción DECLARE CURSOR de SQL-92, la única opción de recuperación que se admite es NEXT. No se puede especificar SCROLL si se especifica también FAST_FORWARD.

instrucciónSELECT : Es una instrucción SELECT estándar que define el conjunto de resultados del cursor. Las palabras clave COMPUTE, COMPUTE BY, FOR BROWSE e



INTO no están permitidas en el argumento instrucciónSELECT de una declaración de cursor.

Microsoft SQL Server convierte implícitamente el cursor a otro tipo si las cláusulas de instrucciónSELECT entran en conflicto con la funcionalidad del tipo de cursor solicitado.

READ ONLY : Impide que se realicen actualizaciones a través de este cursor. No es posible hacer referencia al cursor en una cláusula WHERE CURRENT OF de una instrucción UPDATE o DELETE. Esta opción anula la posibilidad predeterminada de actualizar el cursor.

UPDATE [OF nombreColumna [,...n]] :Define las columnas del cursor que se pueden actualizar. Si se especifica el argumento OF nombreColumna [,...n], sólo se podrán modificar las columnas incluidas en la lista. Si se especifica el argumento UPDATE sin una lista de columnas, se pueden actualizar todas las columnas.

Argumentos extendidos de Transact-SQL

nombreCursor :Se trata del nombre del cursor de servidor Transact-SQL que se va a definir. El argumento nombreCursor debe seguir las reglas de los identificadores.

LOCAL :Especifica que el alcance del cursor es local para el proceso por lotes, procedimiento almacenado o desencadenador en que se creó el cursor. El nombre del cursor sólo es válido dentro de este alcance. Es posible hacer referencia al cursor mediante variables de cursor locales del proceso por lotes, procedimiento almacenado, desencadenador o parámetro OUTPUT del procedimiento almacenado. El parámetro OUTPUT se utiliza para devolver el cursor local al proceso por lotes, procedimiento almacenado o desencadenador que realiza la llamada, el cual puede asignar el parámetro a una variable de cursor para hacer referencia al cursor después de finalizar el procedimiento almacenado. La asignación del cursor se cancela implícitamente cuando el proceso por lotes, procedimiento almacenado o desencadenador finalizan, a menos que el cursor se haya devuelto en un parámetro OUTPUT. En ese caso, se cancela la asignación del cursor cuando se cancela la asignación de la última variable que le hace referencia o ésta se sale del alcance.

GLOBAL : Especifica que el alcance del cursor es global para la conexión. Puede hacerse referencia al nombre del cursor en cualquier procedimiento almacenado o proceso por lotes que se ejecute durante la conexión. Sólo se cancela implícitamente la asignación del cursor cuando se realiza la desconexión.

Nota Si no se especifica GLOBAL o LOCAL, el valor predeterminado se controla mediante la configuración de la opción de base de datos cursor local como predeterminado. En SQL Server versión 7.0, el valor predeterminado de esta opción es FALSE (falso) para que coincida con las versiones anteriores de SQL Server, donde todos los cursores eran globales. El valor predeterminado de esta opción puede cambiar en futuras versiones de SQL Server..



FORWARD_ONLY :Especifica que el cursor sólo se puede desplazar desde la primera a la última fila. FETCH NEXT es la única opción de recuperación aceptada. Si se especifica FORWARD_ONLY sin las palabras clave STATIC, KEYSET o DYNAMIC, el cursor funciona como un cursor DYNAMIC. Cuando no se especifica FORWARD_ONLY ni SCROLL, FORWARD_ONLY es la opción predeterminada, salvo si se incluyen las palabras clave STATIC, KEYSET o DYNAMIC. De forma predeterminada, con STATIC, KEYSET y DYNAMIC los cursores son de tipo SCROLL. A diferencia de las API de bases de datos como ODBC y ADO, FORWARD_ONLY se puede utilizar con los cursores STATIC, KEYSET y DYNAMIC de Transact-SQL. FAST_FORWARD y FORWARD_ONLY se excluyen mutuamente; si se especifica uno de ellos, no se puede especificar el otro.

STATIC :Define un cursor que hace una copia temporal de los datos que utiliza. Todas las peticiones al cursor se responden desde esta tabla temporal de tempdb; por tanto, las modificaciones realizadas en las tablas base no se reflejarán en los datos devueltos por las recuperaciones realizadas en el cursor y además el cursor no admite modificaciones.

KEYSET : Especifica que la pertenencia y el orden de las filas del cursor se fijan al abrir éste. El conjunto de claves que identifica de forma única las filas está integrado en una tabla de tempdb conocida como keyset. Los cambios en valores que no sean claves de las tablas base, ya sean realizados por el propietario del cursor o confirmados por otros usuarios, son visibles cuando el propietario se desplaza por el cursor. Las inserciones realizadas por otros usuarios no son visibles (no es posible hacer inserciones a través de un cursor de servidor Transact-SQL). Si se elimina una fila, el intento de recuperarla obtendrá un valor de -2 en @@FETCH_STATUS. Las actualizaciones de los valores de claves desde fuera del cursor se asemejan a la eliminación de la fila antigua seguida de la inserción de la nueva. La fila con los nuevos valores no es visible y los intentos de recuperar la fila de los valores antiguos devuelven el valor -2 en @@FETCH_STATUS. Los nuevos valores son visibles si la actualización se realiza a través del cursor, al especificar la cláusula WHERE CURRENT OF.

DYNAMIC :Define un cursor que, al desplazarse por él, refleja en su conjunto de resultados todos los cambios realizados en los datos de las filas. Los valores de los datos, el orden y la pertenencia de las filas pueden cambiar en cada recuperación. La opción de recuperación ABSOLUTE no se puede utilizar en los cursores dinámicos.

FAST_FORWARD : Especifica un cursor FORWARD_ONLY, READ_ONLY con las optimizaciones de rendimiento habilitadas. No se puede especificar FAST_FORWARD si se especifica también SCROLL o FOR_UPDATE. FAST_FORWARD y FORWARD_ONLY se excluyen mutuamente; si se especifica uno de ellos, no se puede especificar el otro.

READ_ONLY :Impide que se realicen actualizaciones a través de este cursor. No es posible hacer referencia al cursor en una cláusula WHERE CURRENT OF de una instrucción UPDATE o DELETE. Esta opción anula la posibilidad predeterminada de actualizar el cursor.



SCROLL_LOCKS :Especifica que el éxito de las actualizaciones o eliminaciones con posición, realizadas a través del cursor, está garantizado. Microsoft SQL Server bloquea las filas al leerlas en el cursor, lo que asegura su disponibilidad para posteriores modificaciones. No se puede especificar SCROLL_LOCKS si se especifica FAST_FORWARD.

OPTIMISTIC :Especifica que las actualizaciones o eliminaciones con posición realizadas a través del cursor no tendrán éxito si la fila se ha actualizado después de leerla en el cursor. SQL Server no bloquea las filas al leerlas en el cursor. En su lugar, utiliza comparaciones de valores de columna timestamp o un valor de suma de comprobación si la tabla no tiene columnas timestamp, para determinar si la fila se ha modificado después de leerla en el cursor. Si la fila se ha modificado, la actualización o eliminación con posición fracasa. No se puede especificar OPTIMISTIC si se especifica FAST_FORWARD.

TYPE_WARNING :Especifica que se envía un mensaje de advertencia al cliente si el cursor se convierte implícitamente del tipo solicitado a otro.

instrucciónSELECT : Es una instrucción SELECT estándar que define el conjunto de resultados del cursor. Las palabras clave COMPUTE, COMPUTE BY, FOR BROWSE e INTO no están permitidas en el argumento instrucciónSELECT de una declaración de cursor.

SQL Server convierte implícitamente el cursor a otro tipo si las cláusulas de instrucciónSELECT entran en conflicto con la funcionalidad del tipo de cursor solicitado.

UPDATE [OF nombreColumna [,...n]] : Define las columnas del cursor que se pueden actualizar. Si se especifica el argumento OF nombreColumna [,...n], sólo se podrán modificar las columnas incluidas en la lista. Si se especifica el argumento UPDATE sin una lista de columnas, se pueden actualizar todas las columnas, a menos que se haya especificado la opción de simultaneidad READ_ONLY.

Observaciones

DECLARE CURSOR define los atributos de un cursor de servidor Transact-SQL, como su comportamiento de desplazamiento y la consulta utilizada para generar el conjunto de resultados en que opera el cursor. La instrucción OPEN llena el conjunto de resultados y la instrucción FETCH devuelve una fila del conjunto de resultados. La instrucción CLOSE libera el conjunto de resultados actual asociado con el cursor. La instrucción DEALLOCATE libera los recursos que utiliza el cursor.La primera forma de la instrucción DECLARE CURSOR utiliza la sintaxis de SQL-92 para declarar comportamientos de cursores. La segunda forma de DECLARE CURSOR utiliza extensiones de Transact-SQL que permiten definir cursores con los mismos tipos de cursor utilizados en las funciones de cursores de la API de bases de datos de ODBC, ADO y Bibliotecas de bases de datos.No puede combinar las dos formas. Si especifica las palabras clave SCROLL o INSENSITIVE antes de la palabra clave CURSOR, no puede utilizar ninguna palabra clave entre los argumentos CURSOR y FOR instrucciónSELECT. Si especifica palabras clave entre los argumentos CURSOR y FOR instrucciónSELECT, no puede especificar SCROLL o INSENSITIVE antes de la palabra clave CURSOR.



Si la instrucción DECLARE CURSOR con sintaxis de Transact-SQL no especifica READ_ONLY, OPTIMISTIC o SCROLL_LOCKS, el valor predeterminado es el siguiente:

• Si la instrucción SELECT no acepta actualizaciones (permisos insuficientes, acceso a tablas remotas que no aceptan actualizaciones, etc.), el cursor es de tipo READ_ONLY.

• El valor predeterminado de los cursores de tipo STATIC y FAST_FORWARD es READ_ONLY.

• El valor predeterminado de los cursores de tipo KEYSET y DYNAMIC es OPTIMISTIC. Sólo se puede hacer referencia a nombres de cursores mediante otras instrucciones Transact-SQL. No se puede hacer referencia a los nombres de cursores mediante funciones de la API de base de datos. Por ejemplo, después de declarar un cursor, no se puede hacer referencia al nombre del cursor desde funciones o métodos de OLE DB, ODBC, ADO o Bibliotecas de bases de datos. No se pueden recuperar las filas del cursor con las funciones o métodos de recuperación de las API; las filas sólo se pueden recuperar mediante instrucciones FETCH de Transact-SQL.Una vez que se ha declarado un cursor, se pueden utilizar estos procedimientos almacenados del sistema para determinar las características del cursor.

Procedimiento almacenado del sistema

Descripción

sp_cursor_listDevuelve la lista de cursores visibles actualmente en la conexión y sus atributos.

sp_describe_cursorDescribe los atributos de un cursor, por ejemplo si es de desplazamiento sólo hacia delante o de desplazamiento.

sp_describe_cursor_columnsDescribe los atributos de las columnas del conjunto de resultados del cursor.

sp_describe_cursor_tables Describe las tablas base a las que tiene acceso el cursor.

Permisos

Los permisos de DECLARE CURSOR son los predeterminados de cualquier usuario que tenga permisos de SELECT sobre las vistas, tablas y columnas utilizadas en el cursor.

Ejemplos

A. Utilizar cursores simples y su sintaxis

El conjunto de resultados generado al abrir este cursor contiene todas las filas y todas las columnas de la tabla authors de la base de datos pubs. Este cursor se puede actualizar, y todas las actualizaciones y eliminaciones se representan en las recuperaciones realizadas contra el cursor. FETCH NEXT es la única recuperación disponible debido a que no se ha especificado la opción SCROLL.DECLARE authors_cursor CURSORFOR SELECT * FROM authorsOPEN authors_cursorFETCH NEXT FROM authors_cursor

B. Utilizar cursores anidados para elaborar resultados de informes

Este ejemplo muestra cómo se pueden anidar los cursores para elaborar informes complejos. El cursor interno se declara para cada autor.SET NOCOUNT ONDECLARE @au_id varchar(11), @au_fname varchar(20), @au_lname varchar(40),@message varchar(80), @title varchar(80)PRINT "-------- Utah Authors report --------"DECLARE authors_cursor CURSOR FOR SELECT au_id, au_fname, au_lname FROM authors WHERE state = "UT" ORDER BY au_id



OPEN authors_cursorFETCH NEXT FROM authors_cursor INTO @au_id, @au_fname, @au_lnameWHILE @@FETCH_STATUS = 0BEGIN

PRINT " "SELECT @message = "----- Books by Author: " + @au_fname + " " + @au_lnamePRINT @message-- Declare an inner cursor based -- on au_id from the outer cursor.DECLARE titles_cursor CURSOR FOR SELECT t.title FROM titleauthor ta, titles t WHERE ta.title_id = t.title_id AND

ta.au_id = @au_id -- Variable value from the outer cursorOPEN titles_cursorFETCH NEXT FROM titles_cursor INTO @titleIF @@FETCH_STATUS <> 0 PRINT " <<No Books>>" WHILE @@FETCH_STATUS = 0BEGIN

SELECT @message = " " + @titlePRINT @messageFETCH NEXT FROM titles_cursor INTO @title

ENDCLOSE titles_cursorDEALLOCATE titles_cursor-- Get the next author.FETCH NEXT FROM authors_cursor INTO @au_id, @au_fname, @au_lname

ENDCLOSE authors_cursorDEALLOCATE authors_cursorGO-------- Utah Authors report ------------- Books by Author: Anne RingerThe Gourmet MicrowaveIs Anger the Enemy?----- Books by Author: Albert RingerIs Anger the Enemy?Life Without Fear

1.7.4 Bloqueo de cursores

En la versión 7.0 de Microsoft SQL Server, la instrucción SELECT de la definición de un cursor está sujeta a las mismas reglas de bloqueo de transacciones que se aplican a cualquier otra instrucción SELECT. Sin embargo, en los cursores se puede adquirir un conjunto adicional de bloqueos de desplazamiento en función del grado de simultaneidad de un cursor.Los bloqueos de transacciones que adquiere una instrucción SELECT, incluyendo la instrucción SELECT de la definición de un cursor, se controlan mediante:

• La configuración del nivel de aislamiento de transacciones de la conexión. • Las sugerencias de bloqueo especificadas en la cláusula FROM.

Estos bloqueos se mantienen hasta el final de la transacción actual para los cursores y las instrucciones SELECT independientes. Cuando SQL Server se ejecuta en modo de confirmación automática, cada instrucción de SQL individual es una transacción y los bloqueos se liberan



cuando termina la instrucción. Si SQL Server se ejecuta en el modo de transacciones explícitas o implícitas, se mantienen los bloqueos hasta que la transacción se confirma o deshace.Por ejemplo, el bloqueo realizado en estos dos ejemplos de Transact-SQL es esencialmente el mismo:/* Example 1 */SET TRANSACTION ISOLATION LEVEL REPEATABLE READGOBEGIN TRANSACTIONGOSELECT * FROM authorsGO/* Example 2 */SET TRANSACTION ISOLATION LEVEL REPEATABLE READGOBEGIN TRANSACTIONGODECLARE abc CURSOR STATIC FORSELECT * FROM authorsGOOPEN abcGOEstablecer el nivel de aislamiento de transacciones como lectura repetible significa que la instrucción SELECT independiente del ejemplo 1 y la instrucción SELECT que contiene DECLARE CURSOR en el ejemplo 2 generan bloqueos compartidos en cada fila que leen y que se mantienen los bloqueos compartidos hasta que la transacción se confirma o se deshace.

Adquirir bloqueos

Aunque los cursores obedecen las mismas reglas que las instrucciones SELECT independientes acerca del tipo de bloqueos de transacciones adquiridos, éstos se adquieren en momentos diferentes. Los bloqueos que genera una instrucción SELECT independiente o un cursor siempre se adquieren cuando se recupera una fila. Para una instrucción SELECT independiente, todas las filas se recuperan cuando se ejecuta la instrucción. Sin embargo, los cursores recuperan las filas en momentos diferentes según el tipo de cursor:

• Los cursores estáticos recuperan el conjunto de resultados completo en el momento en que se abre el cursor. Así se bloquea cada fila del conjunto de resultados en el momento de la apertura.

• Los cursores controlados por conjunto de claves recuperan las claves de cada fila del conjunto de resultados en el momento en que se abre el cursor. Así se bloquea cada fila del conjunto de resultados en el momento de la apertura.

• Los cursores dinámicos, incluidos los cursores normales de desplazamiento sólo hacia adelante, no recuperan las filas hasta que se recopilan. Los bloqueos no se adquieren en estas filas hasta que se han recopilado.

• Los cursores de desplazamiento rápido sólo adelante se diferencian en que adquieren sus bloqueos dependiendo del plan de ejecución seleccionado por el optimizador de consultas. Si se selecciona un plan dinámico, no se adquieren bloqueos hasta que se recopilan las filas. Si se generan tablas de trabajo, las filas se leen en la tabla de trabajo y se bloquean en el momento de la apertura.

Los cursores también admiten sus propias especificaciones de simultaneidad, algunas de las cuales generan bloqueos adicionales en las filas en cada recopilación. Estos bloqueos de desplazamiento se mantienen hasta la siguiente operación de recopilación o hasta que el cursor está cerrado, lo que se produzca primero. Si la opción de conexión para mantener cursores abiertos en una confirmación está activada, estos bloqueos se mantienen en las operaciones de confirmar o de deshacer.



1.7.5 Obtener metadatos de cursores de servidor

Hay dos formas de obtener metadatos que describen un cursor de servidor: • Las aplicaciones que utilizan cursores de servidor de la API con una API de bases de

datos como ADO, OLE DB, ODBC o bibliotecas de bases de datos, normalmente utilizan la funcionalidad de cursores de la API para obtener información acerca del estado del cursor.

• Las secuencias de comandos, procedimientos almacenados y desencadenadores de Transact-SQL pueden utilizar las funciones de Transact-SQL y procedimientos almacenados del sistema explicados en este tema para obtener información acerca de un cursor de Transact-SQL.

Hay varias funciones del sistema que informan del estado de un cursor de servidor o de un cursor de servidor asignado a una variable de tipo cursor:

• CURSOR_STATUS Indica si un cursor está abierto o cerrado, o si una variable de tipo cursor está asociada actualmente a un cursor.

• @@FETCH_STATUS Indica el éxito o el error de la última operación de recopilación realizada en la conexión.

• @@CURSOR_ROWS Devuelve el número de filas llenadas en el último cursor abierto en la conexión.

Hay varios procedimientos almacenados del sistema que informan de las características de un cursor de servidor o de un cursor de servidor asignado a una variable de tipo cursor:

• sp_describe_cursor Devuelve un cursor que describe los atributos de un cursor como su alcance, nombre, tipo, estado y número de filas.

• sp_describe_cursor_columns Devuelve un cursor que describe los atributos de cada columna del cursor, como el nombre de la columna, posición, tamaño y tipo de datos.

• sp_describe_cursor_tables Devuelve un cursor que describe las tablas base a las que hace referencia el cursor.

• sp_cursor_list Devuelve un cursor que enumera todos los cursores actualmente visibles de la conexión. El formato del cursor que devuelve sp_cursor_list es el mismo que el del cursor de sp_describe_cursor.

Estos procedimientos almacenados del sistema devuelven sus conjuntos de resultados como variables de cursores de salida. Las API de bases de datos no admiten variables de tipo cursor, por lo que no se puede llamar a estos procedimientos desde aplicaciones, solamente desde secuencias de comandos, procedimientos almacenados y lotes de Transact-SQL. Las aplicaciones deben utilizar la funcionalidad de cursor de las API de bases de datos para obtener los metadatos de los cursores de servidor de la API.Se debe tratar cuidadosamente la información de estado que devuelven estas funciones y procedimientos almacenados, especialmente @@FETCH_STATUS. La información que devuelve @@FETCH_STATUS cambia cada vez que se emite una instrucción FETCH contra cualquier cursor abierto en la conexión. Un procedimiento almacenado o desencadenador que pueda necesitar hacer referencia a la información de estado tras ejecutar varias instrucciones adicionales debe guardar @@FETCH_STATUS en una variable de tipo integer inmediatamente después de la instrucción FETCH. Se puede restablecer @@FETCH_STATUS aunque no haya instrucciones FETCH en el lote entre la instrucción FETCH y la instrucción que prueba el estado. Si una instrucción INSERT, UPDATE o DELETE activa un desencadenador, éste puede abrir y recopilar desde un cursor. @@FETCH_STATUS contendría entonces el estado de la última instrucción FETCH del desencadenador.Los procedimientos almacenados informan de su propio estado para un cursor específico, por lo que su información de estado no se ve afectada por las operaciones de otros cursores. Esta información sigue afectada por las operaciones realizadas en el mismo cursor, por lo que se debe



tener cuidado todavía al utilizar la información de estado que devuelven los procedimientos almacenados.

1.8 Procedimientos almacenados Un procedimiento almacenado es un grupo de instrucciones Transact-SQL compiladas en un único plan de ejecución.Los procedimientos almacenados de Microsoft SQL Server tienen cuatro maneras de devolver datos:

• Parámetros de salida, que pueden devolver datos (como valor entero o carácter) o una variable de cursor (los cursores son conjuntos de resultados que pueden devolver filas de una en una).

• Códigos de retorno, que siempre son un valor entero. • Un conjunto de resultados por cada instrucción SELECT contenida en el procedimiento

almacenado o en cualquier otro procedimiento almacenado invocado por el procedimiento almacenado original.

• Un cursor global al que se puede hacer referencia desde fuera del procedimiento almacenado.

Los procedimientos almacenados contribuyen a conseguir una implementación coherente de una lógica entre las aplicaciones. Las instrucciones SQL y la lógica necesarias para ejecutar una tarea de ejecución frecuente se pueden diseñar, escribir y probar de una sola vez en un procedimiento almacenado. Así, las aplicaciones que necesiten ejecutar dicha tarea sólo tienen que ejecutar el procedimiento almacenado. La escritura de la lógica de una función en un solo procedimiento almacenado también ofrece un único punto de control para asegurar la correcta ejecución de dicha función.Los procedimientos almacenados también pueden aumentar el rendimiento. Muchas tareas están implementadas como series de instrucciones SQL. La lógica condicional aplicada a los resultados de la primeras instrucciones SQL determina las instrucciones SQL que se ejecutan seguidamente. Si dichas instrucciones SQL y la lógica condicional se escriben en un procedimiento almacenado, forman parte de una única unidad de ejecución en el servidor. No es necesario devolver los resultados al cliente para aplicar la lógica condicional; todo el trabajo se realiza en el servidor. La instrucción IF de este ejemplo muestra la inclusión de lógica condicional en un procedimiento para impedir el envío de un conjunto de resultados a la aplicación:

IF (@QuantityOrdered < (SELECT QuantityOnHandFROM InventoryWHERE PartID = @PartOrdered) )BEGIN-- SQL statements to update tables and process order.ENDELSEBEGIN-- SELECT statement to retrieve the IDs of alternate items-- to suggest as replacements to the customer.ENDLas aplicaciones no tienen que transmitir todas las instrucciones SQL del procedimiento: sólo tienen que transmitir una instrucción EXECUTE o CALL que contenga el nombre del procedimiento y los valores de los parámetros.Los procedimientos almacenados también aíslan a los usuarios de los detalles de las tablas de la base de datos. Si un conjunto de procedimientos almacenados implementa todas las funciones que los usuarios necesitan, los usuarios nunca tienen que tener acceso a las tablas de forma directa; sólo tienen que ejecutar los procedimientos almacenados que implementan las funciones diarias de su trabajo.



Una ilustración de este uso de los procedimientos almacenados es el sistema de procedimientos almacenados que SQL Server utiliza para aislar a los usuarios de las tablas del sistema. SQL Server incluye un conjunto de procedimientos almacenados del sistema cuyos nombres suelen empezar por sp_. Dichos procedimientos almacenados del sistema aceptan todas las tareas administrativas requeridas para ejecutar un sistema SQL Server. Los sistemas SQL Server se pueden administrar mediante las instrucciones Transact-SQL destinadas a la administración (como CREATE TABLE) o los procedimientos almacenados del sistema, y nunca se tienen que actualizar directamente las tablas del sistema.En versiones anteriores de SQL Server, los procedimientos almacenados eran una forma de precompilar parcialmente un plan de ejecución. En el momento de la creación del procedimiento almacenado, se almacenaba un plan de ejecución parcialmente compilado en una tabla del sistema. La ejecución de un procedimiento almacenado era más eficiente que la ejecución de una instrucción SQL, ya que SQL Server no tenía que compilar el plan de ejecución; sólo tenía que completar la optimización del plan de ejecución del procedimiento. Además, el plan de ejecución totalmente compilado del procedimiento almacenado se conservaba en la caché de procedimientos de SQL Server, lo que significa que las siguientes ejecuciones del mismo procedimiento almacenado podían utilizar el plan de ejecución precompilado.SQL Server versión 7.0 introduce varios cambios al proceso de instrucciones que amplían muchas de las ventajas de rendimiento de los procedimientos almacenados a todas las instrucciones SQL. SQL Server 7.0 no guarda un plan parcialmente compilado para los procedimientos almacenados cuando éstos se crean. El procedimiento almacenado se compila en tiempo de ejecución como cualquier otra instrucción Transact-SQL. SQL Server 7.0 mantiene los planes de ejecución de todas las instrucciones SQL en la caché de procedimientos, no sólo los planes de ejecución de los procedimientos almacenados. Utiliza un algoritmo muy eficiente para comparar nuevas instrucciones Transact-SQL con las instrucciones Transact-SQL de los planes de ejecución existentes. Si SQL Server 7.0 determina que una nueva instrucción Transact-SQL coincide con una instrucción Transact-SQL de un plan de ejecución existente, utiliza dicho plan. Esto reduce la ventaja de rendimiento relativa de la precompilación de los procedimientos almacenados al ampliar la posibilidad de volver a utilizar los planes de ejecución a todas las instrucciones SQL.SQL Server 7.0 ofrece nuevas alternativas para procesar instrucciones SQL. SQL Server también acepta procedimientos almacenados temporales que, al igual que las tablas temporales, se eliminan automáticamente al desconectar. Los procedimientos almacenados temporales se almacenan en tempdb y son útiles en las conexiones con versiones anteriores de SQL Server. Los procedimientos almacenados temporales se pueden utilizar en el caso en el que una aplicación genere instrucciones Transact-SQL dinámicas que se ejecuten varias veces. En lugar de tener que volver a compilar las instrucciones Transact-SQL todas las veces, puede crear un procedimiento almacenado temporal, que se compila en su primera ejecución, y el resto de las veces ejecuta el plan precompilado. Sin embargo, el uso intensivo de procedimientos almacenados temporales puede producir conflictos en las tablas del sistema de tempdb.Sin embargo, dos características de SQL Server 7.0 eliminan la necesidad de utilizar procedimientos almacenados temporales:

• SQL Server 7.0 puede utilizar planes de ejecución de instrucciones SQL anteriores. Esto es especialmente eficaz cuando se utiliza junto con el nuevo procedimiento almacenado del sistema sp_executesql.

• SQL Server 7.0 acepta de forma nativa el modelo de preparación y ejecución de OLE DB y ODBC sin el uso de procedimientos almacenados.

Este sencillo procedimiento almacenado de ejemplo ilustra tres formas en que los procedimientos almacenados pueden devolver datos:

1. Primero emite una instrucción SELECT que devuelve un conjunto de resultados que resume el orden de actividad de los almacenes de la tabla sales.

2. Después emite una instrucción SELECT que asigna un parámetro de salida. 3. Por último, tiene una instrucción RETURN con una instrucción SELECT que devuelve un

valor entero. Los códigos de retorno se utilizan generalmente para devolver información



para la comprobación de errores. Este procedimiento se ejecuta sin errores, de modo que devuelve otro valor para ilustrar cómo se asignan los códigos de retorno.

USE NorthwindGODROP PROCEDURE OrderSummaryGOCREATE PROCEDURE OrderSummary @MaxQuantity INT OUTPUT AS-- SELECT to return a result set summarizing-- employee sales.SELECT Ord.EmployeeID, SummSales = SUM(OrDet.UnitPrice * OrDet.Quantity)FROM Orders AS OrdJOIN [Order Details] AS OrDet ON (Ord.OrderID = OrDet.OrderID)GROUP BY Ord.EmployeeIDORDER BY Ord.EmployeeID-- SELECT to fill the output parameter with the-- maximum quantity from Order Details.SELECT @MaxQuantity = MAX(Quantity) FROM [Order Details]-- Return the number of all items ordered.RETURN (SELECT SUM(Quantity) FROM [Order Details])GO-- Test the stored procedure.-- DECLARE variables to hold the return code-- and output parameter.DECLARE @OrderSum INTDECLARE @LargestOrder INT-- Execute the procedure, which returns-- the result set from the first SELECT.EXEC @OrderSum = OrderSummary @MaxQuantity = @LargestOrder OUTPUT-- Use the return code and output parameter.PRINT 'The size of the largest single order was: ' +CONVERT(CHAR(6), @LargestOrder)PRINT 'The sum of the quantities ordered was: ' +CONVERT(CHAR(6), @OrderSum)GOEl resultado de la ejecución de este ejemplo es:EmployeeID SummSales ----------- -------------------------- 1 202,143.71 2 177,749.26 3 213,051.30 4 250,187.45 5 75,567.75 6 78,198.10 7 141,295.99 8 133,301.03 9 82,964.00 The size of the largest single order was: 130 The sum of the quantities ordered was: 51317

1.8.1 Programar procedimientos almacenadosCasi cualquier código Transact-SQL que pueda escribirse como un lote puede utilizarse para crear un procedimiento almacenado.



Reglas de procedimientos almacenados

Entre las reglas para la programación de procedimientos almacenados, cabe citar las siguientes: • La propia definición CREATE PROCEDURE puede incluir cualquier número y tipo de

instrucciones SQL, excepto las siguientes instrucciones CREATE, que no pueden ser utilizadas nunca dentro de un procedimiento almacenado: CREATE DEFAULT CREATE TRIGGERCREATE PROCEDURE CREATE VIEWCREATE RULE

• Se puede crear otros objetos de base de datos dentro de un procedimiento almacenado. Puede hacer referencia a un objeto creado en el mismo procedimiento almacenado, siempre que se cree antes de que se haga referencia al objeto.

• Puede hacer referencia a tablas temporales dentro de un procedimiento almacenado. • Si crea una tabla temporal privada dentro de un procedimiento almacenado, la tabla

temporal existirá únicamente para los fines del procedimiento; desaparecerá cuando éste finalice.

• Si ejecuta un procedimiento almacenado que llama a otro procedimiento almacenado, el procedimiento al que se llama puede tener acceso a todos los objetos creados por el primer procedimiento, incluidas las tablas temporales.

• Si se ejecuta un procedimiento almacenado remoto que realiza cambios en un servidor Microsoft® SQL Server™ remoto, los cambios no se podrán deshacer. Los procedimientos almacenados remotos no intervienen en las transacciones.

• El número máximo de parámetros en un procedimiento almacenado es de 1.024. • El número máximo de variables locales en un procedimiento almacenado está limitado

únicamente por la memoria disponible. • En función de la memoria disponible, el tamaño máximo de un procedimiento almacenado

es de 128 MB.

Calificar nombres dentro de procedimientos almacenados

Dentro de un procedimiento almacenado, los nombres de los objetos utilizados en instrucciones (por ejemplo, SELECT o INSERT) que no sean calificados por el usuario se califican de forma predeterminada con el nombre del propietario del procedimiento almacenado. Si un usuario que crea un procedimiento almacenado no califica el nombre de las tablas a las que se hace referencia en las instrucciones SELECT, INSERT, UPDATE o DELETE dentro del procedimiento almacenado, de forma predeterminada, el acceso a esas tablas a través del procedimiento almacenado se restringe al creador del procedimiento.Los nombres de objetos utilizados con las instrucciones ALTER TABLE, CREATE TABLE, DROP TABLE, TRUNCATE TABLE, CREATE INDEX, DROP INDEX, UPDATE STATISTICS y DBCC deben ser calificados con el nombre del propietario del objeto, si otros usuarios van a utilizar el procedimiento almacenado. Por ejemplo, Marisa, propietaria de la tabla marisatab, debe calificar el nombre de su tabla cuando se utiliza con una de estas instrucciones, si desea que otros usuarios puedan ejecutar el procedimiento almacenado en el que se utiliza la tabla.Esta regla es necesaria porque los nombres de los objetos se resuelven cuando se ejecuta el procedimiento almacenado. Si marisatab no está calificada y Juan intenta ejecutar el procedimiento, SQL Server buscará una tabla denominada marisatab que pertenezca a Juan.

Cifrar definiciones de procedimientos

Si está creando un procedimiento almacenado y desea asegurarse de que la definición del procedimiento no pueda ser vista por otros usuarios, puede utilizar la cláusula WITH ENCRYPTION. La definición del procedimiento se almacenará en un formato ilegible.Después de cifrarla, la definición del procedimiento almacenado no puede ser descifrada ni vista por nadie, ni siquiera por el propietario del procedimiento ni por el administrador del sistema.

Instrucción SET

Cuando se conecta una aplicación ODBC a SQL Server, el servidor configura automáticamente estas opciones para la sesión:



• SET QUOTED_IDENTIFIER ON • SET TEXTSIZE 2147483647 • SET ANSI_DEFAULTS ON • SET CURSOR_CLOSE_ON_COMMIT OFF • SET IMPLICIT_TRANSACTIONS OFF

Esta configuración aumenta la portabilidad de las aplicaciones ODBC. Dado que las aplicaciones basadas en bibliotecas de bases de datos no suelen configurar estas opciones, se debe probar los procedimientos almacenados mediante la activación y desactivación de las opciones SET citadas anteriormente. De ese modo se garantiza que los procedimientos almacenados funcionen correctamente, independientemente de las opciones que haya configurado una conexión determinada cuando invoca al procedimiento. Un procedimiento almacenado que necesite una configuración determinada para una de estas opciones deberá emitir una instrucción SET al principio del procedimiento almacenado. Esta instrucción SET tendrá efecto únicamente durante la ejecución del procedimiento almacenado; cuando finalice el procedimiento, se restaurará la configuración original.

Ejemplos

A. Crear un procedimiento almacenado que utilice parámetros

En este ejemplo se muestra cómo crear un procedimiento almacenado de gran utilidad para la base de datos pubs. A partir del nombre y primer apellido de un autor, el procedimiento muestra el título y el editor de cada uno de los libros del autor:CREATE PROC au_info @lastname varchar(40), @firstname varchar(20) AS SELECT au_lname, au_fname, title, pub_nameFROM authors INNER JOIN titleauthor ON authors.au_id = titleauthor.au_idJOIN titles ON titleauthor.title_id = titles.title_idJOIN publishers ON titles.pub_id = publishers.pub_idWHERE au_fname = @firstnameAND au_lname = @lastnameGOSe obtiene un mensaje que indica que el comando no devolvió ningún dato ni ninguna fila, lo que significa que se ha creado el procedimiento almacenado. Ahora, ejecute au_info:EXECUTE au_info Ringer, AnneGOÉste es el conjunto de resultados:au_lname au_fname title pub_name--------- --------- --------------------- ----------------Ringer Anne The Gourmet Microwave Binnet & HardleyRinger Anne Is Anger the Enemy? New Moon Books(2 row(s) affected)

B. Crear un procedimiento almacenado que utilice valores predeterminados para los parámetros

El procedimiento almacenado pub_info2 muestra los nombres de todos los autores que han escrito algún libro publicado por el editor que se especifica como parámetro. Si no se facilita ningún nombre de editor, el procedimiento almacenado muestra los autores cuyos libros han sido publicados por Algodata Infosystems.CREATE PROC pub_info2 @pubname varchar(40) = 'Algodata Infosystems'AS SELECT au_lname, au_fname, pub_nameFROM authors a INNER JOIN titleauthor ta ON a.au_id = ta.au_idJOIN titles t ON ta.title_id = t.title_idJOIN publishers p ON t.pub_id = p.pub_idWHERE @pubname = p.pub_nameEjecute pub_info2 sin especificar ningún parámetro:



EXECUTE pub_info2GOÉste es el conjunto de resultados:au_lname au_fname pub_name---------------- ---------------- --------------------Green Marjorie Algodata InfosystemsBennet Abraham Algodata InfosystemsO'Leary Michael Algodata InfosystemsMacFeather Stearns Algodata InfosystemsStraight Dean Algodata InfosystemsCarson Cheryl Algodata InfosystemsDull Ann Algodata InfosystemsHunter Sheryl Algodata InfosystemsLocksley Charlene Algodata Infosystems(9 row(s) affected)

C. Ejecutar un procedimiento almacenado que suplante al valor predeterminado para el parámetro con un valor explícito

En el procedimiento almacenado showind2, se asignan los títulos como valores predeterminados para el parámetro @table:CREATE PROC showind2 @table varchar(30) = 'titles'AS SELECT TABLE_NAME = sysobjects.name,INDEX_NAME = sysindexes.name, INDEX_ID = indidFROM sysindexes INNER JOIN sysobjects ON sysobjects.id = sysindexes.idWHERE sysobjects.name = @tableLos títulos de las columnas (por ejemplo, TABLE_NAME) facilitan la lectura de los resultados. Esto es lo que muestra el procedimiento almacenado para la tabla authors:EXECUTE showind2 authorsGOTABLE_NAME INDEX_NAME INDEX_ID---------- ---------- ----------authors UPKCL_auidind 1authors aunmind 2(2 row(s) affected)Si el usuario no especifica ningún valor, SQL Server utiliza la tabla predeterminada, titles:EXECUTE showind2GOÉste es el conjunto de resultados:TABLE_NAME INDEX_NAME INDEX_ID---------- ---------- ----------titles UPKCL_titleidind 1titles titleind 2(2 row(s) affected)

D. Crear un procedimiento almacenado que utilice un valor predeterminado NULL para los parámetros

El valor predeterminado para los parámetros puede ser NULL. En ese caso, si el usuario no especifica ningún parámetro, SQL Server ejecutará el procedimiento almacenado de acuerdo con el resto de sus instrucciones. No se muestra ningún mensaje de error.La definición del procedimiento también puede especificar que se realice alguna otra acción si el usuario no proporciona ningún parámetro. Por ejemplo:CREATE PROC showind3 @table varchar(30) = NULLAS IF @table IS NULLPRINT 'Give a table name'



ELSESELECT TABLE_NAME = sysobjects.name,INDEX_NAME = sysindexes.name, INDEX_ID = indidFROM sysindexes INNER JOIN sysobjectsON sysobjects.id = sysindexes.idWHERE sysobjects.name = @table

E. Crear un procedimiento almacenado que utilice un valor predeterminado para un parámetro que incluya caracteres comodín

El valor predeterminado puede incluir caracteres comodín (%, _, [] y [^]), si el procedimiento almacenado utiliza el parámetro con la palabra clave LIKE. Por ejemplo, es posible modificar showind para que se muestre información acerca de las tablas del sistema, si el usuario no especifica ningún parámetro:CREATE PROC showind4 @table varchar(30) = 'sys%'AS SELECT TABLE_NAME = sysobjects.name,INDEX_NAME = sysindexes.name, INDEX_ID = indidFROM sysindexes INNER JOIN sysobjectsON sysobjects.id = sysindexes.idWHERE sysobjects.name LIKE @tableLa siguiente variación del procedimiento almacenado au_info utiliza caracteres comodín como valores predeterminados para ambos parámetros:CREATE PROC au_info2 @lastname varchar(30) = 'D%',@firstname varchar(18) = '%'AS SELECT au_lname, au_fname, title, pub_nameFROM authors INNER JOIN titleauthor ON authors.au_id = titleauthor.au_idJOIN titles ON titleauthor.title_id = titles.title_idJOIN publishers ON titles.pub_id = publishers.pub_idWHERE au_fname LIKE @firstnameAND au_lname LIKE @lastnameSi se ejecuta au_info2 sin parámetros, se muestran todos los autores cuyo apellido empiece por la letra D:EXECUTE au_info2GOÉste es el conjunto de resultados:au_lname au_fname title pub_name-------- -------- --------------------- -------------------Dull Ann Secrets of Silicon Val Algodata Infosystemsdel Castillo Innes Silicon Val Gastrono Binnet & HardleyDeFrance Michel The Gourmet Microwave Binnet & Hardley(3 row(s) affected)En este ejemplo se omite el segundo parámetro cuando se han definido valores predeterminados para dos parámetros, así que puede buscar los libros y los editores para todos los autores cuyo apellido sea Ringer:EXECUTE au_info2 RingerGOau_lname au_fname title pub_name--------- --------- ---------------------- ----------------Ringer Anne The Gourmet Microwave Binnet & HardleyRinger Anne Is Anger the Enemy? New Moon BooksRinger Albert Is Anger the Enemy? New Moon BooksRinger Albert Life Without Fear New Moon Books(4 row(s) affected)



1.8.1.1 Devolver datos de un procedimiento almacenado

Los procedimientos almacenados de Microsoft® SQL Server™ pueden devolver los datos de cuatro formas distintas:

• Parámetros de salida, que pueden devolver datos (como valor entero o carácter) o una variable de cursor (los cursores son conjuntos de resultados que pueden devolver filas de una en una).

• Códigos de retorno, que siempre son un valor entero. • Un conjunto de resultados por cada instrucción SELECT contenida en el procedimiento

almacenado o en cualquier otro procedimiento almacenado invocado por el procedimiento almacenado original.

• Un cursor global al que se puede hacer referencia desde fuera del procedimiento almacenado.

1.8.1.2 Devolver datos mediante parámetros OUTPUT

Si especifica la palabra clave OUTPUT para un parámetro de la definición del procedimiento, éste podrá devolver el valor actual del parámetro al programa que lo llama cuando el procedimiento termine. Para guardar el valor del parámetro en una variable que pueda utilizarse en el programa que realiza la llamada, el programa debe utilizar la palabra clave OUTPUT cuando ejecute el procedimiento almacenado.

Ejemplos

En el ejemplo siguiente se muestra un procedimiento almacenado con un parámetro de entrada y otro de salida. El primer parámetro del procedimiento almacenado, @title, recibirá el valor de entrada especificado por el programa que realiza la llamada, mientras que el segundo parámetro, @ytd_sales, se utilizará para devolver el valor al programa que realiza la llamada. La instrucción SELECT utiliza el parámetro @title para obtener el valor ytd_sales correcto y asigna ese valor al parámetro de salida @ytd_sales.CREATE PROCEDURE get_sales_for_title@title varchar(80), -- This is the input parameter.@ytd_sales int OUTPUT -- This is the output parameter.AS -- Get the sales for the specified title and -- assign it to the output parameter.SELECT @ytd_sales = ytd_salesFROM titlesWHERE title = @titleRETURNGO El programa siguiente ejecuta el procedimiento almacenado con un valor para el parámetro de entrada y guarda el valor de salida del procedimiento en la variable local @ytd_sales_for_title del programa que efectúa la llamada. -- Declare the variable to receive the output value of the procedure.DECLARE @ytd_sales_for_title int-- Execute the procedure with a title_id value-- and save the output value in a variable.EXECUTE get_sales_for_title"Sushi, Anyone?", @ytd_sales = @ytd_sales_for_title OUTPUT -- Display the value returned by the procedure.PRINT 'Sales for "Sushi, Anyone?": ' + convert(varchar(6),@ytd_sales_for_title)GOSales for "Sushi, Anyone?": 4095



También es posible especificar los valores de entrada para los parámetros OUTPUT cuando se ejecuta el procedimiento almacenado. Esto permite al procedimiento recibir un valor del programa que realiza la llamada, cambiarlo o realizar operaciones con el valor, y devolver el nuevo valor al programa que realiza la llamada. En el ejemplo anterior, es posible asignar un valor a la variable @ytd_sales_for_title antes de ejecutar el procedimiento. La variable @ytd_sales contiene el valor del parámetro en el cuerpo del procedimiento almacenado, y el valor de la variable @ytd_sales se devuelve al programa que realiza la llamada cuando el procedimiento termina. A esto se le suele denominar “capacidad de paso por referencia”.Si especifica OUTPUT para un parámetro cuando ejecuta un procedimiento almacenado y el parámetro no se define mediante OUTPUT en el procedimiento almacenado, se produce un mensaje de error. Puede ejecutar un procedimiento con parámetros OUTPUT y no especificar OUTPUT cuando se ejecute el procedimiento. No se devuelve ningún error, pero no podrá utilizar el valor de salida en el programa que realiza la llamada.

1.8.2.2 Devolver datos mediante un código de retorno

Un procedimiento almacenado puede devolver un valor entero, denominado código de retorno, para indicar el estado de ejecución de un procedimiento. Se especifica el código de retorno para un procedimiento mediante la instrucción RETURN. Al igual que con los parámetros OUTPUT, debe guardar el código de retorno en una variable cuando se ejecute el procedimiento almacenado para utilizar su valor en el programa que realiza la llamada. Por ejemplo, la variable de asignación @result del tipo de datos int se utiliza para almacenar el código de retorno del procedimiento almacenado my_proc:DECLARE @result intEXECUTE @result = my_procLos códigos de retorno suelen utilizarse en los bloques de control de flujo dentro de los procedimientos almacenados con el fin de establecer el valor del código de retorno para cada situación de error posible. Puede utilizar la función @@ERROR después de una instrucción de Transact-SQL para detectar si se ha producido un error durante la ejecución de una instrucción.

Ejemplos

A. Devolver otro código de retorno en función del tipo de error

En el ejemplo siguiente se muestra el procedimiento get_sales_for_title con un tratamiento especial que establece valores de código de retorno especiales para distintos errores. En la tabla se muestra el valor entero asignado por el procedimiento almacenado a cada error posible.Valor Significado0 Ejecución correcta.1 No se ha especificado el valor del parámetro necesario.2 Valor no válido para el parámetro.3 Error al obtener el valor de ventas.4 Valor de ventas NULL para el título.CREATE PROCEDURE get_sales_for_title-- This is the input parameter, with a default.@title varchar(80) = NULL, -- This is the output parameter.@ytd_sales int OUTPUT AS -- Validate the @title parameter.IF @title IS NULLBEGINPRINT "ERROR: You must specify a title value."RETURN(1)END



ELSEBEGIN-- Make sure the title is valid.IF (SELECT COUNT(*) FROM titlesWHERE title = @title) = 0RETURN(2)END-- Get the sales for the specified title and -- assign it to the output parameter.SELECT @ytd_sales = ytd_salesFROM titlesWHERE title = @title-- Check for SQL Server errors.IF @@ERROR <> 0 BEGINRETURN(3)ENDELSEBEGIN-- Check to see if the ytd_sales value is NULL.IF @ytd_sales IS NULLRETURN(4) ELSE-- SUCCESS!!RETURN(0)ENDGOSi se utilizan de este modo los códigos de retorno, los programas que realicen llamadas podrán detectar y tratar los errores que se produzcan cuando se ejecute el procedimiento.

B. Tratar los distintos códigos de error devueltos por un procedimiento almacenado

En este ejemplo se crea un programa que trata los códigos de retorno devueltos por el procedimiento get_sales_for_title.-- Declare the variables to receive the output value and return code -- of the procedure.DECLARE @ytd_sales_for_title int, @ret_code INT-- Execute the procedure with a title_id value-- and save the output value and return code in variables.EXECUTE @ret_code = get_sales_for_title"Sushi, Anyone?",@ytd_sales = @ytd_sales_for_title OUTPUT -- Check the return codes.IF @ret_code = 0BEGINPRINT "Procedure executed successfully"-- Display the value returned by the procedure.PRINT 'Sales for "Sushi, Anyone?": ' + CONVERT(varchar(6),@ytd_sales_for_title)ENDELSE IF @ret_code = 1PRINT "ERROR: No title_id was specified."ELSE IF @ret_code = 2 PRINT "ERROR: An invalid title_id was specified."ELSE IF @ret_code = 3PRINT "ERROR: An error occurred getting the ytd_sales."GO



1.8.2.3 Ejecutar un procedimiento almacenado

Cuando necesite ejecutar un procedimiento almacenado, utilice la instrucción EXECUTE de Transact-SQL. Puede ejecutar un procedimiento almacenado sin necesidad de utilizar la palabra clave EXECUTE, si el procedimiento almacenado es la primera instrucción del lote.Es posible suministrar los valores de los parámetros si se escribe un procedimiento almacenado que los acepte.

Nota Si especifica los parámetros con el formato @parámetro = valor, puede proporcionarlos en cualquier orden. También puede omitir los parámetros para los que se hayan especificado valores predeterminados. Si sólo especifica un parámetro con el formato @parámetro = valor, deberá proporcionar todos los parámetros siguientes del mismo modo. Si no especifica los parámetros con el formato @parámetro = valor, deberá especificarlos en el orden seguido en la instrucción CREATE PROCEDURE.Cuando ejecute un procedimiento almacenado, el servidor rechazará todos los parámetros que no se incluyeran en la lista de parámetros durante la creación del procedimiento. No se aceptará ningún parámetro pasado por referencia (el nombre del parámetro se pasa explícitamente) si el nombre del parámetro no coincide.Aunque puede omitir los parámetros para los que se hayan especificado valores predeterminados, sólo puede truncar la lista de parámetros. Por ejemplo, si en un procedimiento almacenado hay cinco parámetros, puede omitir el cuarto y el quinto, pero no puede omitir el cuarto e incluir el quinto si no suministra los parámetros con el formato @parámetro = valor.

El valor predeterminado de un parámetro, si se ha definido para el parámetro en el procedimiento almacenado, se utiliza cuando:

• No se especifica ningún valor para el parámetro en el momento de ejecutar el procedimiento almacenado.

• Se especifica la palabra clave DEFAULT como valor para el parámetro. Para ejecutar un procedimiento almacenado que está agrupado con otros procedimientos del mismo nombre, especifique el número de identificación del procedimiento almacenado dentro del grupo. Por ejemplo, para ejecutar el segundo procedimiento almacenado del grupo my_proc, ejecute:EXECUTE my_proc;2



1.9 Trigger (Desencadenadores)El objeto Trigger expone los atributos de un solo desencadenador de Microsoft® SQL Server™.

Observaciones

SQL Server admite el uso de desencadenadores como una clase de procedimiento almacenado. Los desencadenadores se ejecutan cuando se intenta una modificación de datos especificada, como un intento de eliminar una fila, en la tabla en que se ha definido el desencadenador. Con el objeto Trigger, puede:

• Crear un desencadenador SQL Server en una tabla SQL Server existente. • Quitar un desencadenador SQL Server existente de una tabla SQL Server. • Generar una secuencia de comandos Transact-SQL que se pueda utilizar con otras

herramientas para volver a crear un desencadenador SQL Server existente. • Cambiar el propietario de un desencadenador SQL Server existente.

La propiedad Name de un objeto Trigger es una cadena de caracteres. El valor de la propiedad identifica un desencadenador SQL Server por el nombre y debe cumplir las reglas de denominación de desencadenadores. La propiedad Name es necesaria al crear un desencadenador SQL Server.

Para crear un desencadenador en una tabla SQL Server existente 1. Cree un objeto Trigger. 2. Establezca la propiedad Name. 3. Establezca la propiedad Text para que contenga la secuencia de comandos Transact-

SQL que define el comportamiento del desencadenador SQL Server. Para obtener más información acerca de las secuencias de comandos de desencadenadores, consulte CREATE TRIGGER.

4. Obtenga el objeto Table que hace referencia a la tabla SQL Server que desea en la colección Tables del objeto Database apropiado.

5. Utilice el método BeginAlter del objeto Table para marcar el inicio de los cambios en la definición de tabla SQL Server.

6. Agregue el nuevo objeto Trigger a la colección Triggers del objeto Table seleccionado. 7. Utilice el método DoAlter del objeto Table para marcar el final de los cambios y crear el

desencadenador SQL Server.



1.9.1 Type (Trigger) (SQL-DMO) (Propiedad)

La propiedad Type expone los atributos configurados del componente de Microsoft® SQL Server™ al que se hace referencia.

Se aplica a

Objeto Trigger

Sintaxis

objeto.TypeParte Descripción

objeto Expresión que da como resultado un objeto de la lista Se aplica a.

Devuelve

En el objeto Trigger, la propiedad Type se interpreta con estos valores:Constante Valor Descripción

SQLDMOTrig_All 7Activado por cualquier instrucción de modificación de datos.

SQLDMOTrig_Delete 4 Activado por una instrucción DELETE.SQLDMOTrig_Insert 1 Activado por una instrucción INSERT.SQLDMOTrig_Unknown 0 Valor incorrecto o no válido.SQLDMOTrig_Update 2 Activado por una instrucción UPDATE.

Observaciones

Puede activarse un desencadenador de SQL Server cuando una instrucción INSERT, UPDATE o DELETE de Transact-SQL modifique datos de la tabla en la que está definido.La secuencia de comandos Transact-SQL que define el desencadenador determina las instrucciones Transact-SQL que causan su activación.

Tipo de datos

Entero largo, enumerado

Modificable

De sólo lectura

1.9.2 Desencadenadores anidados (recursive)

Con el valor true (verdadero), permite a los desencadenadores activarse de forma recursiva. La recursión indirecta se produce cuando un desencadenador se activa y realiza una acción que provoca la activación de un desencadenador de otra tabla, con lo que se actualiza la tabla original y, a la vez, se produce una nueva activación del desencadenador original.

Con el valor predeterminado false (falso), no es posible activar los desencadenadores de forma recursiva.

Es posible determinar el estado de esta opción mediante el examen de la propiedad IsRecursiveTriggersEnabled de la función DATABASEPROPERTY.



Desencadenadores anidadosLos desencadenadores se anidan cuando un desencadenador realiza una acción que provoca la activación de otro desencadenador que, a su vez, puede activar otro desencadenador y así sucesivamente. Los desencadenadores puden anidarse hasta un máximo de 32 niveles y es posible controlar si se pueden anidar mediante la opción de configuración del servidor nested triggers (desencadenadores anidados).Si se permiten desencadenadores anidados y un desencadenador de la cadena inicia un bucle infinito, se superará el nivel de anidamiento y se terminará el desencadenador.Puede utilizar desencadenadores anidados para realizar funciones de mantenimiento, tales como el almacenamiento de una copia de seguridad de las filas afectadas por un desencadenador anterior. Por ejemplo, puede crear un desencadenador en titleauthor (autorTítulo) que guarde una copia de seguridad de las filas de titleauthor que haya eliminado el desencadenador delcascadetrig (desEliminCascada). Con la activación de delcascadetrig, la eliminación del valor PS2091 de la columna title_id de la tabla titles elimina la fila o las filas correspondientes en titleauthor. Para guardar los datos, cree un desencadenador DELETE en la tabla titleauthor que guarde los datos eliminados en una nueva tabla, del_save.CREATE TRIGGER savedelON titleauthorFOR DELETEASINSERT del_saveSELECT * FROM deletedNo es recomendable utilizar los desencadenadores anidados en una secuencia que dependa de un orden. Utilice desencadenadores diferentes para realizar modificaciones de datos en cascada.

Nota Dado que los desencadenadores se ejecutan dentro de una transacción, un error en cualquier nivel de un conjunto de desencadenadores anidados anula toda la transacción y provoca que se deshagan todas las modificaciones de datos. Incluya instrucciones PRINT en los desencadenadores para poder determinar dónde se produjo el error.

Desencadenadores recursivos

Un desencadenador no se llama a sí mismo de forma recursiva a menos que se active la opción Desencadenadores recursivos de la base de datos. Hay dos tipos de recursividad:

• La recursividad directa, que se produce cuando un desencadenador se activa y realiza una acción que provoca que el mismo desencadenador se vuelva a activar. Por ejemplo, una aplicación actualiza la tabla T3, que provoca la activación del desencadenador Trig3. Trig3 vuelve a actualizar T3, lo que provoca una nueva activación del mismo desencadenador Trig3.

• La recursividad indirecta, que se produce cuando un desencadenador se activa y realiza una acción que provoca la activación de un desencadenador en otra tabla. Este segundo desencadenador causa una actualización en la tabla original, que, a su vez, provoca que se vuelva a activar el desencadenador original. Por ejemplo, una aplicación actualiza la tabla T1, lo que provoca la activación del desencadenador Trig1. Trig1 actualiza la tabla T2, con lo que se activa el desencadenador Trig2. A su vez, Trig2 actualiza la tabla T1, lo que provoca que se vuelva a activar Trig1.

Ejemplos

Es posible utilizar los desencadenadores recursivos en una tabla caracterizada por una relación de referencia a sí misma (también conocida como de cierre transitivo). Por ejemplo, la tabla emp_mgr (empResp) define:

• A un empleado (emp) de una empresa. • Al responsable de cada empleado (mgr). • El número total de empleados en la estructura de la organización que dependen de cada

empleado (NoOfReports).



Un desencadenador de actualización recursivo puede servir para mantener actualizada la columna NoOfReports a medida que se insertan nuevos registros. El desencadenador de inserción actualiza la columna NoOfReports del registro de responsables, que actualiza de modo recursivo la columna NoOfReports de otros registros de la jerarquía de administración.USE pubsGO-- Turn recursive triggers ON in the database.EXECUTE sp_dboption 'pubs', 'recursive triggers', TRUEGOCREATE TABLE emp_mgr (emp char(30) PRIMARY KEY, mgr char(30) NULL FOREIGN KEY REFERENCES emp_mgr(emp),NoOfReports int DEFAULT 0)GOCREATE TRIGGER emp_mgrins ON emp_mgr FOR INSERTASDECLARE @e char(30), @m char(30)DECLARE c1 CURSOR FORSELECT emp_mgr.empFROM emp_mgr, insertedWHERE emp_mgr.emp = inserted.mgrOPEN c1FETCH NEXT FROM c1 INTO @eWHILE @@fetch_status = 0BEGINUPDATE emp_mgr SET emp_mgr.NoOfReports = emp_mgr.NoOfReports + 1 -- add 1 for newlyWHERE emp_mgr.emp = @e -- added employeeFETCH NEXT FROM c1 INTO @eENDCLOSE c1DEALLOCATE c1GO-- This recursive UPDATE trigger works assuming:-- 1. Only singleton updates on emp_mgr.-- 2. No inserts in the middle of the org tree.CREATE TRIGGER emp_mgrupd ON emp_mgr FOR UPDATEASIF UPDATE (mgr)BEGINUPDATE emp_mgrSET emp_mgr.NoOfReports = emp_mgr.NoOfReports + 1 -- Increment mgr'sFROM inserted -- (no. of reports) by WHERE emp_mgr.emp = inserted.mgr -- 1 for the new report.UPDATE emp_mgrSET emp_mgr.NoOfReports = emp_mgr.NoOfReports - 1 -- Decrement mgr'sFROM deleted -- (no. of reports) by 1 WHERE emp_mgr.emp = deleted.mgr -- for the new reportENDGO-- Insert some test data rows.INSERT emp_mgr(emp, mgr) VALUES ('Harry', NULL)INSERT emp_mgr(emp, mgr) VALUES ('Alice', 'Harry')INSERT emp_mgr(emp, mgr) VALUES ('Paul', 'Alice')INSERT emp_mgr(emp, mgr) VALUES ('Joe', 'Alice')



INSERT emp_mgr(emp, mgr) VALUES ('Dave', 'Joe')GOSELECT * FROM emp_mgrGO-- Change Dave's manager from Joe to HarryUPDATE emp_mgr SET mgr = 'Harry'WHERE emp = 'Dave'GOSELECT * FROM emp_mgrGOÉstos son los resultados antes de la actualización:emp mgr NoOfReports------------------------------ ----------------------------- ----------- Alice Harry 2Dave Joe 0Harry NULL 1Joe Alice 1Paul Alice 0Éstos son los resultados después de la actualización:emp mgr NoOfReports------------------------------ ----------------------------- ----------- Alice Harry 2Dave Harry 0Harry NULL 2Joe Alice 0Paul Alice 0

1.9.3 CREATE TRIGGER (Creación de Disparadores)

Crea un desencadenador, que es una clase especial de procedimiento almacenado que se ejecuta automáticamente cuando un usuario intenta la instrucción especificada de modificación de datos en la tabla indicada. Microsoft® SQL Server™ permite la creación de varios desencadenadores para cualquier instrucción INSERT, UPDATE o DELETE dada.

Sintaxis

CREATE TRIGGER nombreDesencadenadorON tabla[WITH ENCRYPTION]{{FOR { [DELETE] [,] [INSERT] [,] [UPDATE] }[WITH APPEND][NOT FOR REPLICATION]ASinstrucciónSQL [...n]

}|{FOR { [INSERT] [,] [UPDATE] }[WITH APPEND][NOT FOR REPLICATION]AS { IF UPDATE (columna)[{AND | OR} UPDATE (columna)]



[...n]| IF (COLUMNS_UPDATED() {operadorNivelBit} máscaraBitsActualizada) { operadorComparación} máscaraBitsColumna [...n]}instrucciónSQL [...n]

}}

Argumentos

nombreDesencadenador

Es el nombre del desencadenador. Un nombre de desencadenador debe cumplir las reglas de los identificadores y debe ser único en la base de datos. Especificar el nombre del propietario del desencadenador es opcional.

tabla

Es la tabla en que se ejecuta el desencadenador; algunas veces se llama la tabla del desencadenador. Especificar el nombre del propietario de la tabla es opcional. No se pueden especificar vistas.

WITH ENCRYPTION

Codifica las entradas syscomments que contienen el texto de CREATE TRIGGER.

{ [DELETE] [,] [INSERT] [,] [UPDATE] } | { [INSERT] [,] [UPDATE]}

Son palabras clave que especifican qué instrucciones de modificación de datos activan el desencadenador cuando se intentan contra esta tabla. Se debe especificar al menos una opción. En la definición del desencadenador se permite cualquier combinación de éstas. Si especifica más de una opción, sepárelas con comas.

WITH APPEND

Especifica que debe agregarse un desencadenador adicional de un tipo existente. El uso de esta cláusula opcional sólo es necesario cuando el nivel de compatibilidad sea menor o igual que 65. Si el nivel de compatibilidad es mayor o igual que 70, la cláusula opcional WITH APPEND no es necesaria para agregar un desencadenador adicional de un tipo existente (éste es el comportamiento predeterminado de CREATE TRIGGER con el valor de nivel de compatibilidad mayor o igual que 70). Para obtener más información, consulte sp_dbcmptlevel.

NOT FOR REPLICATION

Indica que el desencadenador no debe ejecutarse cuando un proceso de duplicación modifica la tabla involucrada en el mismo.

AS

Son las acciones que va a llevar a cabo el desencadenador.

instrucciónSQL

Son las condiciones y acciones del desencadenador. Las condiciones del desencadenador especifican los criterios adicionales que determinan si los intentos de las instrucciones DELETE, INSERT o UPDATE hacen que se lleven a cabo las acciones del desencadenador.



Las acciones del desencadenador especificadas en las instrucciones Transact-SQL entran en efecto cuando se intenta la acción del usuario (DELETE, INSERT o UPDATE).

Los desencadenadores pueden incluir cualquier número y clase de instrucciones Transact-SQL excepto SELECT. Un desencadenador está diseñado para comprobar o cambiar los datos en base a una instrucción de modificación de datos; no debe devolver datos al usuario. Las instrucciones Transact-SQL de un desencadenador incluyen a menudo lenguaje de control de flujo. En las instrucciones CREATE TRIGGER se utilizan unas cuantas tablas especiales:

• deleted e inserted son tablas lógicas (conceptuales). Son de estructura similar a la tabla en que se define el desencadenador (es decir, la tabla en que se intenta la acción del usuario) y mantiene los valores antiguos o nuevos de las filas que la acción del usuario puede cambiar. Por ejemplo, para recuperar todos los valores de la tabla deleted, utilice:

SELECT *

FROM deleted

• En un desencadenador DELETE, INSERT o UPDATE, SQL Server no admite referencias de columnas text, ntext o image en las tablas inserted y deleted si el nivel de compatibilidad es igual a 70. No se puede tener acceso a los valores text, ntext e image de las tablas inserted y deleted. Para recuperar el nuevo valor de un desencadenador INSERT o UPDATE, combine la tabla inserted con la tabla de actualización original. Cuando el nivel de compatibilidad es 65 o inferior, se devuelven valores Null para las columnas inserted o deleted text, ntext o image que admiten valores Null; si las columnas no permiten valores Null, se devuelven cadenas de longitud cero.

n

Se trata de un marcador de posición que indica que se pueden incluir varias instrucciones Transact-SQL en el desencadenador. Para la instrucción IF UPDATE (columna), se pueden incluir varias columnas al repetir la cláusula UPDATE (columna).

IF UPDATE (columna)

Prueba una acción INSERT o UPDATE en una columna especificada y no se utiliza con operaciones DELETE. Se puede especificar más de una columna. Como el nombre de la tabla se especifica en la cláusula ON, no lo incluya antes del nombre de la columna en una cláusula IF UPDATE. Para probar una acción INSERT o UPDATE para más de una columna, especifique una cláusula UPDATE(columna) separada a continuación de la primera.

Nota La cláusula IF UPDATE (columna) funciona de forma idéntica a una instrucción IF, IF…ELSE o WHILE, y puede utilizar el bloque BEGIN…END. Para obtener más información, consulte Lenguaje de control de flujo.

UPDATE(columna) puede utilizarse en cualquier parte dentro del cuerpo del desencadenador.

columna

Es el nombre de la columna que se va a probar para una acción INSERT o UPDATE. Esta columna puede ser de cualquier tipo de datos admitido por SQL Server. Para obtener más información, consulte Tipos de datos.



IF (COLUMNS_UPDATED())

Prueba, sólo en un desencadenador INSERT o UPDATE, si la columna o columnas mencionadas se insertan o se actualizan. COLUMNS_UPDATED devuelve un patrón de bits varbinary que indica qué columnas de la tabla se insertaron o se actualizaron.

COLUMNS_UPDATED puede utilizarse en cualquier parte dentro del cuerpo del desencadenador.

operadorNivelBit

Es el operador de bits que se utilizará en las comparaciones.

máscaraBitsActualizada

Es la máscara de bits de enteros de las columnas realmente actualizadas o insertadas. Por ejemplo, la tabla t1 contiene las columnas C1, C2, C3, C4 y C5. Para comprobar si las columnas C2, C3 y C4 se han actualizado (con un desencadenador UPDATE en la tabla t1), especifique un valor de 14. Para comprobar si sólo se ha actualizado la columna C2, especifique un valor de 2.

operadorComparación

Es el operador de comparación. Utilice el signo igual (=) para comprobar si todas las columnas especificadas en máscaraBitsActualizada se han actualizado. Utilice el símbolo mayor que (>) para comprobar si alguna de las columnas especificadas en máscaraBitsActualizada se han actualizado.

máscaraBitsColumna

Es la máscara de bits de enteros de las columnas que hay que comprobar para ver si se han actualizado o insertado.

Observaciones

A menudo se utilizan desencadenadores para exigir las reglas del negocio y la integridad de los datos. SQL Server proporciona integridad referencial declarativa (DRI, Declarative Referential Integrity) a través de las instrucciones de creación de tabla (ALTER TABLE y CREATE TABLE); sin embargo, DRI no proporciona integridad referencial entre bases de datos. Para exigir la integridad referencial (reglas acerca de la relación entre la clave principal y la clave externa de las tablas), utilice las restricciones de clave principal y externa (las palabras clave PRIMARY KEY y FOREIGN KEY de ALTER TABLE y CREATE TABLE). Si existen restricciones en la tabla del desencadenador, se comprobarán antes de la ejecución del desencadenador. Si se infringe alguna de las restricciones PRIMARY KEY o FOREIGN KEY, el desencadenador no se ejecuta (no se activa).

Nota El que SQL Server interprete una cadena vacía (NULL) como un espacio simple o como una verdadera cadena vacía se controla mediante el valor de sp_dbcmptlevel. Si el nivel de compatibilidad es menor o igual que 65, SQL Server interpreta las cadenas vacías como espacios individuales. Si el nivel de compatibilidad es igual a 70, SQL Server interpreta las cadenas vacías como tales. Para obtener más información, consulte sp_dbcmptlevel.

Limitaciones de los desencadenadores

CREATE TRIGGER debe ser la primera instrucción en el proceso por lotes y sólo se puede aplicar a una tabla. Un desencadenador se crea solamente en la base de datos actual; sin embargo, un desencadenador puede hacer referencia a objetos que están fuera de la base de datos actual.



Si se especifica el nombre del propietario del desencadenador (para cualificar el desencadenador), cualifique el nombre de la tabla de la misma forma. La misma acción del desencadenador puede definirse para más de una acción del usuario (por ejemplo, INSERT y UPDATE) en la misma instrucción CREATE TRIGGER. En un desencadenador se puede especificar cualquier instrucción SET. La opción SET elegida permanece en efecto durante la ejecución del desencadenador y, después, vuelve a su configuración anterior.Cuando se activa un desencadenador, los resultados se devuelven a la aplicación que llama, exactamente igual que con los procedimientos almacenados. Para impedir que los resultados tengan que devolverse a la aplicación debido a la activación de un desencadenador, no incluya las instrucciones SELECT que devuelven resultados o las instrucciones que realizan una asignación variable en un desencadenador. Un desencadenador que incluya instrucciones SELECT que devuelven resultados al usuario o instrucciones que realizan asignaciones de variables requiere un tratamiento especial; estos resultados devueltos tendrían que escribirse en cada aplicación en la que se permiten modificaciones a la tabla del desencadenador. Si deben ocurrir asignaciones de variable en un desencadenador, utilice una instrucción SET NOCOUNT al principio del desencadenador para eliminar la devolución de cualquier conjunto de resultados. En una vista no se puede crear un desencadenador.Un desencadenador DELETE no captura una instrucción TRUNCATE TABLE. Aunque una instrucción TRUNCATE TABLE es, de hecho, un desencadenador DELETE sin una cláusula WHERE (quita todas las filas), no se registra y, por tanto, no puede ejecutar un desencadenador. Dado que el permiso de la instrucción TRUNCATE TABLE es, de forma predeterminada, el del propietario de la tabla y no se puede transferir, sólo el propietario de la tabla debe preocuparse de colocar sin darse cuenta una instrucción TRUNCATE TABLE en el desencadenador DELETE.La instrucción WRITETEXT, ya se registre o no, no activa un desencadenador.

Las siguientes instrucciones Transact-SQL no están permitidas en un desencadenador:

ALTER DATABASE ALTER PROCEDURE ALTER TABLEALTER TRIGGER ALTER VIEW CREATE DATABASECREATE DEFAULT CREATE INDEX CREATE PROCEDURECREATE RULE CREATE SCHEMA CREATE TABLECREATE TRIGGER CREATE VIEW DENYDISK INIT DISK RESIZE DROP DATABASEDROP DEFAULT DROP INDEX DROP PROCEDUREDROP RULE DROP TABLE DROP TRIGGERDROP VIEW GRANT LOAD DATABASELOAD LOG RESTORE DATABASE RESTORE LOGREVOKE RECONFIGURETRUNCATE TABLE UPDATE STATISTICS

Nota Debido a que SQL Server no admite desencadenadores definidos por el usuario en tablas del sistema, se recomienda que no se creen desencadenadores definidos por el usuario en tablas del sistema.

Desencadenadores múltiples

SQL Server permite que se creen varios desencadenadores por cada evento de modificación (DELETE, INSERT o UPDATE). Por ejemplo, si se ejecuta CREATE TRIGGER FOR UPDATE para una tabla que ya tiene un desencadenador UPDATE, se creará un desencadenador de actualización adicional. En las versiones anteriores, sólo se permitía un desencadenador por cada evento de modificación (INSERT, UPDATE, DELETE) en cada tabla.

Nota El comportamiento predeterminado de CREATE TRIGGER (con un nivel de compatibilidad de 70) es agregar desencadenadores adicionales a los ya existentes si los nombres de



desencadenadores son distintos. Si el nombre de los desencadenadores es el mismo, SQL Server devuelve un mensaje de error. Sin embargo, si el nivel de compatibilidad es igual o menor que 65, cualquier desencadenador creado con la instrucción CREATE TRIGGER substituirá a los desencadenadores existentes del mismo tipo, incluso si los nombres de los desencadenadores son distintos. Para obtener más información, consulte sp_dbcmptlevel.

Desencadenadores recursivos

SQL Server permite también la invocación recursiva de desencadenadores cuando el valor recursive triggers está habilitado en sp_dboption.Los desencadenadores recursivos permiten dos tipos de recursión:

• Recursión indirecta • Recursión directa

Con la recursión indirecta, una aplicación actualiza la tabla T1, que activa el desencadenador TR1 para actualizar la tabla T2. En esta situación, el desencadenador T2 activa y actualiza la tabla T1.Con la recursión directa, la aplicación actualiza la tabla T1, que activa el desencadenador TR1 para actualizar la tabla T1. Debido a que la tabla T1 ya se ha actualizado, el desencadenador TR1 se activa de nuevo, y así sucesivamente.Este ejemplo utiliza ambas recursiones de desencadenador, directa e indirecta. Suponga que en la tabla T1 se han definido dos desencadenadores de actualización, TR1 y TR2. El desencadenador TR1 actualiza la tabla T1 recursivamente. Una instrucción UPDATE ejecuta cada TR1 y TR2 una vez. Además, la ejecución de TR1 desencadena la ejecución de TR1 (recursivamente) y TR2. Las tablas inserted y deleted de un desencadenador dado contienen filas que corresponden sólo a la instrucción UPDATE que invocó al desencadenador.

Nota El comportamiento anterior sólo se produce si el valor recursive triggers de sp_dboption está habilitado. No hay un orden definido en el que se ejecuten los distintos desencadenadores definidos de un evento dado. Cada desencadenador debe ser independiente.

Si alguno de los desencadenadores realiza una instrucción ROLLBACK TRANSACTION, no se ejecuta ningún desencadenador posterior, independientemente del nivel de anidamiento.

Desencadenadores anidados

Los desencadenadores pueden anidarse hasta 32 niveles. Si un desencadenador cambia una tabla en la que hay otro desencadenador, el segundo se activa y puede, entonces, llamar a un tercero, y así sucesivamente. Si algún desencadenador de la cadena causa un bucle infinito, el nivel de anidamiento se habrá sobrepasado, con lo que se cancela el desencadenador. Para deshabilitar los desencadenadores anidados, establezca la opción nested triggers de sp_configure en 0 (desactivada). La configuración predeterminada permite desencadenadores anidados. Si los desencadenadores anidados están desactivados, los desencadenadores recursivos también se deshabilitan, independientemente del valor de recursive triggers de sp_dboption.

Resolución diferida de nombres

SQL Server permite que los procedimientos almacenados, desencadenadores y procesos por lotes de Transact-SQL hagan referencia a tablas que no existen en el momento de la compilación. Esta capacidad se denomina resolución diferida de nombres. Sin embargo, si los procedimientos almacenados, desencadenadores y procesos por lotes de Transact-SQL hacen referencia a una tabla definida en el procedimiento almacenado o desencadenador, se emitirá una advertencia en el momento de la creación sólo si el valor de nivel de compatibilidad (que se establece al ejecutar sp_dbcmptlevel) es igual a 65. Si se utiliza un proceso por lotes, la advertencia se emite en el momento de la compilación. Si la tabla a la que se hace referencia no existe, en el momento de la ejecución se devolverá un mensaje de error. Para obtener más información, consulte Resolución diferida de nombres y compilación.



Permisos

De forma predeterminada, el permiso CREATE TRIGGER es del propietario de la tabla en que se ha definido el desencadenador o de los miembros de las funciones fijas de base de datos db_owner y db_ddladmin, y no se puede transferir.

Ejemplos

A. Utilizar un desencadenador con un mensaje de aviso

El siguiente desencadenador de ejemplo imprime un mensaje en el cliente cuando alguien intenta agregar o cambiar datos en la tabla titles.

Nota El mensaje 50009 es un mensaje definido por el usuario en sysmessages. Para obtener información acerca de la creación de mensajes definidos por el usuario, consulte sp_addmessage.

USE pubsIF EXISTS (SELECT name FROM sysobjectsWHERE name = 'reminder' AND type = 'TR')DROP TRIGGER reminderGOCREATE TRIGGER reminderON titlesFOR INSERT, UPDATE AS RAISERROR (50009, 16, 10)GO

B. Utilizar un desencadenador con un mensaje de correo electrónico de aviso

Este ejemplo envía un mensaje de correo electrónico a una persona especificada (MaryM) cuando cambia la tabla titles.USE pubsIF EXISTS (SELECT name FROM sysobjectsWHERE name = 'reminder' AND type = 'TR')DROP TRIGGER reminderGOCREATE TRIGGER reminderON titlesFOR INSERT, UPDATE, DELETE ASEXEC master..xp_sendmail 'MaryM', 'Don''t forget to print a report for the distributors.'GO

C. Utilizar un desencadenador de regla de negocio entre las tablas employee y jobs

Debido a que las restricciones CHECK pueden hacer referencia sólo a las columnas en que se han definido las restricciones de nivel de columna o de nivel de tabla, cualquier restricción de tablas cruzadas (en este caso, reglas del negocio) debe definirse como desencadenadores.Este ejemplo crea un desencadenador que, cuando se inserta o se cambia un nivel de trabajo de empleado, comprueba que el nivel especificado del trabajo del empleado (job_lvls) en el que se basan los salarios se encuentra en el intervalo definido para el trabajo. Para obtener el intervalo adecuado, debe hacerse referencia a la tabla jobs.USE pubsIF EXISTS (SELECT name FROM sysobjectsWHERE name = 'reminder' AND type = 'TR')DROP TRIGGER reminderGOCREATE TRIGGER employee_insupd



ON employeeFOR INSERT, UPDATEAS/* Get the range of level for this job type from the jobs table. */DECLARE @min_lvl tinyint,@max_lvl tinyint,@emp_lvl tinyint,@job_id smallintSELECT @min_lvl = min_lvl, @max_lvl = max_lvl, @emp_lvl = i.job_lvl,@job_id = i.job_idFROM employee e INNER JOIN inserted i ON e.emp_id = i.emp_id JOIN jobs j ON j.job_id = i.job_idIF (@job_id = 1) and (@emp_lvl <> 10) BEGINRAISERROR ('Job id 1 expects the default level of 10.', 16, 1)ROLLBACK TRANSACTIONENDELSEIF NOT (@emp_lvl BETWEEN @min_lvl AND @max_lvl)BEGINRAISERROR ('The level for job_id:%d should be between %d and %d.',16, 1, @job_id, @min_lvl, @max_lvl)ROLLBACK TRANSACTIONEND

D. Utilizar la resolución diferida de nombres

El ejemplo siguiente crea dos desencadenadores para ilustrar la resolución diferida de nombres. USE pubsIF EXISTS (SELECT name FROM sysobjectsWHERE name = 'trig1' AND type = 'TR')DROP TRIGGER trig1GO-- Creating a trigger on a nonexistent table.CREATE TRIGGER trig1on authorsFOR INSERT, UPDATE, DELETEAS SELECT a.au_lname, a.au_fname, x.info FROM authors a INNER JOIN does_not_exist x ON a.au_id = x.au_idGO-- Here is the statement to actually see the text of the trigger.SELECT o.id, c.textFROM sysobjects o INNER JOIN syscomments c ON o.id = c.idWHERE o.type = 'TR' and o.name = 'trig1'-- Creating a trigger on an existing table, but with a nonexistent -- column.USE pubsIF EXISTS (SELECT name FROM sysobjectsWHERE name = 'trig2' AND type = 'TR')DROP TRIGGER trig2GOCREATE TRIGGER trig2



ON authorsFOR INSERT, UPDATEAS DECLARE @fax varchar(12)SELECT @fax = phone FROM authorsGO-- Here is the statement to actually see the text of the trigger.SELECT o.id, c.textFROM sysobjects o INNER JOIN syscomments c ON o.id = c.idWHERE o.type = 'TR' and o.name = 'trig2'

E. Utilizar COLUMNS_UPDATED

En este ejemplo se crean dos tablas. Una tabla employeeData y una tabla auditEmployeeData. La tabla employeeData, que contiene información confidencial de los sueldos de los empleados, puede ser modificada por los miembros del departamento de recursos humanos. Si se cambia el número de seguridad social del empleado, el sueldo anual o el número de cuenta bancaria, se genera un registro de auditoría y se inserta en la tabla de auditoría auditEmployeeData.Con la función COLUMNS_UPDATED(), es posible comprobar rápidamente cualquier cambio en estas columnas que contienen información confidencial de los empleados.USE pubsIF EXISTS(SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLESWHERE TABLE_NAME = 'employeeData')DROP TABLE employeeDataIF EXISTS(SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLESWHERE TABLE_NAME = 'auditEmployeeData')DROP TABLE auditEmployeeDataGOCREATE TABLE employeeData (emp_id int NOT NULL,emp_bankAccountNumber char (10) NOT NULL,emp_salary int NOT NULL,emp_SSN char (11) NOT NULL,emp_lname nchar (32) NOT NULL,emp_fname nchar (32) NOT NULL,emp_manager int NOT NULL)GOCREATE TABLE auditEmployeeData (audit_log_id uniqueidentifier DEFAULT NEWID(),audit_log_type char (3) NOT NULL,audit_emp_id int NOT NULL,audit_emp_bankAccountNumber char (10) NULL,audit_emp_salary int NULL,audit_emp_SSN char (11) NULL,audit_user sysname DEFAULT SUSER_SNAME(),audit_changed datetime DEFAULT GETDATE())GOCREATE TRIGGER updEmployeeData ON employeeData FOR update AS-- Check whether columns 2, 3 or 4 has been updated. If any or all of -- columns 2, 3 or 4 have been changed, create an audit record.-- The bitmask is: power(2,(2-1))+power(2,(3-1))+power(2,(4-1)) = 14



-- To check if all columns 2, 3, and 4 are updated, use = 14 in place of -- >0 (below).IF (COLUMNS_UPDATED() & 14) > 0-- Use IF (COLUMNS_UPDATED() & 14) = 14 to see if all of columns 2, 3, -- and 4 are updated.BEGIN-- Audit OLD record.INSERT INTO auditEmployeeData(audit_log_type,audit_emp_id,audit_emp_bankAccountNumber,audit_emp_salary,audit_emp_SSN)SELECT 'OLD', del.emp_id,del.emp_bankAccountNumber,del.emp_salary,del.emp_SSNFROM deleted del-- Audit NEW record.INSERT INTO auditEmployeeData(audit_log_type,audit_emp_id,audit_emp_bankAccountNumber,audit_emp_salary,audit_emp_SSN)SELECT 'NEW',ins.emp_id,ins.emp_bankAccountNumber,ins.emp_salary,ins.emp_SSNFROM inserted insENDGO--Inserting a new employee does not cause the UPDATE trigger to fire.INSERT INTO employeeDataVALUES ( 101, 'USA-987-01', 23000, 'R-M53550M', N'Mendel', N'Roland', 32)GO-- Updating the employee record for employee number 101 to change the -- salary to 51000 causes the UPDATE trigger to fire and an audit trail -- to be produced.UPDATE employeeDataSET emp_salary = 51000WHERE emp_id = 101GOSELECT * FROM auditEmployeeDataGO--Updating the employee record for employee number 101 to change both the bank account number and social security number (SSN) causes the UPDATE trigger to fire and an audit trail to be produced.UPDATE employeeDataSET emp_bankAccountNumber = '133146A0', emp_SSN = 'R-M53550M'WHERE emp_id = 101GOSELECT * FROM auditEmployeeDataGO



Anexos

I.1 SQL (Lenguaje Estructurado de Consultas “ Structured Query Language”)

ntes de exponer los siguientes incisos de SQL desarrollaremos una idea global del funcionamiento de SQL, ilustrando sus características y funciones más importantes.A

SQL esta basado en el modelo relacional que organiza los datos en una base como una colección de tablas.

• Cada tabla tiene un nombre que la identifica unívocamente.• Cada tabla tiene una o más columnas dispuestas en un orden específico de izquierda a derecha.• Cada tabla tiene cero o más filas, conteniendo cada una un único valor en cada columna. Las filas están desordenadas.• Todos los valores de una columna determinada tienen el mismo tipo de datos, y éstos están extraídos de un conjunto de valores legales llamado el dominio de la columna.

Las tablas están relacionadas unas con otras por los datos que contienen. El modelo de datos relacional utiliza claves primarias y foráneas para representar estas relaciones entre las tablas.

• Una clave primaria es una columna o combinación de columnas dentro de una tabla(s) cuyo(s) valor(es) identifica(n) unívocamente a cada fila de la tabla.

• Una clave foránea es una columna o combinación de columnas en una tabla, cuyo(s) valor(es) es(son) un valor de la clave primaria .

• Una combinación de claves primarias/foráneas crea una relación padre/hijo entre las tablas que las contienen.

Todas las sentencias en SQL comienzan con un verbo, una palabra clave que describe lo que la sentencia hace (CREATE, INSERT, DELETE, COMMIT), la sentencia continúa con una o más cláusulas (Ver fig. 4.1). Una cláusula puede especificar los datos sobre los que debe actuar la sentencia, o proporcionar más detalles acerca de lo que ésta hace, también comienza con una palabra clave (WHERE, FROM, INTO, HAVING, etc.), algunas son opcionales y otras son necesarias. La estructura y contenido varían de una cláusula a otra.

p a l a b r a sc l a v e

v e r b o c l á u s u l a

D E L E T E F R O M n o m b r e _ d e _ t a b l a

W H E R E n o m b r e _ c o l u m n a < c o n d i c i ó n > < e x p r e s i ó n >



Fig. 4.1 Estructura de una Sentencia SQL.

El estándar SQL ANSI/ISO (American National Standards Institute/International Standards Organization) especifica las palabras clave que se utilizan como verbos y cláusulas de sentencias. De acuerdo al estándar, estas palabras clave no pueden ser utilizadas para designar objetos de la base, tales como tablas, columnas y usuarios. Los objetos de una base de datos basada en SQL se identifican asignándoles nombres únicos, utilizándose en las sentencias para identificar el objeto en la base sobre la que la sentencia debe actuar. El estándar ANSI/ISO especifica palabras permisibles para identificar tablas, columnas y usuarios; algunas implementaciones soportan objetos como procedimientos almacenados, relaciones clave primaria/foránea y formularios de entrada de datos, entre otros.

El estándar ANSI/ISO especifica varios tipos de datos que pueden ser almacenados y manipulados por el lenguaje SQL y la mayoría de los productos los soporta, además de ofrecer un conjunto más extenso que éste.

4.1 HISTORIA Y PERSPECTIVAS DE SQL.

Una de las principales tareas de un sistema computacional es almacenar y gestionar datos, por tal motivo, programas especializados en computadoras conocidos como sistemas de gestión de bases de datos comenzaron a aparecer a finales de los sesenta y comienzo de los setenta. Anteriormente un sistema de gestión de base datos o DBMS (Sistema Manejador de Base de Datos, “Database Management System”), ayudaba a los usuarios a organizar y estructurar sus datos, y permitía al sistema computacional jugar un papel más activo en la gestión de los datos. Aunque los sistemas de bases de datos se desarrollaron inicialmente en mainframes, su popularidad se ha extendido a minicomputadoras, computadoras personales y estaciones de trabajo.

Durante los últimos años se ha popularizado un tipo específico de DBMS, llamado sistema de gestión de base de datos relacional (RDBMS). Las bases de datos relacionales organizan los datos en una forma tabular sencilla y proporcionan muchas ventajas sobre los tipos anteriores de bases de datos. SQL (Lenguaje Estructurado de Consultas “ Structured Query Language”) es un lenguaje relacional utilizado para trabajar con bases de datos relacionales.

BREVE HISTORIA DE SQL



La historia del lenguaje SQL está íntimamente relacionada con el desarrollo de las bases de datos relacionales. La Tabla 4.1 muestra algunos de los acontecimientos en sus veinte años de historia.

El concepto de base de datos relacional fue desarrollado originalmente por el Dr. E. F. Ted Codd, quien publicó un artículo titulado «Un modelo relacional de datos para grandes bancos de datos compartidos» que esquematizaba una teoría matemática de como los datos podrían ser almacenados y manipulados utilizando una estructura tabular.

Fecha Acontecimiento

1970 Codd define el modelo de base de datos relacional.

1974 Comienza el proyecto System/R de IBM.

1974 Primer artículo que describe el lenguaje SEQUEL.

1978 Test de clientes del System/R.

1979 Oracle introduce el primer RDBMS comercial.

1981 Relational Technology introduce Ingres.

1981 IBM anuncia SQL/DS.

1982 ANSI forma el comité de estándares SQL.

1983 IBM anuncia DB2.

1986 Se ratifica el estándar ANSI SQL.

1986 Sybase introduce RDBMS para procesamiento de transacciones.1987 Se ratifica el estándar ISO SQL

1988 Ashton-Tate y Microsoft anuncian SQL Server para OS/2

1988 IBM anuncia la versión 2 de DB2

1989 Primera entrega de servidores de bases de datos SQL para OS/2Tabla 4.1 Acontecimientos en el desarrollo de SQL.

ACEPTACIÓN COMERCIAL

La publicación del estándar ANSI/ISO para SQL en 1986, dio carácter oficial a SQL como estándar. La tabla 4.2 muestra algunos de los sistemas de gestión de base de datos en SQL más populares sobre diferentes tipos de sistemas de computadoras.

Al inicio de los noventa, SQL estaba claramente establecido como el lenguaje estándar de base de datos. Los vendedores de base de datos que no soportaban SQL se preocuparon de hacerlo sobre todo por que cualquier nuevo producto de base de datos requería a SQL como reclamo para ser tomado en serio; SQL se convirtió en el estándar oficial para las bases de datos relacionales.

DBMS Sistemas informáticos



DB2 Mainframes IBM bajo MVS.

SQL/DS Mainframes IBM bajo VM y DOS/VSE.

Rdb/VMS Mainframes VAX/VMS de Digital.

Oracle Mainframes, minicomputadoras y PC’s.

Ingres Mainframes y PC’s.

Sybase Mainframes y LANs.

Informix-SQL Mainframes y PC’s basados en UNIX.

Unify Mainframes basados en UNIX.

OS/2 Extended Edition

Sistemas PS/2 de IBM bajo OS/2.

SQL Server PC LANs basados en OS/2.

SQLBase PC LANs basados en DOS y OS/2.

DBASE IV PC’s y PC LANs.

Tabla 4.2 Principales sistemas de gestión de base de datos basados en SQL.

Uno de los desarrollos más importantes en la aceptación del mercado de SQL es la creación de los estándares SQL. Las referencias al «estándar SQL» significa generalmente el estándar oficial adoptado por la ANSI e ISO.

La mayoría de los desarrolladores de software están de acuerdo en que un estándar para SQL es esencial para el cómputo cliente/servidor. Sin embargo, no menos de ocho proyectos se están llevando a cabo para crear un estándar SQL. Sólo el ANSI es responsable de tres estándares ya sean publicados o en proceso. Otros esfuerzos involucran a consorcios de la industria, tales como SAG (el grupo de acceso a SQL), X/Open y a compañías como IBM, Microsoft y Borland. Si además consideramos que cualquier Base de Datos “habla su propio dialecto de SQL” y tiene su propio conjunto de extensiones de este lenguaje, no es fácil la tarea para su estandarización .

Las razones para la proliferación de estándares de SQL son numerosas; una de ellas es que los estándares están diseñados solamente para servir como guías, esto deja mucho lugar para la interpretación cuando un proveedor toma una especificación del lenguaje y la pone en práctica en software. Sin embargo, la mayoría de las veces los proveedores intentan hacer mucho más y el problema es que aunque cada proveedor tome decisiones excelentes, éstas son diferentes acerca de como extender el estándar de SQL.

A falta de un estándar aceptado, los proveedores de bases de datos están realizando sus propios trabajos de estandarización. A continuación mencionamos los más significativos para la creación de estándares.

• SQL’89 de ANSI. El estándar SQL del ANSI ratificado en 1989 fue el primer nivel de estandarización de SQL.

• SQL’92 de ANSI. Una extensión al estándar de 1989 que se convirtió en un estándar importante en los siguientes años, conforme los proveedores de bases de datos y herramientas hicieron modificaciones para tener compatibilidad con él.

• SQL’93 de ANSI. Un esfuerzo para expandir sustancialmente el lenguaje, proporciona más estructura y estándares para tener acceso a bases de datos orientadas a objetos.



• SAG (Grupo de acceso a SQL) y X/Open. SAG es un consorcio de proveedores de bases de datos y herramientas. X/Open es un consorcio de la industria dedicado a publicar y reforzar el uso de estándares para sistemas abiertos. Estas dos agrupaciones están trabajando conjuntamente para establecer un estándar de SQL y un API basados en el SQL’89 de ANSI, y en los últimos avances en el ámbito cliente/servidor.

• IDAPI (Interface Integrada para la Programación de Aplicaciones de Bases de Datos). IDAPI está basada en el trabajo de SAG y de X/Open, refleja el intento de Borland por definir un API para SQL.

• DRDA (Acceso Distribuido a Bases de Datos Relacionales). El estándar emergente de IBM para acceso a bases de datos a través de todas sus plataformas, incluye otra incursión en SQL.

La creciente popularidad de la conexión de computadoras por red durante los últimos años ha tenido un fuerte impacto en la gestión de base de datos y ha dado a SQL una mayor relevancia. Conforme las redes pasan a ser más comunes, las aplicaciones que han corrido tradicionalmente en una minicomputadora o mainframe central se están transfiriendo a redes de área local con estaciones de trabajo de sobremesa y servidores. En estas redes SQL juega un papel crucial como vínculo entre una aplicación que corre en una estación de trabajo y el DBMS que gestiona los datos compartidos en el servidor, en los siguientes incisos mostramos como actua el DBMS en tres arquitecturas.

ARQUITECTURA CENTRALIZADA

La arquitectura de base de datos tradicional utilizada por DB2, SQL/DS y las bases de datos sobre minicomputadoras tales como Oracle e Ingres se muestra en la figura 4.2. En esta arquitectura el DBMS y los datos físicos residen en un sistema mainframe o minicomputadora central, junto con el programa de aplicación que acepta entradas desde la terminal de usuario y muestra los datos en la pantalla del usuario.

Supongamos que el usuario teclea una consulta que requiere una búsqueda secuencial en la base de datos; por ejemplo, hallar la cantidad media de mercancías de todos los pedidos; el DBMS recibe la consulta, explora la base de datos para acceder a cada uno de los registros de datos del disco, calcula el promedio y muestra el resultado en la pantalla de la terminal.

Tanto el procesamiento de la aplicación como el procesamiento de la base de datos se producen en la computadora central, y como el sistema es compartido por muchos usuarios, cada usuario experimenta una degradación del rendimiento cuando el sistema tiene una carga fuerte.


A p l i c a c i ó n D B M S B a s e d eD a t o s

C o m a n d o s

S i s t e m a C e n t r a l

R e s u l t a d o s

T e r m i n a l


Fig. 4.2. Gestión de Base Datos en una arquitectura centralizada.

ARQUITECTURA DE SERVIDOR DE ARCHIVOS

La introducción de las computadoras personales y de las redes de área local condujo al desarrollo de la arquitectura servidora de archivos, mostrada en la figura 4.3. En esta arquitectura, una aplicación que corre en un computadora personal puede acceder de forma transparente a datos localizados en un servidor de archivos que almacena los archivos compartidos. Cuando una aplicación en PC solicita datos de un archivo compartido, el software de red recupera automáticamente el bloque solicitado del archivo en el servidor. Varias bases de datos PC populares, entre las que se incluye Dbase, R:BASE y Paradox, soportan esta estrategia servidora de archivos, donde cada computadora personal ejecuta su propia copia del software DBMS.

Para consultas típicas esta arquitectura proporciona un rendimiento excelente, ya que cada usuario dispone de la potencia completa de un computadora personal ejecutando su propia copia del DBMS. Sin embargo, consideremos una consulta que requiere una exploración secuencial de la base de datos, el DBMS solicita repentinamente bloques de datos de la base de datos, la cual está localizada físicamente a través de la red en el servidor, eventualmente todos los bloques del archivo están solicitados y enviados a través de la red. Obviamente esta arquitectura produce un fuerte tráfico de red y un bajo rendimiento para consultas de este tipo.

Fig. 4.3. Gestión de base de datos en una arquitectura Servidor de Archivos.

ARQUITECTURA CLIENTE /SERVIDOR


P C

P C P C

A p l i c a c i ó n D B M SS o f t w a r e d e R e d

S e r v i d o r d eA r c h i v o s

P e t i c i o n e s d eE / S a D i s c o

B l o q u e s d e D i s c o

B . D . y A r c h i v o sC o m p a r t i d o s


La figura 4.4 muestra la emergente arquitectura cliente/servidor para gestión de base de datos. En esta arquitectura, las computadoras personales están combinadas en una red de área local junto con un servidor de base de datos que almacena las bases de datos compartidas. Las funciones del DBMS están divididas en dos partes: los « frontales » (front-ends) de base de datos, tales como herramientas de consulta interactiva, escritores de informe y programas de aplicación, que se ejecutan en la computadora personal y la máquina de « soporte » (back-end) de la base de datos que almacena y gestiona los datos se ejecutan en el servidor. SQL se ha convertido en el lenguaje de base de datos estándar para comunicación entre las herramientas frontales y la máquina de soporte en esta arquitectura.

Consideremos una vez más la consulta secuencial. En la arquitectura cliente/servidor, la consulta viaja a través de la red hasta el servidor de base de datos como una petición SQL, la máquina de base de datos en el servidor procesa la petición y explora la base de datos, que también reside en el servidor. Cuando calcula el resultado, la máquina de base de datos envía de regreso a través de la red una única contestación a la petición y la aplicación frontal la muestra en pantalla de la PC.

La arquitectura cliente/servidor reduce el tráfico de red y divide la carga de la base de datos. Las funciones de intensiva relación con el usuario, tales como el manejo de la entrada y la visualización de los datos, se concentran en la PC. Las funciones intensivas en proceso de datos, tales como la entrada/salida de archivos y el procesamiento de consultas, se concentran en el servidor de datos. Lo que es más importante, el lenguaje SQL proporciona una interfaz bien definida entre los sistemas frontales y de soporte, comunicando las peticiones de acceso a la base de datos de una manera eficiente.

La arquitectura cliente/servidor ha recibido gran atención con la introducción de redes de PC basadas en OS/2. SQL Server, el Servidor Oracle para SQLBase de Gupta Technologies utilizan esta estrategia.

Fig. 4.4. Gestión de B.D. en una arquitectura Cliente/Servidor.

SQL es un vehículo natural para implementar aplicaciones utilizando una arquitectura cliente/servidor distribuida. En este papel, sirve como enlace entre los sistemas informáticos «frontales» (front-end) optimizados para interactuar con el usuario y los sistemas «de apoyo» (back-end) especializados para gestión de bases de datos, permitiendo que cada sistema rinda lo mejor posible. También permite que las computadoras personales funcionen como frontales de bases de datos mayores dispuestas en minicomputadoras y


P C

P C P C

A p l i c a c i ó nD B M S

S e r v i d o r d eB . D .

P e t i c i o n e s S Q L

D a t o s

B a s e d eD a t o s


mainframes, proporcionando acceso a datos corporativos desde aplicaciones informáticas personales.

SQL Y EL PROCESAMIENTO DE TRANSACCIONES

SQL y las bases de datos relacionales habían tenido históricamente muy poco impacto en las aplicaciones de procesamiento de transacciones en línea (OLTP). Al hacer énfasis en las consultas, las bases de datos relacionales se confinaron, además, al soporte de decisiones y aplicaciones en línea de bajo volúmen, en las cuales su rendimiento más lento era una desventaja. Para aplicaciones OLTP, donde cientos de usuarios necesitan acceso en línea a los datos y tiempos de respuesta por debajo del segundo, el Information Management System (IMS) no relacional de IBM predominaba como DBMS.

En 1986 un nuevo vendedor DBMS, Sybase, introdujo una nueva base de datos basada en SQL diseñada especialmente para aplicaciones OLTP. El DBMS Sybase corría en minicomputadoras VAX/VMS y en estaciones de trabajo Sun, y se centraba en obtener un rendimiento en línea máximo. Oracle Corporation y Relational Technology siguieron en breve con anuncios de que también ellos ofrecerían versiones OLTP de sus populares sistemas de base de datos Oracle e Ingres. En el mercado UNIX, Informix anunció una versión OLTP de su DBMS, llamada Informix-Turbo.

En abril de 1988 IBM supo subirse al tren del OLTP relacional con DB2 Versión 2, cuyos programas de prueba mostraban que la nueva versión operaba por encima de 250 transacciones por segundo en mainframes; IBM proclamó que el rendimiento de DB2 era ahora adecuado para casi todas las aplicaciones OLTP excepto las más exigentes, y animó a los clientes a considerarla como una serie alternativa a IMS. Los bancos de prueba de OLTP se han convertido ahora en una herramienta estándar de ventas para base de datos relacionales, a pesar de serias cuestiones acerca de lo adecuado de esos programas para medir efectivamente el rendimiento de aplicaciones reales.

La conveniencia de SQL para OLTP continúa mejorando, debido a los avances en la tecnología relacional y a la mayor potencia del hardware que conducen a tasas de transacciones cada vez más altas. Los clientes parecen considerar ahora seriamente a DB2 y a las bases de datos relacionales para su utilización en aplicaciones OLTP.

SQL EN COMPUTADORAS PERSONALES

SQL tuvo poco impacto en las computadoras personales hasta finales de los ochenta, para entonces, ya éran comunes las PC potentes que soportaban decenas o centenares de megabytes de almacenamiento en disco. Los usuarios se conectaban, además, mediante redes de área local y deseaban compartir bases de datos. En resumen, las PC comenzaron a necesitar las características que SQL y las bases de datos relacionales podían proporcionarles.

Las primeras bases de datos basadas en SQL para computadoras personales fueron versiones de los productos populares para minicomputadoras que



difícilmente se ajustaban a las computadoras personales. Professional Oracle, anunciado en 1984, requería 2 Mb de memoria en un IBM PC, y Oracle Macintosh, anunciado en 1988, tenía exigencias análogas; una versión PC de Ingres anunciada en 1987, entraba (aunque muy justamente) dentro del límite de 64O KB de MS-DOS; Informix-SQL para MS-DOS fue anunciado en 1986, proporcionando una versión PC de la popular base de datos UNIX. También en 1986, Gupta Technologies, una empresa fundada por un ex-diretor de Oracle, anunció SQLBase, una base de datos para redes de área local PC. SQLBase estuvo entre los primeros productos PC en ofertar una arquitectura cliente/servidor, un avance de los anuncios de bases de datos OS/2 por llegar.

SERVIDORES DE BASE DE DATOS BASADOS EN SQL

A finales de 1989 aparecieron una gran cantidad de anuncios de servidores de bases de datos bajo OS/2 y cuatro de los productos emergieron como líderes en el mercado de servidores de bases de datos como :

• OS/2 Extended Edition. Aunque su versión servidora aún no estaba comercializada, todos esperaban que el gestor de base de datos OS/2 de IBM jugara un papel importante en el mercado de servicios os/2.

• SQL Server de Microsoft. Respaldado por dos de los tres principales desarrolladores de software para PC, este servidor aparecía como el jugador independiente más fuerte. Tenía la ventaja de una buena tecnología (procedente de Sybase), publicidad excelente y una distribución establecida.

• Oracle para OS/2 de Oracle. La versión OS/2 del DBMS relacional independiente más importante reforzaba la buena conexión con las bases de datos Oracle sobre minicomputadoras y mainframes, con la potencia de la fuerza de ventas directas de Oracle.

• SQL Base de Gupta. El primer vendedor con una base de datos en PC LAN fue el más pequeño de los cuatro y un contendiente oscuro, pero el servidor era real, tenía buenas herramientas frontales gráficas, estaba comercializándose (lo que no era necesariamente cierto de los otros tres) y funcionaba.

Existían además, productos servidores de bases de datos de Novell (NetWare SQL), XDB System (XDB Server) y de otras compañías más pequeñas.

La arquitectura cliente/servidor también estimuló el desarrollo de herramientas de bases de datos frontales que podían funcionar con los nuevos servidores, quizá el producto frontal más significativo fue Dbase IV, que Ashton-Tate anunció funcionaría como frontal de SQL Server y de OS/2 Extended Edition. Paradox y DataEasy otras dos bases de datos en PC, también anunciaron frontales para tres o cuatro de los principales servidores. Cada vendedor de servidor también ofertó sus propios productos frontales, incluyendo herramientas de desarrollo de aplicaciones, consultas orientadas a ventanas y facilidades de entradas de datos, herramientas de inspección de la base de datos y otras.



El modelo cliente/servidor de OS/2 también significó un nuevo incentivo para las bases de datos basadas en MS-DOS. Aunque los servidores requerían típicamente la potencia del sistema OS/2, un PC basado en MS-DOS era adecuado como sistema frontal para muchas aplicaciones, tales como entrada de datos, elaboración de informes y consultas interactivas.

Conforme los años ochenta finalizaban, el papel de los servidores de base de datos basados en SQL y OS/2 se convertía en uno de los temas más novedosos en la prensa informática. Sin embargo, el tamaño último del mercado, la aceptación por parte de los clientes de los sistemas y el relativo éxito de los fabricantes, siguen siendo cuestiones abiertas a resolver en los noventa.

4.1.1 CONCEPTOS Y CONSULTAS

SQL se divide en cuatro grandes categorías de servicios, los cuales son :

I. Lenguaje de definición de Datos (DDL: Data Definition Language). Consiste en comandos para definir objetos en la base como tablas, vistas, índices e integridad de datos; mediante estos comandos, el DBMS verifica que las acciones que el usuario aplica a los objetos se realicen correctamente.

II. Lenguaje de manipulación de datos (DML: Data Manipulation Language). Son comandos que le permiten al usuario seleccionar, actualizar, insertar o borrar información en la Base de Datos. Este acceso a los datos y funciones de manipulación es la razón principal de usar un DBMS.

III. Lenguaje de control de Datos (DCL: Data Control Language). Consiste en comandos que controlan la ejecución de otros comandos. Existen comandos para el manejo de concurrencia, seguridad y consistencia en la Base; por ejemplo, existen comandos que controlan la ejecución de un transacción y restauración de datos si ésta falla.

IV. Program Language Constructs. Son comandos que no pueden ser usados en un modo interactivo con SQL, éstos sólo pueden ser usados desde un lenguaje de programación externo al del DBMS. Su propósito es facilitar la interface entre SQL y los lenguajes de programación, como “C”.

La tabla 4.3 muestra los cuatro servicios que ofrece SQL, así como algunos comandos de cada uno de estos grupos.

SERVICIO COMANDOS RELACIONADOS

DDL CREATE, DROP, ALTER TABLE

DML DELETE, INSERT, SELECT, UPDATE

DCL COMMIT, ROLLBACK, GRANT, REVOKE, LOCK TABLE Program Lenguage

ConstructsBEGIN, DECLARE SECTION, EXECUTE, DECLARE CURSOR, OPEN, CLOSE, FETCH

TABLA 4.3 Ejemplos de comandos de servicios de SQL.



ARQUITECTURAS DE BASES DE DATOS

Las figuras 4.5, 4.6 Y 4.7 muestran tres arquitecturas para manejar en forma remota bases de datos; tales como: proceso por cliente (process-per-client), multihilos e híbrido.

• La arquitectura de proceso por cliente proporciona un máximo de protección de los procesos, dando a cada base de datos cliente, su propio espacio de dirección para procesos. La base de datos corre en uno o más procesos formados por separado. La ventaja de esta arquitectura es que protege a un usuario de los otros y también protege al administrador de la base de datos de los usuarios. Además, el proceso puede ser fácilmente cambiado a otro procesador o una máquina multiprocesador SNMP (Protocolo para la administración de red simple, “Simple Network Management Protocol”), ya que la arquitectura depende del sistema operativo local para los servicios de multitarea. La desventaja de proceso por cliente es que utilizan más memoria y recursos del CPU que los esquemas alternativos e incluso puede ser lento ya que los procesos se intercambian y usan IPC. Sin embargo, estos problemas pueden ser superados fácilmente con el uso de monitor de procesamiento de transacciones (TP monitor) que maneje una ronda de procesos reusables.

Proceso

Proceso

Proceso

Base de Datos

Servidor

ClientesProcesos en Servidor

Dedicado

Fig. 4.5. Arquitectura de Proceso por Cliente.

• La arquitectura multihilos ofrece la mejor ejecución corriendo todos los usuarios conectados, las aplicaciones y la base de datos en el mismo espacio de direcciones. Esta arquitectura proporciona su propio programador de tiempos que conserva memoria y capacidad de trabajo del CPU pues no requiere de intercambios frecuentes de contexto.



Base de Datos

Servidor

Clientes

Procesos Multihilos

Fig. 4.6. Arquitectura Multihilos.

Además, las implemetaciones en el servidor tienden a ser más portables entre diferentes plataformas ya que no requiere de muchos servicios del SO local. La desventaja es que un mal comportamiento de las aplicaciones del usuario puede tirar todo el servidor de la base de datos y sus tareas. Incluso, los programas de usuario que tienen una duración larga puede consumir todos los recursos del servidor. Finalmente la programación previa de tareas ofrecida por el servidor tiende a ser inferior que la del SO.

• La arquitectura híbrida consiste de tres componentes: 1) red multihilos atenta a escuchar que participe en la conexión inicial de tarea al asignar el cliente al despachador; 2) despachadores son tareas que ponen mensajes en una cola de mensajes internos y entonces toma la respuesta y la envía de regreso al cliente; y 3) El servidor de procesos reusables y compartidos que remueve los trabajos para liberarlos de la cola, los ejecuta y coloca la respuesta sobre una cola de salida. La ventaja de esta arquitectura es que ofrece un ambiente protegido para correr las tareas de usuario sin asignar un proceso permanente a cada usuario. Las desventajas son colas latentes. Esta arquitectura es en apariencia buena, su carga de balance no es tan buena como en un monitor TP; de hecho, las colas pueden estar en forma de monitores TP teniendo sus propios algoritmos de programación de tareas. El primer servidor de base de datos que implementa esta arquitectura es Oracle.



Proceso Proceso

ProcesoProceso

Proceso Proceso

Clientes

Programa Escucha

PoolDespachadorCompartido

Pool deProceso enServidor

Compartido

Colade

SolicitudRespuesta

Base deDatos

Servidor

Fig. 4.7. Arquitectura Híbrida.

4.1.2 INTEGRIDAD Y TRANSACCIONES

INTEGRIDAD DE DATOS

El término integridad de datos se refiere a mantener la consistencia y validación de los datos almacenados en una base, el contenido de ésta puede perderse de muchas formas al momento de realizar modificaciones. Ante esto, SQL cuenta con características que ayudan al DBMS en la tarea de preservar la integridad de los datos con el objeto de restringir los valores creados o insertados por actualizaciones en la base, como son:

• Datos requeridos: Impide la existencia de valores nulos en campos donde sólo se permite un valor de dato válido.

• Comprobación de validez: Sólo permite insertar valores que se encuentren definidos en el rango especificado para el campo.

• Integridad de entidad: Verifica la unicidad para claves primarias.

• Integridad referencial: Comprueba la relación que para cada llave foránea exista una llave primaria.

• Consistencia: Comprobación de que un conjunto de sentencias tengan efecto en su totalidad en la base de datos y en caso de falla (sea por Software o por Hardware) ninguna de éstas sea realizada, a estos controles se les denomina transacciones, que son tema de este inciso.

• Reglas comerciales: La actualización de datos pueden estar restringidas por reglas establecidas por las empresas. Las transacciones que se realizan en el mundo real están representadas por las actualizaciones a las bases de datos. El DBMS puede comprobar cada nuevo dato introducido, asegurándose que sus valores no violan las reglas



comerciales, estos procesos pueden ser implantados en la base a través de los eventos llamados disparadores que se explicarán más adelante.

TRANSACCIONES

SQL posibilita que la secuencia de actualizaciones a una base de datos pueda ser proposiciones “todo o nada” mediante sus características de procesamiento de transacciones.

Una transacción es un bloque secuencial de trabajo formado por una o más sentencias SQL relacionadas e interdependientes.

El DBMS basado en SQL comprueba que la secuencia de sentencias entera se efectúe asegurando la integridad de la base de datos. “O todas las sentencias son ejecutadas con éxito, o ninguna de las sentencias es ejecutada”. El manejador tiene este compromiso incluso si el programa de aplicación aborta o se produce un fallo hardware a mitad de la transacción.

A efecto de soportar las transacciones de base de datos, SQL utiliza las sentencias COMMIT y ROLLBACK ( Figura 4.8).

COMMIT: Señala el final con éxito de una transacción; informa al DBMS que todas las sentencias que forman la transacción han sido ejecutadas y la base de datos es autoconsistente.

ROLLBACK: Señala el final sin éxito de una transacción, informando que un usuario no desea completar ésta, ante esto, el DBMS debe deshacer los cambios realizados en la base a fin de restaurar a la base de datos a su estado previo al inicio de la transacción.

U P D A T E

C O M M I T

I N S E R T

D E L E T E

C O M M I T

B . D .c o n s i s t e n t e

T r a n s a c c i ó n


T r a n s a c c i ó n


U P D A T E

C O M M I T

I N S E R T

U P D A T E

C O M M I T

I N S E R T

D E L E T E

E l p r o g r a m aa c a b a

C O M M I T

I N S E R T

E l p r o g r a m aa b o r t a

( F a l l o d eH a r d W a r e )

R O L L B A C K

Fig. 4.8. Transacciones en una base de datos utilizando sentencias COMMIT y ROLLBACK



EL MODELO DE TRANSACCIÓN ANSI/ISO.

El modelo de transacción SQL (que está basado en DB2), está definido bajo el estándar ANSI/ISO, así como la función de COMMIT y ROLLBACK. El estándar especifica que una transacción SQL comienza automáticamente con la primera sentencia SQL y continúa en forma secuencial con las sentencias SQL subsiguientes hasta finalizar de uno de los cuatro siguientes modos:

Para SQL programado Para SQL interactivo

COMMIT finaliza la transacción con éxito haciendo los cambios en la base permanentes. Se inicia inmediatamente una nueva transacción después de esa sentencia COMMIT.

La terminación de un programa con éxito también finaliza la transacción correctamente; sin embargo, puesto que el programa está finalizado no hay ninguna transacción que comenzar.

ROLLBACK aborta la transacción, deshaciendo las modificaciones hechas a la base. Se inicia inmediatamente una nueva transacción después de la sentencia ROLLBACK.

La terminación anormal de un programa también aborta la transacción; pero puesto que el programa está finalizado no hay ninguna transacción que comenzar

4.1.3 VISTAS

Una vista es una tabla virtual generada por una consulta a partir de una o varias tablas, en la vista, SQL permite el acceso y modificación de los datos como si fuera una tabla real.

Una vista no existe en la base de datos, es la definición de la vista la que se almacena permanentemente en la base, al efectuar una consulta los datos visibles son el resultado de esta, ver figura 4.9

S e n t e n c i a S Q L c o nr e f e r e n c i a a u n a v i s t a

L o s r e s u l t a d o s s o np r e s e n t a d o s a l u s u a r i o .

S e l l e v a a c a b o l ap e t i c i ó n e q u i v a l e n t e .

T r a d u c c i ó n d e l a p e t i c i ó n e n l ac o n s u l t a c o n r e s p e c t o a l a st a b l a s f u e n t e s d e l a v i s t a .

D e f i n i c i ó n d e l a v i s t aa l m a c e n a d a e n l a B . D .



Fig. 4.9 Desarrollo de una Vista en SQL.

Al usar las vistas se obtiene los siguientes beneficios:

• Seguridad al mostrar solo los datos autorizados al usuario.• Simplicidad de consultas multitabla, presentadas como consultas de una sola tabla.• La estructurada de la BD no se altera ante las consultas• Integridad de datos. Comprobación de las restricciones de integridad de los datos introducidos a través de la vista.

Al crear una vista, se debe considerar que el DBMS debe traducir las consultas, con respectos a las tablas fuentes relacionadas. Para consultas complejas multitabla, la vista se convierte en una combinación complicada y puede tardar mucho tiempo en completarse. Si el usuario trata de actualizar la información en la vista, el DBMS debe traducir la petición de actualización a las tablas relacionadas en la vista, dado lo complejo de este proceso este tipo de vista son creadas de sólo lectura.

El estándar SQL ANSI/ISO, especifica las vistas que pueden ser actualizadas, en base a las consultas que las define, las cuales deben cumplir con las siguientes condiciones:

• Las filas duplicadas no deben de ser suprimidas.• Sólo una tabla fuente relacionada en la vista puede ser actualizadas siempre que el usuario tenga los privilegios requeridos.• Cada elemento de selección, debe de ser una referencia de columna simple, la lista de selección no puede contener expresiones, columnas calculadas o funciones de columna• No se puede definir una subconsulta en la cláusula WHERE.• La consulta no debe incluir GROUP BY o HAVING

Estas restricciones se pueden resumir en el siguiente concepto:

“Para que una vista sea actualizable el DBMS debe ser capaz de relacionar cualquier fila de la vista con la fila fuente. Análogamente, el DBMS debe ser capaz de relacionar cada columna individual a actualizar con su columna fuente.”

Si la vista satisface esta comprobación es posible definir operaciones INSERT, DELETE y UPDATE, y tener efecto sobre los datos fuente.

Tipos de Vistas:

• Horizontales: Muestran sólo las filas seleccionadas sobre una tabla.

• Verticales: Permiten accesar sólo a ciertas columnas seleccionadas de una tabla, cada fila de la tabla fuente está representada en la vista.

• Con subconjuntos Fila/Columna: Los datos visibles son un subconjunto de fila/columna de una tabla, contiene las columnas designadas y las filas que satisfacen una condición de búsqueda.



• Agrupadas: Agrupación de filas relacionadas, generando una fila de resultados de consulta por cada grupo y sumarizando los datos de ese grupo, en estas vistas se requiere mucho tiempo de procesamiento a efecto de mantener la tabla virtual, no se puede actualizar debido, a que no hay modo de trasladar la petición de actualización de la vista a las filas de la tabla fuente, este tipo de vistas son de sólo lectura.

• Compuestas: Extracción de datos de dos o más tablas diferentes, en la que cada fila es la combinación de una fila de cada tabla fuente, en estas vistas el tiempo de procesamiento es considerable, si la consulta llega a ser demasiado compleja, la vista se vuelve de sólo lectura.

Se pretende que todas las vistas lleguen a ser actualizadas en un tiempo mínimo de proceso, pero esto aún se encuentra en proceso de investigación.

4.1.4 SEGURIDAD

La seguridad de la información almacenada en la base de datos es especialmente importante en un DBMS basado en SQL. La implementación de un esquema de seguridad y el reforzamiento de las restricciones de seguridad son responsabilidad del Software del DBMS. El lenguaje SQL define un panorama general para la seguridad de la Base de Datos, y la sentencias SQL son utilizadas para especificar restricciones de seguridad, el cual se basa en tres conceptos principales:

• Los usuarios son los principales demandantes de la información almacenada en la Base de Datos. Cada vez que el DBMS accesa a la base de datos, para recuperar, insertar, suprimir o actualizar datos, lo hace a cuenta de algún usuario, por lo que el DBMS permitirá o prohibirá la acción dependiendo de qué usuario esteé efectuando la petición.

• Los objetos de la base de datos son los elementos a los cuales se puede aplicar la protección de seguridad. La seguridad se aplica generalmente a tablas y vistas, pero otros objetos tales como formularios, programas de aplicación y bases de datos enteras también pueden ser protegidos.

• Los privilegios son las acciones que un usuario tiene permitido efectuar para un determinado objeto de la base de datos, por ejemplo, un usuario puede tener permiso para recuperar o insertar datos en una tabla determinada, pero se le puede negar el permiso de borrar o actualizar datos. A cada usuario se le pueden dar diferentes permisos para acceder a la base de datos.

Para establecer un esquema de seguridad en una base de datos, es utilizada la sentencia SQL, GRANT y REVOKE para negar el acceso, como lo muestra el siguiente ejemplo:



G R A N T S E L E C T , I N S E R TO N L I B R O ST O J O S E

s e n t e n c i a S Q L J O S E

B a s e d eD a t o s

LI

BROS

P E R M I S O S D E :

C O N S U L T A RE I N S E R T A RD A T O S

I D E N T I F I C A D O R D EU S U A R I O

Fig. 4.10 Acceso a Usuarios a la Base de Datos.

La sentencia GRANT especifica una combinación de un identificador de usuario (ID-usuario José), un objeto (La tabla Libros) y privilegios concedidos para recuperar e insertar datos. De forma análoga, se pueden negar los accesos permitidos si se cambia la palabra GRANT por REVOKE en el ejemplo anterior.

A cada usuario de la base de datos basada en SQL se le asigna un ID-usuario, que es un nombre breve que lo identifica dentro del DBMS. Todas las sentencias SQL ejecutadas por el DBMS se llevan a cabo a cuenta de un ID-usuario específico, el DBMS, entonces, determina si el ID-usuario se le han concedido privilegios para la sentencia que ha solicitado. El estándar SQL ANSI/ISO utiliza el término ID-autorización que, técnicamente es más adecuado, la razón de que se utilice este término, es que algunos DBMS utilizan el ID-usuario que es asignado para ingresar al sistema.

Los ID-usuarios están asociados con programas o grupos de programas, más que con personas.

En ciertas bases de datos con frecuencia existen grupos de usuarios con necesidades similares. Bajo el esquema de seguridad de SQL ANSI/ISO, se pueden manejar grupos de usuarios con similares necesidades de dos formas diferentes:

1 Se puede asignar un ID-usuario único a todas las personas del grupo, esto simplifica la administración de la base de datos, ya que los privilegios de acceso a datos se asignan al único ID-usuario del grupo, pero la desventaja consiste en que las personas que comparten el ID-usuario no podrán distinguirse en las visualizaciones del operador del DBMS, ni en los informes del DBMS.

2 Se puede asignar un ID-usuario diferente a cada persona del grupo, dando la ventaja de asignar diferentes privilegios de acceso a los datos a cada usuario y distinguirlos en los informes producidos por el DBMS. Sin embargo, esto hace que la administración de la seguridad de la base de datos sea tediosa y propensa a errores.

Por lo tanto, el esquema de seguridad que se elija, dependerá particularmente de los compromisos de cada base de datos y aplicaciones para lo que hayan sido creadas.

Las protecciones de seguridad en el estándar SQL ANSI/ISO se aplican a dos objetos específicos, tablas y vistas. Así cada tabla y vista en la base de datos puede ser individualmente protegida. El acceso a una tabla o vista puede ser



permitido para ciertos ID-usuarios y prohibido para otros. El conjunto de acciones que un usuario puede efectuar sobre un objeto en la base de datos se denomina: privilegios que el usuario tiene sobre éste.

El estándar SQL ANSI/ISO especifica cuatro privilegios sobre los objetos:

1Recuperación de datos2Inserción de datos3Supresión de datos4Actualización de datos. Posibilita la restricción de columnas específicas,

permitiendo actualizaciones y desautorizando a cualquier otra columna.

Estos cuatro privilegios son soportados por casi todos los productos SQL comerciales, sin embargo, la mayoría soporta más de lo que el estándar ANSI/ISO ha definido.

Otro privilegio que es importante mencionar es el de propiedad y éste es otorgado al usuario al instante que crea un objeto (tabla o vista) en la base de datos. Quien crea un objeto en la base de datos se convierte en su propietario y recibe totales privilegios sobre éste, como son: recuperación, inserción, supresión y actualización de datos. Sin embargo, hay que tomar en cuenta que para crear una vista, hay que contar con los privilegios de recuperación de datos y sí se tienen los demás privilegios el DBMS los concederá.

Al crear un usurario un objeto, éste es el único que puede otorgar privilegios a otros usuarios para autorizar el acceso a este objeto. Por lo que los privilegios otorgados no podrán ser transmitidos por quien(es) lo(s) haya(n) recibido. De este modo, el propietario de un objeto mantiene un control muy estricto sobre quien tiene permiso para autorizar el objeto y sobre qué formas de acceso se permiten. Sin embargo, la mayoría de los productos SQL, cuentan con opciones de transmisión de privilegios en cascada, dando mayor flexibilidad del control del objeto al propietario.

4.1.5 TRIGGERS “DISPARADORES”

Antes de iniciar el tema de disparadores, es necesario mencionar algunos conceptos.

El estándar SQL ANSI/ISO utiliza la sentencia CREATE TABLE para especificar restricciones de unicidad en columnas o combinaciones de columnas. Sin embargo, los valores NULL presentan un problema cuando aparecen en la clave primaria de una tabla o en una columna que está especificada en una restricción de unicidad.

Por ejemplo, supongamos que se intentase insertar una fila con una clave primaria que fuera NULL (o parcialmente NULL, si la clave primaria está compuesta por más de una columna), debido al valor NULL, el DBMS no puede decidir concluyentemente si la clave primaria está o no duplicada con respecto a otra que ya existe. La respuesta debe ser “quizás”, dependiendo del valor “real” del dato que falta (NULL).



Por esta razón, SQL requiere que toda columna que forma parte de una clave primaria y toda columna designada en una restricción de unicidad debe ser declarada NOT NULL.

SQL también cuenta con la restricción de integridad referencial, la cual es una parte esencial del modelo relacional desde que fue propuesto por el Dr. Codd, donde se asegura la integridad de las relaciones padre/hijo, creadas mediante claves foráneas y claves primarias.

Los siguientes puntos resúmen los problemas de actualización a la base de datos que pueden corromper la integridad referencial:

• Inserción o actualización de una fila “hijo”: Cuando se inserta o actualiza una fila en la tabla hijo, su valor de clave foránea debe coincidir con uno de los valores de la clave primaria en la tabla padre.

• Supresión o actualización de una fila padre: El DBMS detecta error si se intenta borrar o actualizar una fila de la tabla “padre” a la cual se está haciendo referencia por otra fila de la tabla “hijo”.

Aunque el estándar SQL ANSI/ISO no proporciona en su totalidad la solución de los puntos anteriores, existen algunos DBMS como DB2, SQL Windows y SyBASE que incluyen el manejo de integridad referencial más completo.

Citando algunos ejemplos tenemos las siguientes cláusulas:

• RESTRICT: Impide suprimir una fila de la tabla padre si la fila tiene alguna fila hijo.

• CASCADE: Si una fila padre es suprimida, también son suprimidas todas las filas hijo.

• SET NULL: Si una fila padre es suprimida, los valores de la clave foránea en todas las filas hijo deben ser actualizadas al valor NULL.

El concepto de disparador se puede definir como: “Para cualquier evento que provoca un cambio en el contenido de una tabla, se puede especificar una acción asociada al DBMS que debe efectuar”.

Las sentencias que pueden disparar una acción son:

• INSERT• DELETE• UPDATE

La acción disparada por estas cláusulas son especificadas mediante una secuencia de sentencias SQL, como lo muestra el siguiente ejemplo:

CREATE TRIGGER NUEVO PEDIDO

ON PEDIDOSFOR INSERTAS UPDATE REPVENTAS

SET ventas = ventas + Inserted.importe



FROM Repventas , InsertedWHERE Repventas.num_empl = Inserted.rep

UPDATE ProductosSET existencias = existencias - Inserted.cant

FROM Productos , InsertedWHERE Productos.id_dir = Inserted.fab

AND Productos.id_producto = Inserted.producto

Otras extensiones no mostradas en el ejemplo incluyen sentencias IF/THEN/ELSE, iteraciones, llamadas de procedimiento, e incluso sentencias PRINT que visualizan mensajes de usuario.

Los disparadores proporcionan un modo alternativo de implementar las restricciones de integridad referencial, proporcionadas por claves foráneas y primarias. De hecho los defensores de esta característica, señalan que el mecanismo disparador es mucho más flexible que la integridad referencial proporcionada por algunos DBMS e incluso por el estándar SQL ANSI/ISO.

La principal ventaja de los disparadores, es que las reglas comerciales pueden almacenarse en las bases de datos y ser forzadas consistentemente con cada actualización que tengan. Esto puede reducir substancialmente la complejidad de los programas de aplicación que acceden a la base de datos. Sin embargo, algunas desventajas son:

• Complejidad de la Base de Datos: Cuando las reglas se trasladan al interior de la base, prepararla, pasa a ser una tarea más compleja. Los usuarios que razonablemente podían esperar crear pequeñas aplicaciones propias con SQL, encontrarán que la lógica del programa de los disparadores hace la tarea mucho más difícil.

• Reglas Ocultas: Con las reglas ocultas dentro de la base de datos, programas que parecen efectuar sencillas actualizaciones, pueden de hecho, generar una enorme actividad en la base. El programador ya no controla totalmente lo que sucede en la base de datos.

Los disparadores están ausentes del estándar SQL ANSI/ISO, aunque algunos vendedores de DBMS han proclamado públicamente planes para añadir las características de los disparadores a las versiones futuras de sus productos, la importancia futura es un poco nebulosa y solamente el tiempo dirá si se convierten en parte importante del entorno SQL.



Conclusiones

La arquitectura computacional C/S es la primera solución en tecnología informática que satisface las demandas actuales de costo-rendimiento, ofreciendo la optimización de las tareas existentes y agregando nuevas funcionalidades. Es por eso que se observa una clara tendencia ha implementar este modelo. Siendo sus ventajas, que la capacidad de cómputo está determinada por todos los equipos interconectados con que se cuenta, agregación de nuevas funcionalidades y una considerable reducción de tráfico en la red, ya que las operaciones de procesamiento se jerarquizan y la red da prioridad a las necesidades del usuario, transmitiéndole información realmente útil. Esto constituye un estimulo al uso de sistemas abiertos dado que tanto clientes como servidores operan en diferentes plataformas de hardware y software, lo cual permite comprar productos de diferentes proveedores sin interferir en el desempeño de las demás aplicaciones y equipos instalados.

Las cualidades que ofrece esta arquitectura son interesantes y muy convincentes, pero esto no significa que sea perfecta, sobre todo cuando lo que se persigue es la integración plena de ambientes heterogéneos, por lo cual se enfrenta a :

• Las diferentes capas de software de interoperabilidad (middleware) pueden afectar en la duplicidad de tareas.• Muchas aplicaciones no son capaces de separar tareas por lo que el comportamiento en la red será el de una arquitectura tradicional.• Se requiere de una evaluación y planeación completas de la arquitectura C/S para minimizar el tráfico y evitar la saturación del medio de comunicación. Aspecto que una aplicación C/S bien diseñada si prevé.• Como la administración de este ambiente es más complicada, los procesos y herramientas al conectar equipo pueden complicar ampliamente las labores de administración y control.• El personal que se requiere para dar soporte y administrar el ambiente seguramente tendrá que incrementarse. Primero porque al ser un medio abierto se requiere más personal. Segundo porque al tratarse de medios abiertos se requieren más especialistas con conocimientos en diversas tecnologías. Además los costos de mantenimiento también se elevan, pues cada versión de una aplicación C/S se deberá probar en diferentes plataformas.

Todos estos obstáculos se pueden contrarrestar y quizá las grandes ventajas que ofrece un ambiente abierto sean de mayor peso para emigrar a esta arquitectura.

Es importante recordar que la Tecnología C/S siempre tiene que ver con redes, lo contrario sería falso, es decir no todas las redes trabajan bajo la arquitectura C/S. Esta pequeña pero importante diferencia abre una brecha enorme en el tipo de productos o servicios que el usuario puede adquirir para aprovechar su equipo. El conocer el verdadero significado del concepto es de trascendental importancia para quien desea tener una solución productiva y debe cuidar que quien lo vende, o le asesora, realmente le ofrezca una arquitectura C/S.



I.2 Nomenclatura de Objetos

Prefijos de ControlesTipo de Control Prefijo Tipo de Control Prefijo Tipo de Control

3D Panel pnl_ Horizontal scroll bar hsb_ Picture clipADO Data ado_ Image img_ ProgressBarAnimated button ani_ Image combo imgcbo_ Remote Data ControlCheck box chk_ ImageList ils_ RichTextBoxCombo box, drop-down list box cbo_ Label lbl_ ShapeCommand button cmd_ Lightweight check box lwchk_ SliderCommon dialog dlg_ Lightweight combo box lwcbo_ SpinCommunications com_ Lightweight command button lwcmd_ StatusBarControl (usado para objetos genéricos)

ctr_ Lightweight frame lwfra_ SysInfo

Data dat_ Lightweight horizontal scroll bar lwhsb_ TabStripData-bound combo box dbcbo_ Lightweight list box lwlst_ Text boxData-bound grid dbgrd_ Lightweight option button lwopt_ TimerData-bound list box dblst_ Lightweight text box lwtxt_ ToolbarData combo dbc_ Lightweight vertical scroll bar lwvsb_ TreeViewData grid dgd_ Line lin_ UpDownData list dbl_ List box lst_ Vertical scroll barData repeater drp_ ListView lvw_ GraphDate picker dtp_ MAPI message mpm_ GridDirectory list box dir_ MAPI session mps_ Hierarchical flexgridDrive list box drv_ MCI mci_ OLE containerFile list box fil_ Menu mnu_ Option buttonFlat scroll bar fsb_ Month view mvw_ Picture boxForm frm_ MS Chart mch_ Remote Data ObjectsFrame fra_ MS Flex grid mfg_ Data Acces ObjectsGauge gau_ MS Tab mst_ ActiveX Data Objects



Prefijos para MenúsSecuencia de Menú Ejemplo de Menú

Archivo mnu_ArchivoArchivo Abrir mnu_ArchivoAbrirArchivo envíar correo mnu_ArchivoCorreoArchivo envíar fax mnu_ArchivoFaxFormato carcater mnu_FormatoCaracterAyuda mnu_Ayuda

Nombres de Prefijos para otros ControlesPara otros controles no listados, se deberán estandarizar utilizando sólo letras minúsculas y el guión bajo. Procurando sólo utilizar tres letras en los casos que el nombre sea descriptivo.



I.3 Convenciones de nombres de variables para Visual Basic

Los nombres de variables estarán determinados por el ámbito de la variable y el tipo.1. Ambito de la variable.

Ambito PrefijoGlobal gModular mLocal lParámetro p

2. Tipos de datos.

Tipo de dato Prefijo Bytes Rango EjemploBoolean bln 2 True o False blnExisteByte byt 1 0 – 255 bytColorCollection object col - - colForma

Currency cur 8-922,337,203,685,477.5808 a 922,337,203,685,477.5807

curPago

Date (Time) dtm 8 01/01/100 a 31/12/9999. dtmNacimiento

Double (Precisión de punto flotante)

dbl 8

Para valores negativos:-1.79769313486232E308 a -4.94065645841247E-324 Para valores positivos:4.94065645841247E-324 a 1.79769313486232E308

dblArea

Decimal dec 14

Sin punto decimal +/-79,228,162,514,264,337,593,543,950,335El valor más pequeño es: +/-0.0000000000000000000000000001

decPIB

Error err - - errNumeroInteger int 2 -32,768 a 32,767 intCantidadLong (Integer) lng 4 -2,147,483,648 a 2,147,483,647 lngDistanciaObject obj 4 Cualquier referencia a un objeto objActual

Single (Precisión de punto flotante)

sng 4

Para valores negativos:-3.402823E38 a -1.401298E-45 Para valores positivos:1.401298E-45 to 3.402823E38

sngPromedio

String (Longitud variable)

str

10 + longitud de la cadena

0 a 2 billonesstrApellido

String (Longitud fija)

strlongitud de la cadena 1 a 65,400

strApellido

Tipo definido por el usuario

udt- Dependiendo del tipo de dato asignado

udtEmpleado

Variant vnt 16 Dependiendo del tipo de dato asignado vntSuma



3. Forzar que Visual Basic verifique la declaración de VariablesDeclarar todas las variables reduce el tiempo de programación y los errores causados por incompatibilidad de tipos. VB permite utilizar variables sin que previamente hallan sido declaradas. Para forzar que VB detecte las variables que no hallan sido declaradas realice lo siguiente.

i. Seleccione la opción del menú : Tools\Options...ii. Se despliega un dialogo con distintas pestañas.iii. Seleccione la pestaña de : Editor iv. Marque la casilla de “Require Variable Declaration”

Esto forzará a que VB detecte las variables que no hallan sido declaradas en toda la aplicación.

4. Creación de nombres de Variables El nombre de una variable debe ser descriptivo, para formar el nombre siga los siguientes pasos:

i. Primera letra : Determine el ámbito de la variable (global, modular o local).

ii. Siguientes letras minúsculas : Determine el tipo de la variable.iii. Primera letra mayúscula : Inicio del nombre de la variable.iv. Siguientes letras minúsculas : Complemente el nombre de la variable.

Ejemplo : ldtmNacimento Donde l = Ambito de lavariable local.dtm = Tipo datetime.Nacimiento = Nombre de la variable.

Ejemplo : gstrLogin Donde g = Ambito de la variable globalstr = Tipo string (cadena)Login = Nombre de la variable.

Notas: Los tipos definidos por el usuario deberán ajustarse a las nomenclaturas antes mencionadas. 5. Definición de constantes

i. El nombre debe comenzar con el prefijo: CTE_ii. El nombre estará en mayúsculas.iii. El nombre deberá ser descriptivo y podrá contener guión bajo “_”.iv. Ejemplo: CTE_ARREGLO_INDICEMAXIMO = 32532

6. Definición de arreglosi. El nombre debe comenzar con el ambito de la variable: g,m,l o pii. Prefijo de la variable: arriii. Aplicar la nomenclatura de tipos de datos para el arreglo.iv. Nombre de la variable del arreglo (primera letra con mayúscula)v. Ejemplo: marrblnPreguntas ;

m = Ambito de la variable modular.arr = Arreglo.bln = Tipo del arreglo boleanoPreguntas = Nombre de la variable.

Los tipos de datos definidos como arreglos requieren 20 bytes de memoria más 4 bytes por cada dimensión del arreglo, más los bytes ocupados por el tipo de dato mismo.

7. Nomenclatura de parámetros.



Los parámetros deberán iniciar con el prefijo p y la composición del nombre de la variable deberá ajustarse a la nomenclatura de tipos de datos.


Documents

Visual Basic 6-Manual Completo