12 octubre 2007

Trabajando con documentos XML (y III)

Aunque es posible trabajar con un documento XML usando solamente el componente XMLDocument y la interfaz IXMLNode es mucho más fácil utilizar el asistente XML Data Binding.

Dicho asistente toma los datos del esquema de un archivo XML a través de su archivo asociado DTD y realiza una nueva unidad con una interfaz que maneja nuestro documento XML sin tener que navegar por los nodos.

CREANDO UNA INTERFAZ PARA CLIENTES.XML

Para crear una unidad nueva para nuestro documento clientes.xml hay que hacer lo siguiente:

1. Seleccionamos en Delphi la opción File -> New -> Other...

2. Estando situados en la pestaña New seleccionamos el icono XML Data Binding y pulsamos OK.


3. En la ventana siguiente seleccionamos el archivo cli.dtd y pulsamos Next.


4. Después nos aparece otra ventana donde se nos permite modificar el nombre de la clase a crear así como los nombres que van tener las propiedades y métodos de la nueva clase. Lo dejamos como está y pulsamos Next.



5. La última pantalla del asistente nos muestra como va a ser definitivamente la interfaz que va a crear. Sólo nos queda pulsar Finish.



Va a generar la siguiente unidad:

{**************************************************************************}
{ }
{ XML Data Binding }
{ }
{ Generated on: 11/10/2007 11:15:57 }
{ Generated from: D:\Desarrollo\DelphiAlLimite\XML\cli.dtd }
{ Settings stored in: D:\Desarrollo\DelphiAlLimite\XML\cli.xdb }
{ }
{**************************************************************************}

unit UInterfazClientes;

interface

uses xmldom, XMLDoc, XMLIntf;

type

{ Forward Decls }

IXMLClientesType = interface;
IXMLClienteType = interface;

{ IXMLClientesType }

IXMLClientesType = interface(IXMLNodeCollection)
['{A21F5A80-EBA7-48F5-BFE1-EB9F390DFBBD}']
{ Property Accessors }
function Get_Cliente(Index: Integer): IXMLClienteType;
{ Methods & Properties }
function Add: IXMLClienteType;
function Insert(const Index: Integer): IXMLClienteType;
property Cliente[Index: Integer]: IXMLClienteType read Get_Cliente; default;
end;

{ IXMLClienteType }

IXMLClienteType = interface(IXMLNode)
['{624B6C2E-4E94-4CE0-A8D4-FE719AA7D975}']
{ Property Accessors }
function Get_Nombre: WideString;
function Get_Nif: WideString;
function Get_Saldopte: WideString;
function Get_Diaspago: WideString;
procedure Set_Nombre(Value: WideString);
procedure Set_Nif(Value: WideString);
procedure Set_Saldopte(Value: WideString);
procedure Set_Diaspago(Value: WideString);
{ Methods & Properties }
property Nombre: WideString read Get_Nombre write Set_Nombre;
property Nif: WideString read Get_Nif write Set_Nif;
property Saldopte: WideString read Get_Saldopte write Set_Saldopte;
property Diaspago: WideString read Get_Diaspago write Set_Diaspago;
end;

{ Forward Decls }

TXMLClientesType = class;
TXMLClienteType = class;

{ TXMLClientesType }

TXMLClientesType = class(TXMLNodeCollection, IXMLClientesType)
protected
{ IXMLClientesType }
function Get_Cliente(Index: Integer): IXMLClienteType;
function Add: IXMLClienteType;
function Insert(const Index: Integer): IXMLClienteType;
public
procedure AfterConstruction; override;
end;

{ TXMLClienteType }

TXMLClienteType = class(TXMLNode, IXMLClienteType)
protected
{ IXMLClienteType }
function Get_Nombre: WideString;
function Get_Nif: WideString;
function Get_Saldopte: WideString;
function Get_Diaspago: WideString;
procedure Set_Nombre(Value: WideString);
procedure Set_Nif(Value: WideString);
procedure Set_Saldopte(Value: WideString);
procedure Set_Diaspago(Value: WideString);
end;

{ Global Functions }

