Free Web space and hosting from latinowebs.com
Search the Web

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ómo 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:

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:

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 }
   CompDescDeTDateSet.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:

Es FALSE en todos los demás casos.

EOF (end of file)

Es TRUE si:

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

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:

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

 


ANEXOS

 

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.

Finalizamos pulsando el botón de "Aplicar" , con lo que ya tenemos dado de alta el alias. A 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:

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