Bases de datos con Delphi 1. Introducción Cuando queramos desarrollar una aplicación con Delphi que dé acceso a una base de datos, no debemos perder nunca este doble punto de vista: la aplicación será, por una parte, cliente de un servidor de base de datos y, por otra parte, será el interface de usuario de la base de datos, para todas las tablas o sólo para algunas (eso ya depende de la amplitud de la aplicación con respecto al total de los datos). Debemos centrarnos en un buen diseño de la aplicación, pues esto facilita al usuario la edición de datos, y a nosotros, como programadores, el mantenimiento, sea como sea de complejo el modelo de datos sobre el que trabajemos. Para ello, debemos conocer muy bien tanto el modelo de datos de la base de datos, como la filosofía de trabajo con bases de datos en Delphi. En este curso vamos a preocuparnos, lógicamente, de la filosofía de trabajo con Delphi. Delphi utiliza un intermediario para conectar con la base de datos: se llama BDE (Borland Database Engine). Puede conectar con diversos tipos de bases de datos de forma directa (Interbase, Paradox, Informix, ...) o bien a través de ODBC. Así pues, es el BDE el que realiza el trabajo duro de "hablar" con el servidor de base de datos, quedándonos a nosotros una tarea mucho más sencilla: poder olvidarnos de cómo es la estructura interna (a nivel de estructura de ficheros) de la base de datos, centrándonos en las tablas como idea y en el diseño de las consultas. Hay un concepto clave para todo esto: el concepto de alias. Se trata de un nombre lógico (que no tiene por qué coincidir con el nombre del fichero físico de la base de datos) con el que Delphi reconocerá a la base de datos. Así, creamos un alias para la base de datos, y desde Delphi no tendremos que preocuparnos de la ruta. Especificaremos estos datos previamente accediendo directamente al BDE Administrator desde el panel de control, o bien usando la utilidad SQL Explorer. En los anexos se detalla cómo hacerlo. Delphi separa en dos grupos los componentes de bases de datos: los componentes de acceso a datos (que se encuentran en la pestaña Data Access) y los componentes visuales que muestran datos (en la pestaña Data Controls). La filosofía es separar el contenido de la forma. Así, en los componentes visuales especificaremos cómo queremos que el usuario vea los datos, y en los componentes de acceso a datos programaremos cómo obtener los datos que necesitamos. Hay un componente muy específico que enlazará nuestro acceso a datos con nuestra visualización de datos, y que es el que se encargará de proveer al control visual de los datos que genera el control no visual de acceso a datos.

2.i. Descripción rápida de Data access Comenzamos dando una primera mirada a los componentes de la paleta Data access que trataremos en este curso. Todos estos componentes son no visuales y permiten que los datos lleguen a la aplicación.

Paleta DATA ACCESS

TDatabase Encapsula una conexión cliente/servidor a una única base de datos. A pesar de que si no incluimos un componente de este tipo, Delphi usa uno de forma temporal, será conveniente empezar dando a nuestra aplicación uno o más componentes de este tipo para poder añadir algunos parámetros adicionales. TTable

Representa un conjunto de datos que recupera todas las columnas y registros de una tabla de la base de datos. Tiene propiedades y métodos que nos permiten movernos por el conjunto de datos y encontrar datos que cumplan un determinado patrón de búsqueda.

TQuery Representa un conjunto de datos que recupera un subconjunto de columnas y registros de una o más tablas de bases de datos basadas en una consulta SQL. Al igual que TTable, tiene propiedades y métodos que nos permiten movernos entre los datos y escoger aquellos que cumplan ciertas características requeridas por la aplicación. TStoredProc Representa un conjunto de datos que recupera uno o más registros de una tabla de base de datos basándose en un procedimiento almacenado definido para un servidor de base de datos. Sólo tiene sentido usarlo cuando la base de datos soporta esta característica. TDataSource Actúa como un conducto entre otros componentes de acceso a datos y controles visuales de datos. Es el encargado de que los datos de componentes como TTable, TQuery y TStoredProc puedan mostrarse de forma cómoda para el usuario en los controles visuales de datos. La paleta Data access tiene algunos componentes más, pero con los que describiremos en este curso, hay más que suficiente para hacer aplicaciones medianas-grandes.

2.ii. Descripción rápida de Data controls Ahora le toca el turno a los componentes de visualización de datos:

Paleta DATA CONTROLS

TDBGrid Muestra y edita registros de conjunto de datos en formato de tabla. Puede ser la tabla completa o sólo algunas de las columnas. TDBNavigator

Mueve el cursor a través de registros de un conjunto de datos, permite editar e insertar registros, almacena los registros modificados o nuevos, cancela el modo de edición y actualiza la visualización de datos. Permite una cómoda navegación por conjuntos grandes de registros. TDBText Muestra un campo como si fuera una etiqueta. TDBEdit Muestra y edita un campo en un cuadro de edición. TDBListBox Muestra una lista con opciones para introducir un campo. TDBComboBox Muestra un cuadro de edición y una lista desplegable de elecciones para editar y entrar en un campo. TDBCheckBox Muestra y configura una condición de campo booleana en un cuadro de comprobación. TDBRadioGroup Muestra y configura opciones únicas para un campo de un grupo de botones de radio. TDBLookupListBox Muestra una lista con opciones derivadas de un campo en otro conjunto de datos para entrar en un campo. TDBLookupComboBox Muestra un ComboBox de opciones derivada de un campo de otro conjunto de datos para introducirlos en un campo

3. Módulos de datos Antes de comenzar a detallar los componentes que usaremos, vamos a hablar de esta peculiar característica de Delphi. Un módulo de datos es una clase especial de Delphi que se usa para la gestión centralizada de componentes no visuales de una aplicación. Generalmente incluye componentes para el acceso a datos (como TDatabase, TTable, TQuery, ...), pero también puede incluir otros componentes no visuales (como TTimer, TOpenDialog, TImageList, etc). Un módulo de datos nos permite:

• • •

Mantener todos los componentes de acceso a datos en un solo contenedor visual en modo de diseño, en lugar de duplicarlos para cada form de la aplicación Diseñar tablas y consultas una sola vez y usarlas en varios forms, en lugar de crearlas por separado para cada form. Guardarlo en el Object Repository para poder reutilizarlo.

La centralización de recursos para la aplicación quizá sea una de las características más interesantes. Por ejemplo, un cuadro de diálogo de apertura de ficheros es un recurso candidato a ser centralizado. Si tenemos una aplicación con 10 forms que necesiten de un cuadro de diálogo, tenemos dos opciones, crear 10 componentes, uno para cada form, o crear un único componente de cuadro de diálogo y usarlo en los 10 forms.

El método de trabajo que usaremos será el de crear los componentes no visuales en un módulo de datos, y usarlo en todas las units que lo requieran. Así lo tendremos disponible para toda la aplicación sin tener que repetirlos. Además, alteraremos el orden de creación de forms en el proyecto, entrando en Auto-create forms de las opciones del proyecto, situando en primer lugar a nuestro módulo de datos. Haremos esto por lo siguiente: asociaremos al evento onCreate código para abrir la conexión con la base de datos, estando así disponible desde el principio de la aplicación y no después de crearse el form principal. Así, nos evitaremos problemas en el caso de que antes de que se muestre el form principal sea necesario realizar alguna operación con la base de datos. Los módulos de datos se encuentran en Delphi accediendo a New -> Data Module, dentro de la pestaña por defecto, New. Nuestra aplicación puede usar cuantos necesite. Puede ser buena idea, incluso, usar distintos módulos de datos, atendiendo a finalidades distintas, para poner en ellos los componentes no visuales, agrupados por esta finalidad.

4.i. TDatabase El componente TDatabase nos va a permitir:

• • • •

Crear conexiones persistentes a bases de datos (esto es, permaneceremos conectados a la base de datos siempre que el componente tenga especificado que debe estar conectado). Personalizar el acceso a servidores de bases de datos. Por ejemplo, solicitar o no una contraseña de acceso al conectar con la base de datos. Controlar las transacciones y especificar sus niveles de aislamiento (aunque en este curso no vamos a hablar de transacciones). Crear alias BDE locales de aplicaciones. Esto es especialmente útil por lo siguiente: supongamos una aplicación que debe funcionar con una base de datos en una determinada ruta. Todos los componentes de acceso a datos que necesite la aplicación, deben estar ligados a esa base de datos vía el alias. Si, por algún motivo, cambia el alias, entonces tendríamos que cambiarlo a todos los componentes de acceso a datos. Teniendo definido un alias local, asociaremos a los componentes de acceso a datos el alias local, y así, en caso de que haya que cambiar algo, sólo tendremos que hacerlo en el componente TDatabase.

Vamos a estudiar las propiedades más importantes de este componente:

AliasName

El valor de esta propiedad será el alias BDE asociado. Delphi nos presentará un menú desplegable con los alias definidos en el sistema. De ahí será de donde tendremos que escoger uno. Si damos un valor a la propiedad DriverName entonces se elimina el valor dado a esta propiedad.

DriverName

Identifica al controlador BDE del componente (esto forma parte del alias). Es autoexcluyente con AliasName, como hemos visto.

Connected

Es un booleano que nos dice si estamos conectados o no a la base de datos.

DatabaseName

Es el alias local a la aplicación que damos al componente. No es necesario, pero sí recomendable darle uno.

LoginPrompt