function GetClientes(Doc: IXMLDocument): IXMLClientesType;
function LoadClientes(const FileName: WideString): IXMLClientesType;
function NewClientes: IXMLClientesType;

const
TargetNamespace = '';

implementation

{ Global Functions }

function GetClientes(Doc: IXMLDocument): IXMLClientesType;
begin
Result := Doc.GetDocBinding('Clientes', TXMLClientesType, TargetNamespace) as IXMLClientesType;
end;

function LoadClientes(const FileName: WideString): IXMLClientesType;
begin
Result := LoadXMLDocument(FileName).GetDocBinding('Clientes', TXMLClientesType, TargetNamespace) as IXMLClientesType;
end;

function NewClientes: IXMLClientesType;
begin
Result := NewXMLDocument.GetDocBinding('Clientes', TXMLClientesType, TargetNamespace) as IXMLClientesType;
end;

{ TXMLClientesType }

procedure TXMLClientesType.AfterConstruction;
begin
RegisterChildNode('Cliente', TXMLClienteType);
ItemTag := 'Cliente';
ItemInterface := IXMLClienteType;
inherited;
end;

function TXMLClientesType.Get_Cliente(Index: Integer): IXMLClienteType;
begin
Result := List[Index] as IXMLClienteType;
end;

function TXMLClientesType.Add: IXMLClienteType;
begin
Result := AddItem(-1) as IXMLClienteType;
end;

function TXMLClientesType.Insert(const Index: Integer): IXMLClienteType;
begin
Result := AddItem(Index) as IXMLClienteType;
end;

{ TXMLClienteType }

function TXMLClienteType.Get_Nombre: WideString;
begin
Result := ChildNodes['nombre'].Text;
end;

procedure TXMLClienteType.Set_Nombre(Value: WideString);
begin
ChildNodes['nombre'].NodeValue := Value;
end;

function TXMLClienteType.Get_Nif: WideString;
begin
Result := ChildNodes['nif'].Text;
end;

procedure TXMLClienteType.Set_Nif(Value: WideString);
begin
ChildNodes['nif'].NodeValue := Value;
end;

function TXMLClienteType.Get_Saldopte: WideString;
begin
Result := ChildNodes['saldopte'].Text;
end;

procedure TXMLClienteType.Set_Saldopte(Value: WideString);
begin
ChildNodes['saldopte'].NodeValue := Value;
end;

function TXMLClienteType.Get_Diaspago: WideString;
begin
Result := ChildNodes['diaspago'].Text;
end;

procedure TXMLClienteType.Set_Diaspago(Value: WideString);
begin
ChildNodes['diaspago'].NodeValue := Value;
end;

end.

UTILIZANDO LA NUEVA INTERFAZ PARA CREAR DOCUMENTOS XML

La unidad creada por el asistente la he guardado con el nombre UInterfazClientes.pas lo que significa que hay que introducirla en la sección uses del formulario donde vayamos a utilizarla.

Vamos a ver como damos de alta un cliente utilizando dicha interfaz:

var
Clientes: IXMLClientesType;
begin
XML.FileName := ExtractFilePath( Application.ExeName ) + 'clientes.xml';
XML.Active := True;
Clientes := GetClientes( XML );

with Clientes.Add do
begin
Attributes['id'] := '3';
Nombre := 'FERNANDO RUIZ BERNAL';
Nif := '58965478T';
Saldopte := '150.66';
Diaspago := '45';
end;

XML.SaveToFile( ExtractFilePath( Application.ExeName ) + 'clientes5.xml' );
end;

He cargado el documento XML como siempre y utilizando la interfaz IXMLClientesType cargo la lista de clientes del documento clientes.xml. Después doy de alta un cliente y grabo el documento como clientes5.xml.

Una cosa cosa interesante que se puede hacer es activar la propiedad doAutoSave que está dentro de la propiedad Options del componente XMLDocument lo que implica que el documento se guardará automáticamente conforme vayamos modificando los elementos del documento XML.

La ventaja de convertir nuestro documento XML en una interfaz persistente es que ahora podemos manejar la lista de clientes como si fuera una base de datos utilizando los métodos get y set de cada uno de los campos así como las rutinas para alta, baja o modificación de elementos dentro del documento. Sólo es cuestión de echarle una mirada a la nueva unidad creada para ver las posibiliades de la misma.