Es un booleano que nos dice si se debe solicitar o no un nombre de usuario y su contraseña la primera vez que se vaya a acceder a la base de datos. Si le damos el valor False tendremos que especificar estos valores en la propiedad Params

Params

Se trata de una lista con los parámetros de acceso para la conexión.

Params En el inspector de objetos, al situarnos sobre la propiedad Params, podemos hacer doble click con el ratón, con lo que se abre la siguiente ventana:

En ella escribiremos lo siguiente:

USER NAME=ElNombreDelUsuario PASSWORD=LaClaveDelUsuario

cuando pongamos a False el valor de la propiedad LoginPrompt

Resumiendo: Cuando vayamos a realizar una aplicación de base de datos, comenzaremos creando un form de módulo de datos (un DataModule) en el que incluiremos el componente TDatabase. Pondremos los valores oportunos en sus propiedades, y le daremos un valor a la propiedad DatabaseName para tener definido un alias local. Veremos en los siguientes capítulos la utilidad de ese alias local. Para poder asociar a los componentes de acceso a datos este alias local, tendremos que estar conectados a la base de datos. En tiempo de diseño podremos conseguirlo poniendo el valor de la propiedad Connected a True. En tiempo de ejecución también podemos acudir al método Open del componente. Será conveniente protegerlo con un bloque try .. except por si se produjera algún problema en la apertura de la base de datos.

4.ii. TDataSet Este componente es el que encapsula los datos de una base de datos. No debemos usarlo directamente en nuestras aplicaciones. Para ello, tenemos a sus descendientes, los componentes de acceso a datos TTable, TQuery y TStoredProc. Sin embargo, debemos conocer bien este componente, pues es el que nos prové de propiedades y métodos comunes a sus descendientes, fundamentales para el acceso a datos. Además, cada conjunto de datos debe tener asociado su componente TDataSource correspondiente, que es el que vincula los controles de datos visuales con los conjuntos de datos. El componente de fuente de datos es el que se encarga de canalizar los datos desde el componente de acceso a datos al componente visual. Así que vamos a comentar las características interesantes que nos ofrece este componente (recordemos que serán comunes a sus descendientes): En primer lugar, tenemos que saber cómo abrir y cerrar conjuntos de datos. Mientras un conjunto de datos esté cerrado, no podremos extraer datos de él. Esto se traduce en que los componentes visuales que estén asociados a él (vía un TDataSource) no mostrarán datos. Así, cuando esté abierto, sí se podrán ver los datos, e igualmente se podrá recorrer las distintas filas que pueda contener. Por tanto, para abrir el conjunto de datos tenemos dos posibilidades que son equivalentes:

CompDescDeTDataSet.Active := True;

{ diseño y ejecución }

CompDescDeTDataSet.Open;

{ ejecución }

Y para cerrarlo tenemos otras dos, igualmente equivalentes:

CompDescDeTDataSet.Active := False; { diseño y ejecución } CompDescDeTDataSet.Close;

{ ejecución }

Si hay que modificar alguna propiedad del conjunto de datos que afecte a la consulta, es necesario cerrar ANTES dicho conjunto. Vamos a ver ahora cómo nos desplazamos por conjuntos de datos: Cada conjunto de datos tiene un cursor (es decir, un puntero que apunta a la fila ACTUAL del conjunto). Dicha fila corresponde a los valores que pueden manipularse vía métodos de edición/inserción/borrado, y cuyos valores de campo muestran actualmente controles de dato monocampo, como TDBEdit o TDBText. Disponemos de los siguientes métodos para desplazarnos por conjuntos de datos: First

Desplaza el cursor a la primera fila del conjunto de datos

Last

Desplaza el cursor a la última fila del conjunto de datos

Next

Desplaza el cursor a la fila siguiente del conjunto de datos

Prior

Desplaza el cursor a la fila anterior del conjunto de datos

MoveBy(NumFilas: Integer)

Desplaza el cursor un número dado de filas del conjunto de datos, hacia delante si NumFilas es positivo, y hacia atrás si NumFilas es negativo

El objeto TDataSet cuenta además con las propiedades:

BOF (beginning of file) Es TRUE si:

• • • •

Se Se Se Se

abre el conjunto de datos llama al método First del conjunto de datos llama a Prior y falla (porque el cursor ya está en la primera fila) llama a SetRange en un rango o conjunto de datos vacío (no veremos SetRange)

Es FALSE en todos los demás casos.

EOF (end of file) Es TRUE si:

• • • •

Se Se Se Se

abre un conjunto de datos vacío llama al método Last del conjunto de datos llama a Next y falla (porque el cursor ya está en la última fila) llama a SetRange en un rango o conjunto de datos vacío (no veremos SetRange)

Es FALSE en todos los demás casos.

Marcadores Un marcador es un objeto que nos va a permitir marcar una posición concreta del conjunto de datos, de manera que si nos movemos después por dicho conjunto, podamos más adelante volver a esta posición marcada. Para ello, Delphi cuenta con tres métodos marcador que permiten asignar un indicador a un registro de un conjunto de datos para volver al mismo posteriormente (es decir, marcamos una posición concreta):

• • •

GetBookmark: asigna un marcador a la posición actual en el conjunto de datos GotoBookmark: volver a un marcador creado previamente con GetBookmark FreeBookmark: libera un marcador creado previamente con GetBookmark

Para crear un marcador es necesario declarar una variable de tipo TBookmark. Se trata de un puntero, así que tanto para liberarla definitivamente como para usarla para marcar otro registro, hemos de llamar a FreeBookmark. Por ejemplo:

PROCEDURE HazAlgo(CONST Tbl: TTable);

VAR B: TBookmark; BEGIN B := Tbl.GetBookmark; Tbl.DisableControls;

TRY Tbl.First; WHILE NOT Tbl.EOF DO BEGIN { Proceso } Tbl.Next; END;

FINALLY Tbl.GotoBookmark(B); Tbl.EnableControls; Tbl.FreeBookmark(B); END; END;

Este código consta de un procedimiento al que le pasamos como argumento un objeto de tipo TTable (uno de los descendientes de TDataSet). Declaramos una variable de tipo TBookmark y marcamos la posición actual de la tabla (será la que estuviera apuntada en ese momento por el cursor, no tiene por qué ser la primera). Nos vamos al principio de la tabla (usando el método First) y mientras no lleguemos al final (usando la propiedad EOF), procesamos lo que haya que procesar de la fila actual, y avanzamos el cursor (usando el método Next). Terminado el proceso, volvemos a la posición marcada inicialmente y liberamos el marcador. Todo esto va englobado dentro de un bloque TRY ... FINALLY porque hemos de asegurarnos de que el marcador se libera. Nuestro proceso podría dar lugar a una excepción, así que hemos de ser cuidadosos. Para buscar datos dentro de un conjunto de datos usaremos la siguiente función:

FUNCTION TDescDeTDataSet.Locate('Campo; ...; Campo', VarArrayOf([Valor1, ..., ValorN]), SearchOptions): Boolean;

Especificamos los campos, los valores a buscar como un array de variants (por eso he puesto que el segundo parámetro es VarArrayOf, pero si hubiera un único campo no haría falta convertirlo a array de variant) y un conjunto de opciones de búsqueda que podeis consultar en la ayuda. Devuelve si ha tenido éxito o no con la búsqueda. De todas formas, cuando veamos el

componente TQuery, casi con toda seguridad no le encontraremos mucha utilidad a esta función, pues en el componente TQuery podremos restringir la selección de datos tanto como queramos usando sentencias SQL.

Modificación de datos del conjunto de datos Otro punto importante es saber cómo modificar los datos existentes en un conjunto de datos. Para ello, contamos con los siguientes métodos: Edit Asigna al conjunto de datos el estado dsEdit, si es que el conjunto no está ya en ese estado, o si está en modo dsInsert. Entonces, podremos editar datos. Append Almacena los datos pendientes, desplaza el registro actual al final del conjunto de datos, y asigna al conjunto de datos el estado dsInsert. Insert Almacena los datos pendientes y asigna al conjunto el estado dsInsert. Post Intenta almacenar el nuevo registro, o modificar el registro existente, en la base de datos. Si hay éxito, se asigna al conjunto de datos el estado dsBrowse. Si no, se mantiene el estado. Cancel Cancela la operación actual y asigna al conjunto el estado dsBrowse. Delete Elimina el registro actual y asigna al conjunto de datos el estado dsBrowse. Por ejemplo:

Tbl.Edit; Tbl.FieldValues['Campo'] := Valor; Tbl.Post;

Ponemos la tabla para editar, usamos la propiedad FieldValues para acceder al campo Campo, y almacenamos en este campo el valor Valor. A continuación, usando el método Post cerramos la edición, almacenándose los datos. Previo al estudio de los descendientes de TDataSet será necesario estudiar los componentes de campo, que se engloban en el objeto TField. Este objeto da formas de acceder a los campos individuales de un conjunto de datos. Todos los componentes de conjunto de datos cuentan con tantos objetos TField como campos tenga la tabla/consulta/etc. Los veremos en capítulo aparte. Dentro del objeto TDataSet, hay un evento que cabe destacar, el evento OnCalcFields, que nos sirve para decidir los valores de los llamados campos calculados en función de los valores de los campos normales. Si la propiedad AutoCalcFields del conjunto de datos es TRUE, entonces se produce un evento OnCalcFields si:

• • •

Hay un conjunto de datos abierto El foco se desplaza de un componente visual a otro, o de una columna a otra en un TDBGrid (rejilla de datos) Se recupera un registro de la base de datos

Si el valor de un campo no calculado cambia, se llama a este evento independientemente de si AutoCalcFields es TRUE o FALSE. Veremos en el capítulo dedicado a TField qué es un campo calculado, y qué es un campo no calculado. Hay que tener cuidado con este evento y no llamar a Post dentro del código del manejador del evento: aunque AutoCalcFields es FALSE, OnCalcFields es llamado si hay un Post. Hacer Post en el evento sería recursivo y habria desbordamiento de pila. ¿Resulta confuso todo esto? Quizá un poco. Hay que tener en cuenta que llegados a este punto aún no hemos visto cómo llevar a la práctica este componente que no vamos a tratar directamente, ni cómo usarlo exactamente, ni cómo podemos mostrar los datos, ni... No hay que olvidarlo: no usaremos este componente sino sus descendientes, y todo lo que hemos visto aquí es puramente teórico pero imprescindible para avanzar. Es en los siguientes capítulos donde se empieza a manipular de lo que se habla aquí.

4.iii. TDataSource Se trata de un componente de base de datos no visual que sirve de conducto entre un conjunto de datos y un componente de visualización de datos en un form. Es necesario que cada control de datos esté asociado a un componente TDataSource para poder manipular y visualizar los datos.

Propiedades interesantes DataSet Especifica el nombre del conjunto de datos del que este componente obtiene los datos. Puede también asignarse a un conjunto de datos de otro form para sincronizar los componentes de visualización de datos de los dos forms. Enabled Nos dice si está conectado a un conjunto de datos. AutoEdit Especifica si los conjunto de datos conectados al TDataSource entran automáticamente en modo Edit cuando el usuario empieza a introducir los componentes de visualización vinculados al conjunto de datos.

Eventos interesantes OnDataChange Este evento se da cada vez que el cursor se desplaza a un nuevo registro. Si se llama al método Next, Previous, Insert o cualquier otro que implique un cambio de posición del cursor, se llamará a este evento. OnUpdateData Se produce cada vez que los datos están a punto de actualizarse, es decir, tras llamadas a Post pero antes de que los datos se almacenen definitivamente en la base de datos. OnStateChange Se produce cada vez que cambia el estado del conjunto de datos asociado al TDataSource. Veremos su utilidad cuando estudiemos los componentes gráficos, pues es en ese momento cuando hay que elegir un descendiente adecuado de TDataSet, asociarle un TDataSource para, en el componente gráfico, asociar el mismo TDataSource. Entonces tendremos conectados el componente gráfico con el TDataSet vía el TDataSource.

4.iv. TField: Uso de campos Vamos a ver en este capítulo un objeto muy importante y útil, el objeto TField. Este objeto representa columnas de bases de datos individuales en conjuntos de datos. No lo usaremos directamente en nuestras aplicaciones, sino que emplearemos sus componentes descendientes. Cada uno de ellos representa un tipo de dato distinto en una columna del TDataSet correspondiente al componente de conjunto de datos. Estos tipos son: Nombre del componente Nombre del componente Nombre del componente TStringField

TSmallIntField

TIntegerField

TBooleanField

TFloatField

TCurrencyField

TDateField

TTimeField

TDateTimeField

TVarBytesField

TBlobField

TMemoField

TWordField

TBCDField

TBytesField

TGraphicsField

TAutoIncField

TNumericField

Este componente no es visual, y tampoco está visible en tiempo de diseño. Los TField están asociados a un componente de conjunto de datos y dan a componentes de datos como TDBGrid acceso a ciertas columnas de bases de datos vía ese conjunto. Aunque se verá más adelante, voy a intentar explicar esto de forma más inteligible. Como ya sabemos, en una aplicación de base de datos tenemos, por una parte, componentes visuales que mostrarán los datos y nos dejarán cambiarlos y, por otra parte, componentes no visuales que obtienen los datos a mostrar. En medio tenemos a TDataSource, que es el conducto entre unos y otros, el que realiza el paso efectivo de la información. Podemos tener un control visual en que queramos mostrar varias columnas fijas de una determinada consulta. Bien, pues TField va a ser nuestro aliado. Definiremos lo que se llaman campos persistentes que podrán ser referenciados desde el componente visual para poder fijar las columnas a mostrar. Lo iremos viendo poco a poco. Al abrirse un conjunto de datos, se genera un componente de campo para cada columna de datos de la tabla o consulta correspondiente. Delphi usa BDE para determinar el tipo correcto de componente de campo que se debe asignar a cada columna (los que hemos visto en la tabla). Este tipo, además, determina las propiedades del campo así como cómo debe mostrarse. Por ejemplo, si se da el caso de que para una columna se genera un TFloatField, entonces tendremos una propiedad que nos permitirá decirle el formato que queremos de visualización. Si es, por ejemplo, de dos decimales, este formato sería 0.00#. También podríamos fijar el número de dígitos a mostrar. Es sólo un ejemplo. Como veremos, los componentes de campo tienen propiedades comunes, y luego habrá otras específicas del tipo de campo que sea. En modo de diseño, estos componentes se crean de forma dinámica si el correspondiente conjunto de datos tiene a True su propiedad Active. En tiempo de ejecución también se generan de forma dinámica. No obstante, es recomendado crear componentes de campo persistentes. Si, por ejemplo, tenemos un control TDBGrid que se basa en una estimación del número de campos, al añadir uno nuevo la aplicación podría responder de forma "extraña". Pero si el número de campos viene definido de antemano, estos problemas no se dan. Estos campos definidos "de antemano" son los que llamamos campos persistentes. Entre otras ventajas, nos ofrecen las siguientes:

•

Restricción de los campos del conjunto de datos a un subconjunto de las columnas disponibles en la base de datos correspondiente.

• • •

Definición de nuevos campos basándose en columnas de la tabla o consulta correspondiente al conjunto de datos. Definición de campos calculados. Modificación de las propiedades de edición y visualización de los componentes de campo.

Con los componentes de campo persistentes tenemos garantizado que cada vez que se ejecute la aplicación se usarán y mostrarán las mismas columnas, en el mismo orden, incluso si ha cambiado la estructura física de la base de datos.

Cómo se crean Para crearlos usaremos el editor de campos. Se inicia haciendo doble click sobre un componente de conjunto de datos (un descendiente de TDataSet). Presenta el siguiente aspecto:

También podemos acceder a él pulsando con el botón derecho del ratón sobre el componente de conjunto de datos y escogiendo la opción "Fields Editor" que se nos mostrará en el menú contextual. Notar que en la barra de título pone NombreForm.NombreComponenteConjuntoDeDatos. Ahora tenemos que añadir aquí los campos que queramos que sean persistentes. Para ello, pulsamos con el botón derecho del ratón sobre el Editor de Campos, con lo que aparece el menú:

Entonces nos aparece una lista con todos los campos disponibles. Por ejemplo:

Los campos que nos aparecen son los correspondientes a la tabla seleccionada (si elegimos como componente conjunto de datos TTable) o a la consulta SQL (si elegimos TQuery). En este ejemplo, los campos son los resultantes de una consulta SQL en un componente de tipo TQuery. Si no termináis de verlo claro, en el ejemplo desarrollado de la agenda iremos viendo paso a paso qué es lo que debemos hacer y por qué. Podemos crear nuevos campos o eliminar campos que hayamos puesto en la lista. Además, podemos ordenarlos como queramos, pinchando sobre el campo a cambiar de sitio y arrastrándolo a la nueva posición. Para crear un campo nuevo (es decir, uno que no existe y por tanto no aparece en la lista de campos disponibles) pulsaremos con el botón derecho del ratón sobre el Editor de Campos y elegiremos la opción New Field... del menú contextual. Se nos abrirá una ventana como esta:

Vamos a estudiar únicamente los dos primeros tipos de campo, Data y Calculated. El tercer tipo, Lookup puede ser estudiado como ejercicio buscando en la ayuda de Delphi (si no lo he dicho ya, la ayuda de Delphi es muy completa y un buen lugar donde encontrar documentación de forma estructurada; además, es muy buena en general).

Definición de campos de datos Imaginad que quereis cambiar, por el motivo que sea, el tipo de dato de un campo. Por ejemplo, teneis un campo de tipo TSmallIntField y queréis convertirlo en TIntegerField. Dado que no podemos cambiar el tipo de dato de forma directa, tendremos que usar un campo de este tipo para substituir al existente. Los pasos a seguir (en la ventana que hemos visto antes) son: 1. 2.

3. 4.

En primer lugar, hemos de asegurarnos que en el apartado Field type tenemos seleccionado Data. Introducimos como nombre de campo el nombre de un campo persistente que exista (aquel del que queremos cambiar su tipo) en el campo Name. No hemos de introducir un nombre nuevo, sino uno que exista. Elegir el nuevo tipo de dato seleccionándolo del combo Type. Introducir el tamaño del campo en la opción Size si es necesario (en los tipos TStringField, TBytesField y TVarBytesField).

Con todos los datos necesarios introducidos, ya podemos pulsar el botón OK. Ya tenemos definido nuestro campo; podremos cambiar sus propiedades en el Inspector de Objetos.

Definición de campos calculados Un campo calculado nos muestra valores que el evento OnCalcFields del objeto conjunto de datos calcula en tiempo de ejecución. Para crear un campo calculado, seguiremos los siguientes pasos: 1. 2. 3. 4.

En primer lugar, nos aseguraremos de que en el apartado Field type tenemos seleccionado Calculated. Elegimos el tipo de datos seleccionándolo del combo Type. Le damos un nombre en el campo Name. Hemos de introducir un nombre nuevo, no el de un campo que ya exista. Introducir el tamaño en Size si es necesario.

Con todo esto, pulsamos OK y ya tenemos creado nuestro campo calculado. Ahora habrá que acudir al evento OnCalcFields del conjunto de datos correspondiente y escribir el código que asignará un valor a nuestro campo calculado.

Algunas propiedades de los componentes de campo Propiedad

Breve descripción

Aligment

Nos permite alinear a la izquierda, derecha o centro el contenido del campo

Calculated

Si es True nos indica que el contenido del campo es calculado en el evento onCalcFields del respectivo componente fuente de datos.

DisplayFormat

Especifica el formato de los datos que se muestran (no disponible para todos los tipos de campo).

DisplayWidth

Ancho, en caracteres, de una columna de un TDBGrid que muestra el campo.

FieldName

Especifica el nombre de la columna real de la tabla de la que el campo toma sus datos.

ReadOnly

Si es True muestra los valores del campo, pero no permite editarlos.

Por ejemplo, un componente de campo de tipo TStringField no cuenta con la propiedad DisplayFormat. Cuando hagáis vuestras propias aplicaciones os daréis cuenta de que si teneis un componente de conjunto de datos, llamémosle ConjuntoDeDatos, cuando creéis un campo persistente, por ejemplo CAMPO_PERSISTENTE, el objeto de campo que se crea recibe el identificador (el nombre para Delphi) ConjuntoDeDatosCAMPO_PERSISTENTE. En una aplicación, podemos acceder al valor de una columna de la base de datos vía la propiedad Value del componente de campo correspondiente haciendo (por ejemplo):

EdNombreAlumno.Text := ConjuntoDeDatosNOMBRE_ALUMNO.Value;

Esto va bien para las cadenas, pero en otros tipos de campos será necesario hacer una conversión; para ello, el componente de campo dispone de unos métodos que nos permitirá hacer esta conversión. Vamos a ver una tabla en la que mostramos estas funciones de conversión y apuntamos el tipo de campo para el que dicha función va bien: Tipo de campo / función

AsVariant AsString AsInteger AsFloat AsCurrency AsDateTime AsBoolean

TStringField

OK

OK

OK

OK

OK

OK

TIntegerField

OK

OK

OK

OK

OK

TSmallIntField

OK

OK

OK

OK

OK

TWordField

OK

OK

OK

OK

OK

TFloatField

OK

OK

OK

OK

TCurrencyField OK

OK

OK

TBCDField

OK

OK

OK

TDateTimeField OK

OK

OK

OK

OK

TDateField

OK

OK

OK

OK

OK

TTimeField

OK

OK

OK

OK

OK

TBooleanField

OK

OK

TBytesField

OK

OK

TVarBytesField OK

OK

TBlobField

OK

OK

TMemoField

OK

OK

OK

OK

TGraphicField

OK

OK

En caso de duda, usar AsVariant. Vamos a hacer un pequeño inciso mostrando el resultado de algunas conversiones "especiales": De String a Boolean: Únicamente convierte los valores "True" o "Yes" a True y los valores "False" o "No" a False. El resto genera excepciones. De Float a Integer: Redondea al entero más cercano. De DateTime a Float: Convierte fechas al número de días transcurridos desde el 31 de diciembre de 1899 y las horas a una fracción de 24 horas. De Boolean a String: Convierte True a "True" y False a "False". En cualquier caso, una conversión no válida generará una excepción.

Varios ejemplos de uso:

EdNombre.Text := ConjuntoDeDatosNOMBRE_ALUMNO.AsString; EdApellidos.Text := ConjuntoDeDatosAPELLIDOS_ALUMNO.AsString; DTPickerFechaNac.Date := ConjuntoDeDatosFECHA_NAC_ALUMNO.AsDate; Curso := ConjuntoDeDatosCURSO_ALUMNO.AsInteger; ConjuntoDeDatosREPETIDOR_ALUMNO.AsBoolean := ChkBxRepetidor.Checked;

Otras formas de acceder a los campos: También podemos acceder a los valores de los campos vía la propiedad Fields del objeto de conjunto de datos. Esta propiedad es de tipo array, por lo que necesitaremos saber la posición de un campo en el objeto conjunto de datos, siendo la primera columna la 0. Por ejemplo: EdNombre.Text := ConjuntoDeDatos.Fields[2].AsString; Esto sería si supiéramos que la tercera columna es la del nombre. Una alternativa que evita saber el orden correcto es usar el método FieldByName. Así, lo siguiente sería equivalente al ejemplo anterior: EdNombre.Text := ConjuntoDeDatos.FieldByName('NOMBRE_ALUMNO').AsString;

4.v. TTable Gracias a este componente vamos a poder trabajar con los datos de cualquier fila y columna de una tabla concreta de la base de datos. Hemos de recordar que es un descendiente de TDataSet, así que todo lo dicho para TDataSet es válido para TTable.

Creación de un componente TTable Siempre que queramos usar un componente TTable, los pasos fundamentales a seguir son estos: 1. 2. 3. 4.

Insertar el componente bien en un form bien en un Data Module y darle nombre en Name. Definir en la propiedad DatabaseName la base de datos a la que estará ligado. Definir en la propiedad TableName el nombre de la tabla a la que hará referencia. Insertar un componente TDataSource en el form o en el Data Module y asignar a su propiedad DataSet el nombre de la tabla (i.e., su propiedad Name).

Nota: DatabaseName puede ser un alias de BDE (aparecerá en un desplegable junto a esta propiedad) o bien una ruta completa. Es recomendable que sea un alias BDE porque si cambiamos la base de datos de sitio, sólo tendremos que cambiar en el alias este dato y no en todos los componentes que hagan referencia a ella. Es más recomendable aún que sea el nombre de algún componente TDatabase que exista en la aplicación, porque si cambiara el alias, únicamente habría que cambiarlo aquí.

Búsqueda de registros Para buscar registros usaremos el método Locate ya visto en la explicación de TDataSet. Este método nos desplazará el cursor a la primera fila que coincide con el conjunto de criterios de búsqueda especificados. Un ejemplo puede ser: Exito := Tabla.Locate('NOMBRE_ALUMNO', 'Juan', [loPartialKey]);

No hay mucho más que decir; el resto ya fue estudiado con TDataSet.

4.vi. TQuery Este componente puede usarse con servidores de bases de datos remotos (en la version Client/Server Suite de Delphi), con bases de datos Paradox y dBase y con bases de datos compatibles con ODBC (como Access). Gracias a este componente vamos a poder acceder a varias tablas al mismo tiempo (vía un JOIN, claro está) o acceder de forma automática a un subconjunto de filas y columas de una tabla o tablas. Hemos de recordar que también es un descendiente de TDataSet, así que todo lo dicho para TDataSet es válido para TQuery. Los criterios de selección son sentencias SQL y pueden ser estáticos (todos los parámetros de la sentencia se dan en tiempo de diseño) o dinámicos (algunos o todos los parámetros se dan en tiempo de ejecución).

Creación de un componente TQuery

Siempre que queramos usar un componente TQuery, los pasos fundamentales a seguir son estos: 1.

Insertar en el componente bien en un form bien en un Data Module y darle nombre en Name. 2. Definir en la propiedad DatabaseName la base de datos a la que estará ligado. 3. Especificar la sentencia SQL en la propiedad SQL del componente y definir, si es necesario, los parámetros de la misma en la propiedad Params. 4. Insertar un componente TDataSource en el form o en el Data Module y asignar a su propiedad DataSet el nombre del query (i.e., su propiedad Name).

Consultas estáticas y dinámicas Vamos a distinguirlas con un ejemplo. Supongamos que escribimos en la propiedad SQL (veremos a continuación cómo asignar valores a esta propiedad) el texto: SELECT NOMBRE_ALUMNO FROM ALUMNOS WHERE NOTAMEDIA >= 5 AND EDAD = 15

Todos los valores para la cláusula WHERE vienen dados de forma explícita. Es una consulta estática, porque todos los valores vienen dados. Sin embargo, si en vez de eso escribiéramos:

SELECT NOMBRE_ALUMNO FROM ALUMNOS WHERE NOTAMEDIA >= 5 AND EDAD = :Edad

Vemos que aparece, en vez de un valor concreto para la edad, el valor :Edad. Eso quiere decir que en tiempo de ejecución, de acuerdo a los criterios que exija nuestro programa, asignaremos el valor adecuado de la edad según la situación. La forma de especificar estos nombres variables es anteponiendo dos puntos al nombre que le queramos dar. Luego, en el código, asignaremos el valor adecuado usando el método ParamByName del componente TQuery. Por ejemplo, para nuestro caso anterior podría quedar como sigue:

QAlumnos.ParamByName('Edad').AsInteger := 17;

Notar que el nombre del parámetro, en la llamada al método ParamByName, no lleva los dos puntos. Los dos puntos se ponen única y exclusivamente en la consulta, para distinguirlos de un valor estático y para saber que el identificador que va a continuación es el que se debe esperar en el programa.