Pruebas realizadas en Delphi 7.

11 octubre 2007

Trabajando con documentos XML (II)

Anteriormente vimos que cada documento XML podía llevar asociado un documento DTD. Los documentos DTD (Document Type Definition) definen la estructura y la sintaxis de un documento XML. Su misión es mantener la consistencia entre los elementos del documento XML para que todos los documentos de la misma clase mantengan un mismo estilo.

Nuestro documento cli.dtd va a ser el siguiente:

Veamos que hace cada línea:

!ELEMENT Clientes (Cliente*)

Aquí establecemos que el documento XML se va a llamar Clientes y que cada elemento se llamará Cliente. El asterístico significa que va a tener cero o más elementos de tipo Cliente. Si quisieramos que el nodo Cliente apareciese una o más veces utilizaríamos el caracter +.

!ELEMENT Cliente (nombre, nif, saldopte?, diaspago?)

La segunda línea nos dice de que campos está compuesto el nodo Cliente: nombre, nif, saldopte y diaspago. Todos los campos que no lleven el signo de interrogación son obligatorios (en este caso nombre y nif).

!ELEMENT nombre (#PCDATA)
!ELEMENT nif (#PCDATA)
!ELEMENT saldopte (#PCDATA)
!ELEMENT diaspago (#PCDATA)

Por último se describe el tipo de dato que van a contener los nodos finales. El atributo #PCDATA significa que puede contener cualquier valor.

Con este archivo al lado de nuestros documentos XML podemos hacer doble clic sobre los mismos para que se vean en cualquier navegador.

NAVEGANDO POR LOS NODOS DEL DOCUMENTO XML

Una vez que el documento ha sido analizado sintácticamente por la implementación DOM, los datos representados estarán disponibles en la jerarquía de nodos. Cada nodo corresponde a un elemento etiqueta del documento. Por ejemplo, para el documento de clientes.xml que hemos visto anteriormente tendríamos la siguiente jerarquía: El nodo raiz es Clientes que a su vez tiene nodos hijos con el nombre Cliente. Cada uno de esos nodos hijos tienen a su vez otros nodos hijos tales como (nombre, nif, importepte y diaspago). Esos nodos hijos actuan como los nodos finales de un arból ya no tienen más nodos hijos.

Para acceder a cada nodo se utiliza la interfaz IXMLNode, comenzando por el nodo raiz a través de la propiedad DocumentElement del componente XMLDocument.

LEYENDO EL VALOR DE LOS NODOS

Vamos a ver un ejemplo de cómo leer el saldo pentiende (saldopte) del primer cliente y mostrarlo por pantalla:

var
Cliente: IXMLNode;
begin
XML.LoadFromFile( ExtractFilePath( Application.ExeName ) + 'clientes.xml' );
XML.Active := True;
Cliente := XML.DocumentElement.ChildNodes[0];
ShowMessage( Cliente.ChildNodes['saldopte'].Text );
end;

Suponemos que el documento clientes.xml está en el mismo directorio que nuestro programa. Como se puede apreciar en el código hemos abierto el documento XML, lo hemos activado y a continuación hemos recogido el nodo del primer cliente dentro de la variable Cliente que es de tipo IXMLNode. Después hemos accedido a su nodo hijo llamado saldopte para leer su valor.

MODIFICANDO EL VALOR DE LOS NODOS

Utilizando el mismo sistema podemos modificar el valor de cada nodo. En el siguiente ejemplo voy a modificar el nombre del segundo cliente (ROSA MARTINEZ GUILLEN) por el de MARIA PEREZ ROJO:

var
Cliente: IXMLNode;
begin
XML.LoadFromFile( ExtractFilePath( Application.ExeName ) + 'clientes.xml' );
XML.Active := True;
Cliente := XML.DocumentElement.ChildNodes[1];
Cliente.ChildNodes['nombre'].Text := 'MARIA PEREZ ROJO';
XML.SaveToFile( ExtractFilePath( Application.ExeName ) + 'clientes2.xml' );
end;

Una vez modificado el nombre grabo todo el documento XML en otro archivo llamado clientes2.xml (aunque podía haber utilizado el mismo).

AÑADIENDO Y BORRANDO NODOS

Mediante el método AddChild podemos crear nuevos nodos hijos dentro de un documento XML. Veamos como dar de alta un nuevo cliente y guardar el archivo como clientes3.xml:

var
Cliente, Nodo: IXMLNode;
begin
XML.LoadFromFile( ExtractFilePath( Application.ExeName ) + 'clientes.xml' );
XML.Active := True;
Cliente := XML.DocumentElement.AddChild( 'Cliente' );
Cliente.Attributes['id'] := '3';
Nodo := Cliente.AddChild( 'nombre' );
Nodo.Text := 'PABLO PALAZON ALCOLEA';
Nodo := Cliente.AddChild( 'nif' );
Nodo.Text := '79469163E';
Nodo := Cliente.AddChild( 'saldopte' );
Nodo.Text := '0.00';
Nodo := Cliente.AddChild( 'diaspago' );
Nodo.Text := '15';
XML.SaveToFile( ExtractFilePath( Application.ExeName ) + 'clientes3.xml' );
end;

En esta ocasión utilizamos dos nodos: Cliente para crear el nodo padre y Nodo para crear cada uno de los nodos hijos.

Por último podemos eliminar elementos utilizando el método Delete cuyo parámetro es el número de nodo hijo que deseamos eliminar (siendo cero el primer elemento). Para eliminar el primer cliente de la lista hacemos los siguiente:

begin
XML.LoadFromFile( ExtractFilePath( Application.ExeName ) + 'clientes.xml' );
XML.Active := True;
XML.DocumentElement.ChildNodes.Delete( 0 );
XML.SaveToFile( ExtractFilePath( Application.ExeName ) + 'clientes4.xml' );
end;

Este código coge la lista de los dos clientes iniciales, elimina el primero y guarda el documento como clientes4.xml. De esta manera podemos crear una pequeña base de datos utilizando documentos XML.

En el próximo artículo veremos como simplificar aún más el manejo de archivos XML utilizando el asistente XML Data Binding.

Pruebas realizadas en Delphi 7.

10 octubre 2007

Trabajando con documentos XML (I)

Un documento XML (Extensible Markup Language) contiene un lenguaje de etiquetas para almacenar información de forma estructurada. Es similar a las páginas web HTML, exceptuando que sólo guarda la información y no la forma de visualizarla. Los documentos XML proporcionan una forma simple para almacenar la información que permite ser comprendida fácilmente.

Además se ha convertido de hecho en un estándar, siendo utilizado en aplicaciones web, comunicaciones, etc. Se trata de un lenguaje de intercambio de datos que ya es soportado por la mayoría de lenguajes de programación.

Los documentos XML manejan la información de forma jerárquica, siendo las etiquetas las que describen la información de cada elemento así como los elementos hijos. Veamos un ejemplo de un documento XML:

Este ejemplo muestra como está almacenada la información en un documento XML. La primera línea contiene la declaración de un documento XML. Aunque declaración es opcional es recomendable introducirla en todos los documentos XML. Es este caso nos dice que es un documento XML con versión 1.0 y que utiliza la codificación de caracteres UTF-8.

La segunda línea nos informa que el documento se llama Clientes y que va a estar enlazado con un documento externo llamado cli.dtd. Los documentos DTD se utilizan para definir las reglas de cómo tienen que estar estructurados los documentos XML. En nuestro caso define la regla de cómo deben estar definida la estructura de un cliente. Sería algo así como la definición de un esquema para la jerarquía de los datos del cliente. No es obligatorio definir un DTD por cada documento XML.

La información que se guarda en los documentos XML comienza con un nodo raiz Clientes que a su vez tiene nodos hijos: Cliente, nombre, etc. Las etiquetas a su vez pueden contener dentro valores predeterminados, por ejemplo Cliente tiene el valor id="1".

Aunque es posible trabajar directamente con un documento XML utilizando cualquier procesador de textos (incluso el Bloc de Notas de Windows) existen aplicaciones para editar este tipo de documentos. El consorcio internacional W3C define un conjunto de reglas estándar que definen como debe crearse un documento XML cuyo nombre es DOM (Document Object Model).

USANDO DOM

Las interfaces denifidas por el estandar DOM contienen la implementación de diferentes documentos XML suministrados por terceras partes llamados vendedores (vendors). Si no deseamos utilizar la implementación DOM de estos vendedores, Delphi permite utilizar un mecanismo de registro adicional para crearnos nuestra propia implementación de documentos XML.

La unidad XMLDOM incluye declaraciones para todas las interfaces DOM definidas por las especificaciones de nivel 2 para documentos XML según el consorcio W3C. Cada vendedor DOM proporciona sus propias interfaces para manejar documentos XML. Una interfaz DOM viene a ser algo así como un driver para manejar documentos XML.

Para que Delphi pueda utilizar un documento DOM de algun vendedor en concreto hay que añadir la unidad correspondiente a dicha implementación DOM. Estas unidades finalizan con la cadena 'xmldom'. Por ejemplo, la unidad para la implementación de Microsoft es MSXMLDOM, la unidad para documentos de IBM es IBMXMLDOM y la unidad para implementaciones Open XML es OXMLDOM.

Si quisieramos crear nuestra propia implementación DOM tendríamos que crear una unidad que defina una clase descendiente de la clase TDOMVendor. Se haría de la siguiente manera:

- En nuestra clase descendiente, debemos sobrescribir dos métodos: el método Description, el cual devuelve una cadena con el identificador del venvedor y el método DOMImplementation donde define la interfaz IDOMImplementation.

- Después registramos nuestra nueva unidad llamando al procedimiento RegistrerDOMVendor y ya estaría lista para poder ser utilizada.

- Y si queremos eliminarla de las implementaciones estándar DOM debemos anular el registro llamando al procedimiento UnRegisterDOMVendor, el cual debería estar en la sección finalization.

Algunos vendedores suministran extensiones a las interfaces estandar DOM. Para que puedas usar esas extensiones la unidad XMLDOM define la interfaz IDOMNodeEx, la cual es descendiente de la interfaz estandar IDOMNode.

Podemos trabajar directamente con interfaces DOM para leer y editar documentos XML. Simplemente llamamos la la función GetDOM para obtener el intefaz IDOMImplementation, el cual proporciona un punto de partida.

TRABAJANDO CON COMPONENTES XML

El punto de partida para comenzar a trabajar con documentos XML es utilizando el componente de la clase TXMLDocument. Para poder crear un documento XML hay que seguir los siguientes pasos:

1. Añadimos el componente XMLDocument a nuestro formulario o módulo de datos. Este componente se encuentra en la pestaña Internet.

2. Seleccionamos en la propiedad DOMVendor la implementación del documento DOM que queremos usar. Por defecto aparece seleccionada la de Microsoft (MSXML).

3. Dependiendo de la implementación seleccionada, podemos modificar sus opciones en propiedad ParseOptions para configurar como va a procesarse el documento XML. Un parser viene a ser algo así como un analizador sintáctico.

4. Para trabajar con un documento XML que ya existe hay que especificar el documento de la siguiente manera:

- Si el documento esta almacenado en un archivo, ponemos en FileName el nombre del archivo.

- O bien podemos meter el texto XML dentro del mismo componente XMLDocument utilizando su propiedad XML.

5. Activamos el documento XML poniendo la propiedad Active a True.

Una vez que tenemos activo el documento, podremos navegar por su jerarquía de nodos leyendo o modificando sus valores. El nodo raiz está disponible en la propiedad DocumentElement.

En el próximo artículo veremos ejemplos de código fuente para leer y modificar documentos XML con Delphi.

Pruebas realizadas en Delphi 7.

09 octubre 2007

Leyendo los metadatos de una tabla de Interbase/Firebird

No hay nada que cause más pereza a un programador que la actualización de campos en las bases de datos de nuestros clientes. Hay muchas maneras de hacerlo: desde archivos de texto con metadatos, archivos SQL o incluso actualizaciones por Internet con FTP o correo electrónico.

Yo lo que suelo hacer es tener un archivo GDB o FDB (según sea Interbase o Firebird respectivamente) que contiene todas las bases de datos vacías. Si tengo que ampliar algún campo lo hago sobre esta base de datos.

Después cuando tengo que actualizar al cliente lo que hago es mandarle mi GDB vacío y mediante un pequeño programa que tengo hecho compara las estructuras de la base de datos de mi GDB vacío y las del cliente, creando tablas y campos nuevos según las diferencias sobre ambas bases de datos.

Ahora bien, ¿Cómo podemos leer el tipo de campos de una tabla? Pues en principio tenemos que el componente IBDatabase tiene la función GetTableNames que devuelve el nombre de las tablas de una base de datos y la función GetFieldNames que nos dice los campos pertenecientes a una tabla en concreto. El problema radica en que no me dice que tipo de campo es (float, string, blob, etc).

LEYENDO LOS CAMPOS DE UNA TABLA

Para leer los campos de una tabla utilizo el componente de la clase TIBQuery situado en la pestaña Interbase. Cuando este componente abre una tabla carga el nombre de los campos y su tipo en su propiedad FieldDefs. Voy a realizar una aplicación sencilla en la cual seleccionamos una base de datos Interbase o Firebird y cuando se elija una tabla mostrará sus metadatos de esta manera:


Va a contener los siguientes componentes:


- Un componente Edit con el nombre RUTADB que va a guardar la ruta de la base de datos.

- Un componente de la clase TOpenDialog llamado AbrirBaseDatos para buscar la base de datos Firebird/Interbase.

- Un botón llamado BExaminar.

- Un componente ComboBox llamado TABLAS que guardará el nombre de las tablas de la base de datos.

- Un componente IBDatabase llamado BaseDatos que utilizaremos para conectar.

- Un componente IBTransaction llamado Transaccion para asociarlo a la base de datos.

- Un componente IBQuery llamado IBQuery que utilizaremos para abrir una tabla.

- Y por último un campo Memo llamado Memo para mostrar la información de los metadatos.

Comenzemos a asignar lo que tiene que hacer cada componente:

- Hacemos doble clic sobre el componente BaseDatos y le damos de usuario SYSDBA y password masterkey. Pulsamos Ok y desactivamos su propiedad LoginPrompt.

- Asignamos el componente Transaccion a los componentes BaseDatos y IBQuery.

- Asignamos el componente BaseDatos a los componentes Transaccion y IBQuery.

- En la propiedad Filter del componente AbrirBaseDatos ponemos:

Interbase|*.gdb|Firebird|*.fdb

- Al pulsar el botón Examinar hacemos lo siguiente:

procedure TFormulario.BExaminarClick( Sender: TObject );
begin
if AbrirBaseDatos.Execute then
begin
RUTADB.Text := AbrirBaseDatos.FileName;
BaseDatos.DatabaseName := '127.0.0.1:' + RUTADB.Text;

try
BaseDatos.Open;
except
on E: Exception do
Application.MessageBox( PChar( E.Message ), 'Error al abrir base de datos',
MB_ICONSTOP );
end;

BaseDatos.GetTableNames( TABLAS.Items, False );
end;
end;

Lo que hemos hecho es abrir la base de datos y leer el nombre de las tablas que guardaremos dentro del ComboBox llamado TABLAS.

Cuando el usuario seleccione una tabla y pulse el botón Mostrar hacemos lo siguiente:

procedure TFormulario.BMostrarClick( Sender: TObject );
var
i: Integer;
sTipo: String;
begin
with IBQuery do
begin
Memo.Lines.Add( 'CREATE TABLE ' + TABLAS.Text + ' (' );

SQL.Clear;
SQL.Add( 'SELECT * FROM ' + TABLAS.Text );
Open;

for i := 0 to FieldDefs.Count - 1 do
begin
sTipo := '';

if FieldDefs.Items[i].FieldClass.ClassName = 'TIBStringField' then
sTipo := 'VARCHAR(' + IntToStr( FieldByName( FieldDefs.Items[i].Name ).Size ) + ')';

if FieldDefs.Items[i].FieldClass.ClassName = 'TFloatField' then
sTipo := 'DOUBLE PRECISION'; // También podría ser FLOAT (32 bits) aunque prefiero DOUBLE (64 bits)

if FieldDefs.Items[i].FieldClass.ClassName = 'TIntegerField' then
sTipo := 'INTEGER';

if FieldDefs.Items[i].FieldClass.ClassName = 'TDateField' then
sTipo := 'DATE';

if FieldDefs.Items[i].FieldClass.ClassName = 'TTimeField' then
sTipo := 'TIME';

if FieldDefs.Items[i].FieldClass.ClassName = 'TDateTimeField' then
sTipo := 'TIMESTAMP';

if FieldDefs.Items[i].FieldClass.ClassName = 'TBlobField' then
sTipo := 'BLOB';

// ¿Es un campo obligatorio?
if FieldByName( FieldDefs.Items[i].Name ).Required then
sTipo := sTipo + ' NOT NULL';

Memo.Lines.Add( ' ' + FieldDefs.Items[i].Name + ' ' + sTipo );

// Si no es el último campo añadimos una coma al final
if i < FieldDefs.Count - 1 then
Memo.Lines[Memo.Lines.Count-1] := Memo.Lines[Memo.Lines.Count-1] + ',';
end;

Memo.Lines.Add( ')' );
Close;
Transaction.Active := False;
end;
end;

Lo que hace este procedimiento es abrir con el componente IBQuery la tabla seleccionada y según los tipos de campos creamos la SQL de creación de la tabla.

Este método también nos podría ser útil para hacer un programa que copie datos entre tablas Interbase/Firebird.

Pruebas realizadas con Firebird 2.0 y Delphi 7.


PUBLICIDAD

lentillas

bajar de peso

bajar peso

08 octubre 2007

Generando números aleatorios

Las funciones de las que disponen los lenguajes de programación para generar números aleatorios se basan en una pequeña semilla según la fecha del sistema y a partir de ahí se van aplicando una serie de fórmulas se van generando números al azar según los milisegundos que lleva el PC arrancado.

Dephi dispone de la función Random para generar números aleatorios entre 0 y el parámetro que se le pase. Pero para que la semilla no sea siempre la misma es conveniente inicializarla utilizando el procedimiento Randomize.

Por ejemplo, si yo quisiera inventarme 10 números del 1 y 100 haría lo siguiente:

procedure TFormulario.Inventar10Numeros;
var
i: Integer;
begin
Randomize;

for i := 1 to 10 do
Memo.Lines.Add( IntToStr( Random( 100 ) + 1 ) );
end;

El resultado lo he volcado a un campo Memo.

INVENTANDO LOS NUMEROS DE LA LOTO

Supongamos que quiero hacer el típico programa que genera automáticamente las combinaciones de la loto. El método es tan simple como hemos visto anteriormente:

procedure TFormulario.InventarLoto;
var
i: Integer;
begin
Randomize;

for i := 1 to 6 do
Memo.Lines.Add( IntToStr( Random( 49 ) + 1 ) );
end;

Pero así como lo genera es algo chapucero. Primero tenemos el problema de que los números inventados no los ordena y luego podría darse el caso de el ordenador se invente un número dos veces.

Para hacerlo como Dios manda vamos a crear la clase TSorteo encargada de inventarse los 6 números de la loto y el complementario. Además lo vamos a hacer como si fuera de verdad, es decir, vamos a crear un bombo, le vamos a introducir las 49 bolas y el programa las va a agitar y sacará una al azar. Y por último también daremos la posibilidad de excluir ciertos números del bombo (por ejemplo el 1 y 49 son los que menos salen por estadística).

Comencemos creando la clase TSorteo en la sección type:

type
TSorteo = class
public
Fecha: TDate;
Numeros: TStringList;
Complementario: String;
Excluidos: TStringList;

constructor Create;
destructor Destroy; override;
procedure Inventar;
procedure Excluir( sNumero: String );
end;

Como podemos ver en la clase los números inventados y los excluidos los voy a meter en un StringList. El constructor de la clase TSorteo va a crear ambos StringList:

constructor TSorteo.Create;
begin
Numeros := TStringList.Create;
Excluidos := TStringList.Create;
end;

Y el destructor los liberará de memoria:

destructor TSorteo.Destroy;
begin
Excluidos.Free;
Numeros.Free;
end;

Nuestra clase TSorteo también va a incluir un método para excluir del sorteo el número que queramos:

procedure TSorteo.Excluir( sNumero: String );
begin
// Antes de excluirlo comprobamos si ya lo esta
if Excluidos.IndexOf( sNumero ) = -1 then
Excluidos.Add( sNumero );
end;

Y aquí tenemos la función que se inventa el sorteo evitando los excluidos:

procedure TSorteo.Inventar;
var
Bombo: TStringList;
i, iPos1, iPos2: Integer;
sNumero, sBola: String;
begin
// Metemos las 49 bolas en el bombo
Bombo := TStringList.Create;
Numeros.Clear;

for i := 1 to 49 do
begin
sNumero := CompletarCodigo( IntToStr( i ), 2 );

if Excluidos.IndexOf( sNumero ) = -1 then
Bombo.Add( sNumero );
end;

// Agitamos las bolas con el método de la burbuja
if Bombo.Count > 0 then
for i := 1 to 10000 + Random( 10000 ) do
begin
// Nos inventamos dos posiciones distintas en el bombo
iPos1 := Random( Bombo.Count );
iPos2 := Random( Bombo.Count );

if ( iPos1 >= 0 ) and ( iPos1 <= 49 ) and ( iPos2 >= 0 ) and ( iPos2 <= 49 ) then
begin
// Intercambiamos las bolas en esas dos posiciones inventadas
sBola := Bombo[iPos1];
Bombo[iPos1] := Bombo[iPos2];
Bombo[iPos2] := sBola;
end;
end;

// Vamos sacando las 6 bolas al azar + complementario
for i := 0 to 6 do
begin
if Bombo.Count > 0 then
iPos1 := Random( Bombo.Count )
else
iPos1 := -1;

if ( iPos1 >= 0 ) and ( iPos1 <= 49 ) then
sBola := Bombo[iPos1]
else
sBola := '';

// ¿Es el complementario?
if i = 6 then
// Lo sacamos aparte
Complementario := sBola
else
// Lo metemos en la lista de números
Numeros.Add( sBola );

// Sacamos la bola extraida del bombo
if ( iPos1 >= 0 ) and ( iPos1 <= 49 ) and ( Bombo.Count > 0 ) then
Bombo.Delete( iPos1 );
end;

// Ordenamos los 6 números
Numeros.Sort;

Bombo.Free;
end;

El procedimiento Inventar hace lo siguiente:

1º Crea un bombo dentro de un StringList y le mete las 49 bolas.

2º Elimina los número excluidos si los hay (los excluidos hay que meterlos en dos cifras, 01, 07, etc.)

3º Agita los números dentro del bombo utilizando del método de la burbuja para que queden todas las bolas desordenadas.

4º Extrae las 6 bolas y el complementario eligiendo a azar dos posiciones del StringList para hacerlo todavía mas rebuscado. Al eliminar la bola extraida evitamos así números repetidos, tal como si fuera el sorteo real.

5º Una vez inventados los números los deposita en el StringList llamado Numeros y elimina de memoria el Bombo.

Ahora vamos a utilizar nuestra clase TSorteo para generar una combinación:

procedure TFormulario.InventarSorteo;
var
S: TSorteo;
begin
Randomize;
S := TSorteo.Create;
S.Inventar;
Memo.Lines.Add( S.Numeros.Text );
S.Free;
end;

Si quisiera excluir del sorteo los número 1 y 49 haría lo siguiente:

var
S: TSorteo;
begin
Randomize;
S := TSorteo.Create;
S.Excluir( '01' );
S.Excluir( '49' );
S.Inventar;
Memo.Lines.Add( S.Numeros.Text );
S.Free;
end;

Este es un método simple para generar los números de la loto pero las variantes que se pueden hacer del mismo son infinitas. Ya depende de la imaginación de cada cual y del uso que le vaya a dar al mismo.

Igualmente sería sencillo realizar algunas modificaciones para inventar otros sorteos tales como el gordo de la primitiva, el sorteo de los euromillones o la quiniela de fútbol.

Pruebas realizadas en Delphi 7.

Publicidad