Dónde especificar la consulta SQL El componente TQuery tiene una propiedad llamada SQL que es donde se almacena la consulta a enviar a la base de datos. Podemos introducirla en tiempo de diseño pulsando sobre ella (se nos abre el editor de consultas) o en tiempo de ejecución, asignando a la propiedad Text de la propiedad SQL el texto completo de la consulta. Hay que señalar que esta propiedad SQL es de tipo TStringList, por ello contamos con una propiedad Text así como el resto de propiedades de estos objetos. En tiempo de ejecución, antes de asignar cualquier valor a la propiedad SQL la consulta debe estar cerrada. Esto lo conseguimos con el método Close que ya estudiamos en el objeto TDataSet. Así, un ejemplo de asignación en tiempo de ejecución puede ser:

QAlumnos.Close; QAlumnos.SQL.Text := 'SELECT NOMBRE_ALUMNO FROM ALUMNOS WHERE EDAD = 15';

Para más información, repasad TDataSet y consultad en la ayuda de Delphi.

5.i. TDBGrid Este componente nos permite mostrar los registros de un TDataSet en forma tabular:

Para asociar este componente con el TDataSet del que obtiene los datos, hemos de poner en su propiedad DataSource el nombre del TDataSource asociado al TDataSet. Si la propiedad State del DBGrid toma el valor csDefault, el aspecto de los registros se determina a través de las propiedades de los campos incluidos en el TDataSet asociado al DBGrid. Si el TDataSet asociado al DBGrid consta de componentes de campo persistentes (ya vimos cómo crearlos en el capítulo correspondiente), éstos permanecen aunque se cierre el TDataSet, de manera que las columnas asociadas a estos campos conservarán también sus propiedades aunque se cierre el TDataSet. Podemos personalizar una DBGrid precisamente gracias a los objetos de campo persistentes. Así, en tiempo de diseño podremos dejar la DBGrid lista para que funcione exactamente como queremos que se muestre siempre. La forma de hacerlo es la siguiente. En primer lugar, nos vamos a la propiedad Columns y hacemos doble click sobre el botón de los puntos suspensivos. Entonces se nos abre una ventana como la siguiente:

Añadimos tantas columnas como queramos pulsando New. En principio, todas ellas no están asociadas a campos. Si pulsamos sobre una columna concreta, entonces en el Inspector de objetos nos muestra todas las propiedades de esa columna. El título de la columna puede tener su propio formato, independientemente del formato de la columna, pudiendo poner el título en negrita de color clNavy y la columna en cursiva de color clMaroon con fondo clInfoBk. Hay una propiedad que nos interesa mucho: FieldName. Si pulsamos, se nos abre un desplegable con todos los componentes de campo persistentes que hayan sido definidos para el TDataSet. Elegimos uno y ya está. Repetimos la operación con las restantes columnas, y ya tenemos el DBGrid completamente personalizado.

Ejemplo: Creación de una agenda I. Diseño de la base de datos y las operaciones Como ejemplo de uso de base de datos con Delphi, vamos a acudir al socorrido ejercicio de crearnos una agenda con los datos de nuestros conocidos. Para evitar simplificar demasiado con una única tabla en la base de datos, añadiremos un pequeño extra en este ejemplo: los contactos estarán agrupados por categorías, lo que nos da la siguiente estructura (podeis añadir/eliminar los campos que queráis):

Como vamos a usar Interbase, primero crearemos la base de datos bajo el usuario que queramos que sea su dueño. Si no sabeis dar de alta usuarios, o no sabeis crear la base de datos, id al anexo sobre Interbase. Yo le voy a dar el nombre Agenda.gdb. A continuación tenemos que crear las tablas. Podemos hacerlo directamente en el IBConsole, o podemos crear un alias BDE y entonces crear las tablas con el SQL Explorer. Yo voy a hacerlo usando la segunda opción, porque de todas maneras, necesitaremos el alias BDE para cuando llegue el momento de diseñar la aplicación con Delphi. Recordad que en el anexo 1 encontrareis la información necesaria para crear alias BDE y en el SQL Explorer.

anexo 3 hay un pequeño manual de uso de

Elijáis el camino que elijáis, hay que crear las tablas, para lo cual vamos a introducir las siguientes sentencias SQL:

CREATE TABLE CATEGORIAS( IDCATEGORIA INTEGER NOT NULL, DESCRIPCION VARCHAR(255) NOT NULL, PRIMARY KEY(IDCATEGORIA)

); CREATE GENERATOR GENIDCATEGORIA;

CREATE TABLE CONTACTOS( IDCONTACTO INTEGER NOT NULL, CATEGORIA INTEGER NOT NULL, NOMBRE VARCHAR(100) NOT NULL, APELLIDO1 VARCHAR(100) NOT NULL, APELLIDO2 VARCHAR(100), TELEFONO VARCHAR(20) NOT NULL, MOVIL VARCHAR(20), DIRECCION VARCHAR(255), EMAIL1 VARCHAR(255), EMAIL2 VARCHAR(255), WEB1 VARCHAR(255), WEB2 VARCHAR(255), PRIMARY KEY(IDCONTACTO) );

CREATE GENERATOR GENIDCONTACTO;

ALTER TABLE CONTACTOS ADD FOREIGN KEY(CATEGORIA) REFERENCES CATEGORIAS(IDCATEGORIA);

Una vez introducidas, vamos a pensar en las operaciones básicas de gestión de estos datos: inserción, edición, eliminación y búsqueda. Dejaremos claras cuáles serán las sentencias SQL que llevarán a cabo cada una de las operaciones, con lo que el desarrollo del programa será más sencillo.

Gestión de la tabla CATEGORIAS Comenzaremos con la tabla CATEGORIAS. Entre otras cosas, empezamos por ella porque ningún campo de esta tabla depende de que exista un valor previo en otra tabla (cosa que no sucede en la tabla CONTACTOS). La clave primaria de esta tabla es IDCATEGORIA. Me gusta usar enteros como claves primarias porque son más simples. Si estamos seguros de que la combinación NOMBRE + APELLIDO1 + APELLIDO2 es única podríamos usarla como clave primaria, por ejemplo. Personalmente, prefiero que la clave primaria sea un entero independiente del resto de información. Es un criterio que he ido adoptando con el tiempo y que quizá vosotros veáis innecesario.

Para generar los valores sucesivos de la clave primaria utilizo un generador, GENIDCATEGORIA. Le pongo el prefijo GEN porque así lo identifico rápidamente como generador de los valores del campo que le sigue, IDCATEGORIA en este caso. Así que vamos ya a ver en qué consisten las operaciones básicas para esta tabla. Inserción Cuando se crea un generador, se inicializa automáticamente a 0. Así que, cuando insertemos un nuevo registro, debemos incrementar este valor, e insertarlo junto con la descripción de la categoría. Por tanto, las sentencias necesarias para insertar una nueva categoría serían:

INSERT INTO CATEGORIAS( IDCATEGORIA , DESCRIPCION ) VALUES ( GEN_ID(GENIDCATEGORIA, 1) , :Descripcion );

¿Qué es :Descripcion? Es un parámetro. Con eso quiero decir que la descripción a insertar será la que se nos dé en el programa. Edición El único campo que podemos editar es la descripción de la categoría, ya que el ID permanece invariable. Es un dato que al usuario no le sirve y que no le vamos a mostrar (el exceso de información siempre es peligroso), pero que nosotros vamos a tener disponible (veremos cómo cuando entremos en el desarrollo con Delphi, por ahora, asumimos que es así). Por tanto, actualizar el registro será tan sencillo como:

UPDATE CATEGORIAS SET DESCRIPCION = :Descripcion WHERE IDCATEGORIA = :Id ; Eliminación Por supuesto, tras asegurarnos de que el usuario realmente quiere eliminar ese registro, procederemos a realizar la operación de borrado:

DELETE FROM CATEGORIAS WHERE IDCATEGORIA = :Id

Cuidado con la operación de borrar, si no pusiéramos la cláusula WHERE, se borraría la tabla completa. Búsqueda Únicamente va a tener sentido buscar una categoría por su nombre. Una sentencia sencilla que nos daría esto sería:

SELECT * FROM CATEGORIAS WHERE DESCRIPCION LIKE %LoQueBuscamos%

pero en lugar de eso, vamos a usar el método Locate de los descendientes de TDataSet. Cuando desarrollemos la aplicación veremos que es bastante sencillo :-)

Gestión de la tabla CONTACTOS Al contrario que con la otra tabla, ésta sí que depende de otra tabla. En el dibujo se ha mostrado que hay una relación entre la tabla CONTACTOS y la tabla CATEGORIAS, y es que todo contacto pertenece a una categoría, por ello, antes de crear un contacto, debe existir la categoría a la que se le quiere asociar. Así, creadas las categorías necesarias, ya podemos dar de alta contactos. Esta tabla también tiene como clave primaria un ID que será generado vía su generador asociado GENIDCONTACTO por medio de la función GEN_ID que ya hemos usado. He elegido los siguientes campos como obligatorios (especificado vía el NOT NULL que hay en la definición de algunos campos): IDCONTACTO, CATEGORIA, NOMBRE, APELLIDO1, TELEFONO. No he escogido APELLIDO2 porque no siempre sabemos el segundo apellido de una persona, y tampoco he escogido MOVIL porque un contacto cualquiera en principio no tiene por qué tener móvil, pero sí un TELEFONO, ya que la agenda se supone que es de teléfonos. Y la DIRECCION tampoco es obligatoria porque no tenemos por qué saber dónde vive. Lo mismo con el resto de campos. Son datos opcionales. Inserción Tras comprobar que los campos no nulos contienen valores, tendremos que escribir la siguiente consulta de inserción (los campos opcionales los represento entre []):

INSERT INTO CONTACTOS( IDCONTACTO, CATEGORIA, NOMBRE, APELLIDO1[, APELLIDO2] , TELEFONO[, MOVIL][, DIRECCION][, EMAIL1][, EMAIL2] [, WEB1][, WEB2] ) VALUES ( GEN_ID(GENIDCONTACTO), :Categoria, :Nombre, :Apellido1[, :Apellido2] , :Telefono[, :Movil][, :Direccion][, :Email1][, :Email2] [, :Web1][, :Web2] );

Es obvio que de alguna manera hemos de conocer el IDCATEGORIA correcto para asociarlo al campo CATEGORIA. No hay ningún problema: veremos cómo nos ayuda Delphi en este sentido. Edición La edición es semejante a la inserción y queda como ejercicio para el lector ;-) No hay que preocuparse por cómo localizar los ID adecuados: Delphi sigue ayudándonos en este trabajo. Eliminación Previo asegurarse de si de verdad se va a eliminar el registro o no, la sentencia para eliminar el registro es análoga a la vista con las categorías y queda de nuevo como ejercicio ;-) Búsqueda Aquí podemos buscar por varios campos: por nombre, por apellido, por teléfono, ... al igual que con la tabla de CATEGORIAS, dejaremos el trabajo de la búsqueda al método Locate de los objetos descendientes de TDataSet ;-) Seguimos en el próximo capítulo diseñando la parte gráfica de la aplicación. Estudiad todo lo que hemos pensado hasta el momento, en particular, la relación entre las tablas.

Ejemplo: Creación de una agenda II.I Diseño del interface de la aplicación: Categorías Una vez pensada la estructura de la base de datos así como las operaciones a realizar, vamos a diseñar el interface de la aplicación. Por variar un poco, vamos a crear un form con un TPageControl que contendrá dos TTabSheet: uno será la ficha de contactos y otro será la ficha de categorías:

Además, vamos a tener en un DataModule el componente TDatabase:

De las propiedades del TDatabase cabe destacar:

AliasName = Agenda DatabaseName = DBGlobal LoginPrompt = False Name = DBGlobal

En el evento OnCreate del DataModule escribiremos este código:

procedure TDM.DataModuleCreate(Sender: TObject); begin DBGlobal.Params.Values['USERNAME'] := TuNombreDeUsuario; DBGlobal.Params.Values['PASSWORD'] := TuContraseña;

try DBGlobal.Open; except ShowMessage('Error abriendo la base de datos: cerrando aplicación'); Application.Terminate; end; end;

Para que reconozca ShowMessage debéis incluir la unit Dialogs, y para que reconozca al objeto Application debéis incluir la unit Forms. Además, hemos de colocar esta unit dentro del fichero del proyecto la primera de entre todos los forms que se crean. Así, lo primero que comprobamos al arrancar es que podemos conectar con la base de datos; si es así, pues ya se crean los forms y si no, se termina la aplicación. Ahora que ya tenemos el DataModule con la base de datos, comenzaremos con la ficha de categorías por ser la más sencilla:

Por partes: la idea de funcionamiento (que aplicaremos también a los contactos) es que no vamos a crear categorías ni editarlas directamente sobre la DBGrid, sino que lo haremos aparte (concretamente en un panel). Los botones de gestión son de tipo TSpeedButton y los he llamado SBtnNuevo, SBtnEditar, SBtnEliminar, SBtnBuscar y SBtnOKBuscar. Cuando estemos editando datos en el panel, estos botones se deshabilitarán y al revés, cuando no estemos editando será el panel quien esté deshabilitado. El panel inferior recibe el nombre de PnlEdicion, tiene Caption = '' y BevelOuter = bvLowered. Dentro contiene los componentes que usaremos para crear nuevas categorías o editar las existentes. Concretamente, tenemos el edit EdCategoria, el label LblTipoModif, que nos dirá si estamos creando una nueva categoría o editando una existente y los TBitBtn BtnAceptar y BtnCancelar. Hemos colocado un DBGrid, DBGCategorias, un Table, TblCategorias y un DataSource, DSCategorias. El DataSource tiene por valor en su propiedad DataSet = TblCategorias. TblCategorias tiene en su propiedad DatabaseName = DBGlobal (debemos incluir la unit del DataModule para que esté disponible) y en su propiedad TableName = CATEGORIAS. El DBGrid tiene en su propiedad DataSource = DSCategorias y hemos definido una columna que mostrará el valor del campo persistente DESCRIPCION (he añadido los dos campos de la tabla a la lista de campos persistentes), por tanto, para esta columna, FieldName = DESCRIPCION. Además, al DBGrid le hemos quitado la posibilidad de que pueda editarse sobre él, el indicador de registro actual y que pueda cambiarse el tamaño de la columna. Empezaremos definiendo qué debe suceder en los eventos OnShow y OnCreate. El código para estos eventos será ampliado cuando trabajemos con la pestaña de contactos.

procedure TFrmAgenda.FormCreate(Sender: TObject); begin HabilitarPanelEdicion(False); end;

procedure TFrmAgenda.FormShow(Sender: TObject); begin TblCategorias.Close; TblCategorias.Open; end;

Por otro lado, definimos los siguientes procedimientos que nos serán útiles para realizar la gestión.

procedure TFrmAgenda.HabilitarBotonesGestion(Habilitar: Boolean); begin SBtnNuevo.Enabled := Habilitar; SBtnEditar.Enabled := Habilitar; SBtnEliminar.Enabled := Habilitar; SBtnBuscar.Enabled := Habilitar; end;

procedure TFrmAgenda.HabilitarPanelEdicion(Habilitar: Boolean); var i: Integer; begin PnlEdicion.Enabled := Habilitar;

for i := 0 to PnlEdicion.ControlCount - 1 do PnlEdicion.Controls[i].Enabled := Habilitar;

VaciarCamposEdicion; end;

procedure TFrmAgenda.CerrarEdicion; begin HabilitarPanelEdicion(False); HabilitarBotonesGestion(True); end;

procedure TFrmAgenda.VaciarCamposEdicion;

begin EdCategoria.Text := ''; LblTipoModif.Caption := ''; end;

procedure TFrmAgenda.RefrescarCategorias(Id: Integer); begin TblCategorias.Close; TblCategorias.Open;

if Id > 0 then begin TblCategorias.Locate('IDCATEGORIA', Id, []); DBGCategorias.SetFocus; end; end;

Ahora vamos a definir los procedimientos de crear, editar y eliminar registros. La idea será que los botones Nuevo y Editar pondrán los valores pertinentes en los campos y luego, al pulsar el botón Aceptar, en función de una variable que llamaremos GestionNuevo: Boolean (privada dentro de la definición del form) sabremos si tenemos que hacer un INSERT o un UPDATE. El botón de Cancelar simplemente vaciará el edit del panel de edición y retornará el control a los botones de gestión. Para Eliminar primero pediremos confirmación. Vamos primero a crear una nueva tabla en la base de datos, cuya definición será:

CREATE TABLE AUXILIAR( COLUMNA INTEGER );

La usaremos para incrementar el valor del generador para los ids, tanto de categorías como de contactos. Debemos insertar una única fila en esta tabla pudiendo contener cualquier valor entero, por ejemplo, 1. Este detalle es muy importante; lo que haremos a continuación no funcionará si esta tabla no tiene una y sólo una fila con un valor numérico cualquiera. Recordad que en la estructura de la base de datos se vio que hay un id en cada tabla que es único. Este id es el que nos permite distinguir un registro de otro. Además, incluimos en el form un objeto TQuery al que llamaremos QConsulta en cuya propiedad DatabaseName pondremos el valor DBGlobal. Este query nos servirá para realizar la consulta siguiente:

SELECT GEN_ID(GENIDCATEGORIA, 1) FROM AUXILIAR;

que nos devolverá el siguiente valor a insertar del generador. Así, creamos la siguiente función:

function TFrmAgenda.GenID(Generador: String): Integer; begin QConsulta.Close; QConsulta.SQL.Text := 'SELECT GEN_ID(' + Generador + ', 1) FROM AUXILIAR;'; QConsulta.Open;

Result := QConsulta.Fields[0].AsInteger; end;

que usaremos en el lugar apropiado. Vamos a ver ahora cómo preparamos los controles según si pulsamos el botón Nuevo o el botón Editar:

procedure TFrmAgenda.SBtnNuevoClick(Sender: TObject); begin GestionNuevo := True; HabilitarPanelEdicion(True); HabilitarBotonesGestion(False); LblTipoModif.Caption := 'Nueva categoría'; EdCategoria.SetFocus; end;

procedure TFrmAgenda.SBtnEditarClick(Sender: TObject); begin if TblCategoriasIDCATEGORIA.AsInteger > 0 then begin GestionNuevo := False; HabilitarPanelEdicion(True); HabilitarBotonesGestion(False); LblTipoModif.Caption := 'Editando categoría'; EdCategoria.Text := TblCategoriasDESCRIPCION.AsString; end; end;

Como podeis ver, en Editar la condición dice que si no hay ids (es decir, no hay registros, porque cuando se crea el primer registro su id es 1) entonces no hace nada, pero si hay ids, preparo el edit del panel de edición con el valor del campo seleccionado. Al pulsar el botón Eliminar ejecutaremos la siguiente acción:

procedure TFrmAgenda.SBtnEliminarClick(Sender: TObject); var Id: Integer; begin Id := TblCategoriasIDCATEGORIA.AsInteger;

if (Id > 0) and ( Application.MessageBox('¿Está seguro de que desea eliminar el registro seleccionado?', 'Eliminar registro', MB_YESNO + MB_ICONQUESTION ) = IDYES ) then begin TblCategorias.Delete; RefrescarCategorias(0); end; end;

Si pulsamos el botón Cancelar tendremos:

procedure TFrmAgenda.BtnCancelarClick(Sender: TObject); begin if Application.MessageBox('¿Está seguro de que desea cancelar la edición de los datos?', 'Confirmación de cancelación', MB_YESNO + MB_ICONQUESTION ) = IDYES then

CerrarEdicion; end;

Y si pulsamos Aceptar:

procedure TFrmAgenda.BtnAceptarClick(Sender: TObject); var Id: Integer; begin if GestionNuevo then begin Id := GenID('GENIDCATEGORIA');

TblCategorias.Close; TblCategorias.Open; TblCategorias.Insert; TblCategoriasIDCATEGORIA.AsInteger := Id; TblCategoriasDESCRIPCION.AsString := EdCategoria.Text; TblCategorias.Post;

RefrescarCategorias(Id); CerrarEdicion; end else

{ not GestionNuevo -> Editando existente }

begin Id := TblCategoriasIDCATEGORIA.AsInteger;

TblCategorias.Edit; TblCategoriasDESCRIPCION.AsString := EdCategoria.Text; TblCategorias.Post;

RefrescarCategorias(Id); CerrarEdicion; end; end;

Aquí tenemos un ejemplo de la aplicación funcionando:

Por último, tratamos la búsqueda. Para la búsqueda, en primer lugar pondremos, en tiempo de diseño, la propiedad Enabled del botón OK a False. Después, al botón buscar le asignaremos AllowAllUp = True y GroupIndex = 1. A continuación, escribimos el siguiente código para el botón Buscar:

procedure TFrmAgenda.SBtnBuscarClick(Sender: TObject); begin SBtnNuevo.Enabled := BtnBuscarPulsadoCategorias; SBtnEditar.Enabled := BtnBuscarPulsadoCategorias; SBtnEliminar.Enabled := BtnBuscarPulsadoCategorias;

if not BtnBuscarPulsadoCategorias then begin EdBuscar.Enabled := True; SBtnBuscar.Down := True; SBtnOKBuscar.Enabled := True; BtnBuscarPulsadoCategorias := True; EdBuscar.SetFocus; end else begin EdBuscar.Text := '';

SBtnBuscar.Down := False; EdBuscar.Enabled := False; SBtnOKBuscar.Enabled := False; BtnBuscarPulsadoCategorias := False; end; end;

Y para el botón OK escribimos el siguiente:

procedure TFrmAgenda.SBtnOKBuscarClick(Sender: TObject); begin if BtnBuscarPulsadoCategorias then begin if EdBuscar.Text = '' then begin ShowMessage('Debe escribir un texto para realizar la búsqueda'); EdBuscar.SetFocus; end else begin if TblCategorias.Locate('DESCRIPCION', EdBuscar.Text, [loCaseInsensitive, loPartialKey]) then DBGCategorias.SetFocus else ShowMessage('No se encuentra ninguna categoría con esa descripción');

SBtnBuscar.Down := False; EdBuscar.Text := ''; EdBuscar.Enabled := False; SBtnOKBuscar.Enabled := False; BtnBuscarPulsadoCategorias := False;

SBtnNuevo.Enabled := True; SBtnEditar.Enabled := True; SBtnEliminar.Enabled := True; end;

end; end;

Con lo que ya tenemos funcionando toda la parte de definición de categorías para nuestra agenda. En el capítulo siguiente, daremos cuerpo a la parte de contactos. Tened en cuenta que, visto lo que hemos visto aquí con tanto detalle, me saltaré algunas partes dejándoos a vosotros que penseis un poco y las desarrolleis. Vereis como no es tan difícil.

Ejercicio Ampliar el programa no permitiendo repetir categorías. Sugerencia: usar un SELECT sobre la tabla AUXILIAR con la función EXISTS de SQL.

A1. Borland Database Engine En este apartado vamos a ver los aspectos más básicos que necesitaremos configurar para poder acceder a nuestras bases de datos desde un programa Delphi. Arrancaremos el programa de configuración de BDE accediendo a la ruta Panel de control -> BDE Administrator, con lo que se nos abrirá la ventana:

A la izquierda, en la pestaña Databases tenemos una lista con todos los alias que hayamos dado de alta. A la derecha no tenemos nada porque no hemos seleccionado alias alguno. Si pulsamos sobre un alias cualquiera, la parte derecha cambia y se muestra la configuración del alias, que podremos editar.

Vamos a comenzar creando un nuevo alias. Con este nuevo alias podremos hacer referencia a la base de datos desde Delphi. Para ello, pulsamos en el menú Object, elegimos New... y a continuación escogemos el tipo de base de datos de la lista que nos ofrece:

Trataremos con Interbase por ser un gestor que da suficiente potencia a la base de datos, así como que es gratuito y con buena calidad. Para ello, elegimos como nombre de driver INTRBASE. Hecho esto, veremos aparecer el nuevo alias, con un nombre temporal (a espera de que nosotros pongamos el nuestro) y con un indicador de que es necesario aplicar los cambios para dar la tarea por concluida:

A la derecha de la pantalla nos han aparecido las opciones por defecto para este nuevo alias:

Comenzaremos cambiando el nombre del alias, escribiendo DBPrueba en el lugar de INTRBASE1, que es el que sugiere por defecto:

Ahora vamos a centrarnos en las opciones más importantes que nos ofrece: BLOB SIZE

Tamaño máximo en Kb que podrá tener un campo de tipo Blob al insertarlo o recuperarlo de la base de datos. Es recomendable que tenga un tamaño entre 32 y 1000 Kb BLOBS TO CACHE Es el número máximo de blobs que pueden estar almacenados a la vez en el ordenador cliente. No es conveniente que sea una número muy grande. El valor suele variar entre 64 y 65536. LANGDRIVER Es el juego de caracteres usado por la base de datos. Es recomendable dejar en blanco el campo. MAX ROWS Es el número de filas que devolverá la base de datos al hacer una consulta. Si dejamos el valor -1 (recomendado), nos devolverá todas las filas que cumplan la condición de la consulta. OPEN MODE Es el modo de apertura de la base de datos. Sólo hay dos posibles formas de abrirla: READ ONLY

La base de datos se abre en modo lectura, con lo que no podremos escribir registros ni actualizarlos

READ/WRITE

Es la opción por defecto. Teniendo esta opción, podremos realizar cualquier tipo de operación sobre la base de datos

SERVER NAME Nombre del servidor y ruta dentro del mismo vía el que se accede a la base de datos. Depende de cómo esté configurado el acceso a la red, se escribirá de una de las siguientes formas: Acceso local

Unidad:\Ruta\Fichero.gdb

En red con TCP/IP bajo Windows

NombreMaquina:Unidad:\Ruta\Fichero.gdb

En red con TCP/IP bajo Unix

NombreMaquina:Ruta/Fichero.gdb

En red con NETBEUI

NombreServidor\\Unidad:\Ruta\Fichero.gdb

La extensión gdb es propia de los ficheros de Interbase. USER NAME Nombre de usuario que se tomará por defecto al establecer la conexión con el servidor. Cuando instalamos Interbase hay un usuario administrador por defecto, que es SYSDBA. Será recomendable usar un nuevo usuario. Si no queremos que el sistema nos muestre el nombre del usuario cuando vayamos a establecer la conexión, lo dejaremos en blanco. Esto no querrá decir que no haya un usuario definido, sólo que no se verá qué nombre es. Dejaremos todas las opciones por defecto para nuestro alias, salvo dos, SERVER NAME y USER NAME. Usaremos una base de datos local, así que en SERVER NAME simplemente escribiremos la ruta en la que se encuentra el fichero. Por otra parte, como nombre de usuario pondremos Prueba. En el apartado de Interbase veremos cómo dar de alta usuarios.

, con lo que ya tenemos dado de alta el alias. A Finalizamos pulsando el botón de "Aplicar" partir de ahora podremos acceder a la base de datos desde Delphi simplemente refiriéndonos a DBPrueba. Si intentamos abrirla pulsando el + que hay al lado del nombre del alias, el programa nos dará un error informándonos de que no puede acceder a la base de datos. Hemos creado el alias,

pero en ningún momento hemos creado físicamente la base de datos. En el capítulo de Interbase veremos cómo hacerlo.

A2. InterBase Vamos a crear una base de datos Interbase. Para ello, abriremos el programa IBConsole, que se instala junto con Interbase. Si el servicio de Interbase no se carga de forma automática (en los sistemas Windows NT y Windows 2000 se carga de forma automática), tendremos que arrancarlo nosotros de forma manual. Recién instalado el servidor de Interbase, al abrir el programa IBConsole no tendremos definidos servidores ni más usuarios que el usuario por defecto, SYSDBA, cuya clave de acceso es masterkey. Sobre la opción InterBase Servers pulsaremos con el botón derecho del ratón, con lo que se nos despliega el siguiente menú:

Elegimos Register... y accedemos a la pantalla que nos permite dar de alta el servidor local. Hasta que no registremos un servidor local, no tendremos accesible la opción de dar de alta un servidor remoto. En la pantalla que vemos:

rellenaremos los campos USER NAME y PASSWORD con los valores respectivos SYSDBA y masterkey (muy importante que la clave esté en minúsculas). Pulsamos el botón OK y ya tenemos registrado el servidor local, que será nuestra propia máquina. Ahora podemos crear bases de datos en el servidor local, registrar bases de datos existentes (importante si queremos acceder a ellas, pues sólo veremos las registradas) y registrar servidores remotos (uno o varios). Comenzaremos viendo cómo crear un nuevo usuario. Cuando hemos registrado el servidor local, el aspecto de la pantalla principal cambia un poco, mostrándonos estas opciones:

Si pulsamos sobre Users veremos únicamente al usuario SYSDBA. Para crear uno nuevo, accedemos a la opción User security del menú Server. Se nos muestra entonces la ventana:

en la que pulsaremos el botón New, con lo que se vacían los campos USER NAME y PASSWORD para que los rellenemos con los del nuevo usuario. Una vez introducidos los datos, pulsamos el botón Apply, con lo que ya tenemos dado de alta el usuario. Ahora vamos a crear la base de datos. Lo primero de todo será hacer login como el usuario que queramos que tenga acceso a la base de datos, así que si estamos como SYSDBA y queremos que el usuario sea PEPE, tendremos que "desregistrarnos" como SYSDBA y registrarnos como PEPE en el servidor Local Server.

Estando en Local Server, subopción Databases, pulsamos el botón derecho y elegimos Create database..., con lo que se nos abre la ventana:

Rellenamos el nombre del fichero (ruta completa) y el alias que le vamos a dar a la base de datos, y pulsamos OK:

El directorio debe existir, o de lo contrario se nos mostrará un error de escritura. Creada la base de datos, InterBase nos muestra la pantalla:

Ya podemos empezar a trastear con nuestra recién creada base de datos. Podemos crear tablas, dar del alta registros, etc. Para ello, podemos emplear la utilidad ISQL, o bien SQL Explorer, del propio Delphi, que es el que describimos brevemente en el anexo siguiente. Realmente, se parecen tanto y son tan intuitivos, que no vale la pena repetir lo mismo. No hay que olvidar que para poder acceder a la base de datos desde Delphi, tenemos que haber creado un alias para ella, bien sea desde BDE Administrator o desde SQL Explorer. Crear un alias desde InterBase no quiere decir que Delphi lo vaya a reconocer. Delphi sólo lo reconocerá si ha sido creado desde sus herramientas.

A3. SQL Explorer El programa SQL Explorer nos permite examinar bases de datos cuyo alias tengamos dado de alta con mucha comodidad: separa los elementos de la base de datos en categorías: dominios, tablas, generadores, funciones, procedimientos... Podremos modificar registros de las tablas sin necesidad de acudir a sentencias SQL, simplemente situándonos sobre el campo a modificar, actualizar valores de los generadores, editar procedimientos... y también nos permite introducir sentencias SQL con las que podremos crear tablas, modificarlas, crear procedimientos, generadores, etc. En última instancia, si se nos ha olvidado crear el alias a la base de datos con el programa BDE Administrator, con SQL Explorer podremos hacerlo siguiendo exactamente los mismos pasos. Para mostrar el manejo básico de este programa, trabajaremos con un ejemplo muy sencillo (y típico): supongamos que tenemos una librería, y únicamente necesitamos una base de datos formada por una tabla con los siguientes datos:

• • • • • • • •

Código Libro Título Autor Tema Editorial Precio Unidades ISBN

Lo primero que tenemos que hacer es pensar de qué tipo de dato va a ser cada uno de los campos de la tabla. Parece lógico pensar que los campos "Código Libro","Precio", "Unidades" van a ser de tipo numérico, mientras que los demás serán de tipo carácter. Ejecutamos el programa SQL Explorer, que viene con Delphi, para dar de alta el alias de esta base de datos. En el anexo anterior vimos cómo crear la base de datos desde InterBase, así que ahora ya podemos abrirla con SQL Explorer y crear tablas. Al ejecutarlo, se nos muestra la siguiente pantalla:

Si pulsamos en el iconito del + que hay a la izquierda de nuestra base de datos:

se nos abre una ventana en la que tenemos que introducir el nombre de usuario y la contraseña del usuario activo en Interbase cuando creamos la base de datos:

Entrados estos datos correctamente, se despliega una lista con varias entradas:

Además, también veremos que el botón izquierdo de abrir se ha pulsado automáticamente: la base de datos está abierta, y podemos trabajar con ella. Podríamos haber conseguido lo mismo poniéndonos sobre ella y pulsando ese botón. Luego la cerraremos con la opción CLOSE del menú OBJECT, o bien "despulsando" el botón de abrir. Al abrirla, aparece en la ventana de la derecha una nueva solapa: ENTER SQL. Podemos distinguir una base de datos abierta de una que no lo está porque el icono que la acompaña está rodeada por un cuadrado de color verde, como se ve en el dibujo. Si nos ponemos sobre ella, veremos esto:

Como hemos creado la base de datos, pero no le hemos añadido tablas, comprobamos pulsando el icono + que esa entrada de la lista está vacía:

Así que la primera sentencia que vamos a introducir será la de la creación de la tabla. Para ello, escribimos lo siguiente:

CREATE TABLE LIBROS( CODIGO INTEGER NOT NULL, TITULO VARCHAR(255) NOT NULL, AUTOR VARCHAR(100), TEMA VARCHAR(100), EDITORIAL VARCHAR(50),

PRECIO INTEGER, UNIDADES INTEGER, ISBN VARCHAR(25), PRIMARY KEY (CODIGO) );

y pulsamos sobre el botón de ejecutar. Podemos ver que ahora Tables sí que contiene una entrada: la tabla que acabamos de crear. Si nos ponemos sobre la propia tabla, nos aparecen más opciones:

De aquí, la pestaña que más nos interesa en este momento es DATA. ENTER SQL ya la conocemos, y TEXT únicamente nos muestra la definición de la tabla. Útil por si olvidamos de qué tipo eran los campos. Si nos ponemos sobre DATA, nos aparece esto:

Aquí podemos dar valores a los campos directamente, sin necesidad de escribir sentencias SQL. Además, en la parte superior derecha de la ventana ha salido una barra de botones que explicamos a continuación casi completamente (únicamente nos dejaremos dos de ellos). Esta barra de botones nos va a servir para movernos entre registros, añadir registros, borrar registros, actualizarlos... Sin embargo, como estamos aprendiendo, vamos a ver primero un ejemplo de inserción de un registro con la instrucción INSERT de SQL. Para ello, empezamos por situarnos en la pestaña ENTER SQL, e introducimos lo siguiente:

INSERT INTO LIBROS( CODIGO, TITULO, AUTOR, TEMA, EDITORIAL, PRECIO, UNIDADES, ISBN ) VALUES ( 1 , 'Manual de Matematicas' , 'I. Bronshteim' , 'Matematicas' , 'Mir' , 1500 , 10 , '5-38588-5' );

como se puede ver en el gráfico:

Al pulsar sobre el botón de ejecutar la instrucción, veremos que en la barra de estado pone "1 rows were affected". Si nos vamos a la solapa DATA, aún no veremos nada: eso es porque no hemos actualizado los datos. Vamos a explicar ahora para qué sirven los botones de la parte superior derecha:

Así que tendremos que pulsar el botón de actualizar datos para poder ver el resultado de la inserción:

Como no caben todos los datos, con ayuda de las barras de desplazamiento podremos ir comprobando que los valores han sido introducidos correctamente. Con todo esto, podemos seguir introduciendo datos para practicar con SQL, o directamente en la solapa DATA. Además, podemos también investigar qué sucede con las sentencias UPDATE, DELETE y SELECT. Como último ejemplo de este capítulo, vamos a ver el resultado de una SELECT (previamente, he insertado dos registros más que podeis insertar a vuestro gusto como ejercicio ;-) ). Escribimos lo siguiente: SELECT * FROM LIBROS WHERE PRECIO > 1000;

Y al pulsar sobre el botón que ejecuta la instrucción, obtenemos:

Al desplazarnos hasta llegar al campo PRECIO:

observamos que los campos han sido devueltos correctamente. Usar este programa para crear generadores, triggers, procedimientos, etc. es bastante sencillo. Normalmente haremos todo este trabajo en la pestaña ENTER SQL. Además, cada elemento tiene siempre la opción de desplegar datos sobre él. Por ejemplo, una tabla concreta despliega datos sobre quién es la clave primaria, qué claves ajenas tiene o qué triggers se han definido sobre ella (entre otros). Los procedimientos almacenados nos dirían cuáles son los parámetros de entrada, las vistas sus columnas... Es un programa muy intuitivo y agradable de manejar, así que el resto del aprendizaje os lo dejo a vosotros ;-)