componentes de conexiÓn a bases de datos componentes de

Manual de desarrollador - Componentes HBX

Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co

COMPONENTES DE CONEXIÓN A BASES DE DATOS

COMPONENTES DE CONEXIÓN HYPERBASE SERVER

COMPONENTES DE CONEXIÓN A HYPERBASE LOCAL

VERSION 3.5

HyperSoft S.A.S.

Copyright (c) 2004-2013 por Gustavo Enríquez

e-mail: [email protected]

[email protected]

home page: http://www.hyper-soft.co



Tabla de contenido Que es HyperBase Suite?............................................................................................................... 3

Que son los componentes HBX? .................................................................................................... 3

Para que plataformas están disponibles los Componentes HBX? .................................................. 3

Que lenguajes soportan los HBX? .................................................................................................. 3

A que bases de datos permiten conectarse los componentes HBX? .............................................. 4

Que se requiere para la distribución de la aplicación final? .......................................................... 4

PHP. .............................................................................................................................................. 5

JAVA. ............................................................................................................................................. 6

C Estandar. .................................................................................................................................... 6

Delphi consola. .............................................................................................................................. 7

Delphi Visual. ................................................................................................................................ 8

Delphi IPhone, IPad o Android. ..................................................................................................... 9

THbxConnection: ......................................................................................................................... 10

THbQuery: ................................................................................................................................... 10

THBClientCallBacks:..................................................................................................................... 10

THBServerList: ............................................................................................................................. 10

Otras funciones del HBXConnection ............................................................................................ 14

Manejo de Transacciones (Modo Local) ...................................................................................... 15

Multitareas (THRead Safe) ......................................................................................................... 17

Conectar a una base de datos ..................................................................................................... 18

Ejecución de Procedimientos remotos ........................................................................................ 19

Guardar cambios localmente sin aplicar ..................................................................................... 20

Leer los datos del Query por bloques .......................................................................................... 21

THBQuery como Memory Table .................................................................................................. 22

THBQuery "Live Query" con múltiples tablas .............................................................................. 23



Que es HyperBase y los componentes HBX

Que es HyperBase Suite? HyperBase Suite es un conjunto de herramientas que permiten implementar de forma fácil, rápida

y segura la capa de lógica de negocio en las aplicaciones corporativas. Es un middleware de Datos,

Procedimientos, Reportes y Gráficos entre otros.

HyperBase está diseñado para trabajar sobre redes de públicas de internet, lo cual exige que

implemente opciones de recuperación de conexiones de forma automática, redundancia de

conectividad, escalabilidad y los más importante conexiones seguras, por eso HyperBase maneja

todas sus conexiones bajo protocolos SSL además de encriptación con llave privada y compresión

de datos.

Que son los componentes HBX? Los componentes HBX representan las herramientas de conexión al HyperBase en sus dos

versiones, en la versión Local y versión Server. en otras palabras podría decirse que los

componentes HBX permiten la conexión a las bases de datos, ejecutar consultas y procedimientos

almacenados sobre las bases de datos y en el caso del server, permite ejecutar consultas y

procedimientos almacenados sobre HyperBase.

Opcionalmente en el caso que estén disponibles los módulos de Report Server y Chart Server,

permiten la ejecución de de reportes y gráficos estadísticos en forma remota al servidor.

Para que plataformas están disponibles los Componentes HBX? En modo Local solo están disponibles para Windows, desde las versiones XP en adelante, con

conexión al servidor, existen versiones para Android, IOS (IPhone, IPad), MAC OSX y Windows.

Que lenguajes soportan los HBX? Hay conectores nativos para PHP, Java, C++ y Delphi sobre Windows, también existen drivers

ActiveX y ODBC en Windows que permite la conexión desde cualquier lenguaje que soporte este

tipo de conexiones, por otro lado Android, IOS y OSX solo están soportados en lenguaje Delphi y

C++ de Embarcadero RadStudio XE5.



A que bases de datos permiten conectarse los componentes HBX? Permite las conexiones nativas a Oracle, MS SQL Server, IBM DB2, Postgres, Interbase, FireBird,

MySQL, Informix, SyBase ASA, SyBase ASE y otros por medio de ODBC.

Que se requiere para la distribución de la aplicación final? Los componentes HBX son Royalty Free, eso quiere decir que puede distribuir los componentes

como parte de su aplicación sin ningún costo para el cliente final. Sin embargo es posible que sea

necesario instalar software adicional cliente que es distribuido con el motor de la base de datos.

En el caso particular de Postgres Sql, será necesario adquirir el driver correspondiente.

Existen dos modos de utilizar los componentes HBX, el modo Local y el Modo Server, El modo local

funciona como una aplicación Cliente/Servidor tradicional, mientras que en modo server se

convierte en una aplicación N-Tiers (Multiples capas), eso permite construir o partir de

aplicaciones Cliente/Servidor tradicionales y llevarlas a aplicaciones de 3-Capas de una forma fácil

e intuitiva.

En modo Local los conectores HBX requieren la instalación en el equipo cliente de los drivers para

su conexión y dependiendo del motor de base de datos, podría requerir la instalación del software

del cliente de la base de datos en cada una de las máquinas donde se ejecutará el programa.

En modo Remoto y aplicaciones desarrolladas en lenguajes diferentes a Delphi XE5, se requiere de

solamente un archivo .dll que realiza la conexión con el servidor HyperBase.

Para las aplicaciones desarrolladas en Delphi XE5 y posteriores, la conexión con el servidor

HyperBase no requiere ningún tipo de archivo adicional, así que bastará con el ejecutable para su

ejecución de forma remota.



Descripción básica de uso en los diferentes lenguajes, PHP, Java, C y Delphi.

Realizaremos una breve descripción del funcionamiento de los componentes HBX en los diferentes

lenguajes.

PHP. Ejercicio realizado en PHP, realiza una consulta a la tabla ciudades, guarda el contenido en

formato XML en una carpeta local y luego muestra el resultado de la consulta en una página

HTML.

<?php include '\http\www\sig\hbclasses.php'; $HbConn = new THbConn("","","127.0.0.1",211,"Log in","Password"); $HbConn->DoConnect(); $Query = $HbConn->NewQuery("DbScript","Select * from ciudades",-1); $Query->Open(); $Query->SaveToFile("c:/temp/queryciudades.xml"); //echo $Query->GetXmlData(); $Query->First(); while ($Query->Eof() != TRUE) { print($Query->FieldValue("NOM_CIUDAD")); print("<br>"); $Query->Next(); } $HbConn->DoDisconnect(); ?>



JAVA.

Ejercicio realizado en Java, realiza una consulta a la tabla ciudades y muestra el resultado de

la consulta en una página HTML.

public static void main(String[] args) { JHBConnection con = new JHBConnection("","","127. 0.0.1",211,"Login", "Password"); con.DoConnect(); JHBQuery query = con.NewQuery("DbScrip", "select * from ciudades ",-1); query.Open(); int n = query.FieldCount(); //System.out.println(n); for (int i = 0; i < n; i++) { System.out.println(query.GetField(i).getFFieldNa me()+"="+ query.FieldByName("nom_ciudad").GetAsString() ); } query.Close(); query.Destroy(); new JNIFrame(){ public void cerrando(JHBConnection con){ System.out.println("cerrando2..."); if(con!=null && con.GetConnected()) con.Destroy(); } }; } }

C Estandar. Ejercicio realizado en C Estandar, no se utiliza la Programación orientada a objetos ni ninguna

de las características modernas del lenguajes.

void main(void) { int DbHandle; int TableHandle; int I; DbHandle = RHBNewConnection("", ""); I = RHBOpenConnection(DbHandle, "127.0.0.1", 211 ,"Login","Password"); TableHandle = RHBNewQuery(DbHandle, "DbScript", "Select * from Ciudades", -1); RHBOpen(TableHandle); RHBSaveToFile(TableHandle, "c:\\temp\\queryciuda des.xml"); RHBFreeQuery(TableHandle); RHBCloseConnection(DbHandle); printf("Fin\n"); }



Delphi consola. Ejercicio realizado en Delphi compatible desde Delphi 7 hasta Delphi XE5, en sistemas

operativos Windows, Mac, Android y el IOS.

Var

DbConn : THBXConnection; Query: THbQuery; begin

DbConn := THBXConnection.Create( 'serverhost' , '211' , 'login' , 'password' ); DbConn.ConnectionType := TcxNative; DbConn.Open; Query := DbConn.NewQuery( 'DbScript' , 'select * from ciudades' ); Query.Open; Query.SaveToFile(FilePath+'queryciudades.xml', d fXMLUTF8);

While not Query.Eof do Begin

//La siguiente instrucción cambia de acuerdo a la plataforma //Dado que Writeln es de tipo consola Writeln(Query.Fields[0].FieldName+' : '+Query .Fields[0].AsString); Query.Next; End;

Query.Close; DbConn.Close; end;



Delphi Visual. Ejercicio realizado en Delphi compatible desde Delphi 7 hasta Delphi XE5, en sistemas

operativos Windows, Mac.

El código fuente sería el siguiente:



Delphi IPhone, IPad o Android.

Ejercicio realizado en Delphi XE5 para Android o IOS, en el uso de dispositivos móviles es

indispensable el uso del servidor HyperBase, no es posible trabajar en modo Local.



Componentes HBX Esta es una lista de los componentes HBX y los comparamos con los BDE que son los más

conocidos de Delphi.

Componentes HBX

THbxConnection: Este componente realiza la conexión a un servidor ya sea remoto o local, En el caso de

conexión Local, es el mismo componente quien administra las diferentes conexiones a bases

de datos a las cuales se tiene acceso. si es conexión Remota, será el servidor HyperBase

quien administrará las conexiones a las bases de datos.

THbQuery: El componente de Query permite cumplir una gran variedad de funciones, desde simular

una tabla en memoria, representar una tabla de la base de datos, un query con la propiedad

"Request live" activada, un store procedure y los sqlUpdate query entre otras cosas..

THBClientCallBacks: Este componentes solo está disponible a partir de la versión XE2 de Delphi y permite la

comunicación de mensajes entre las aplicaciones cuando trabajan con el servidor

HyperBase. Implementa un Middleware de mensajes entre los clientes del HyperBase,

permitiendo el envío de mensajes o comandos P2P y Broadcast.

Nota: Solo funciona en modo Server y versiones Delphi XE2 en adelante

THBServerList: Permite la implementación del LoadBalance desde el Cliente, Este componentes administra

una lista de servidores de los cuales el HbxConnection seleccionará para conectarse si está

habilitada la opción de LoadBalance, en caso de no estar disponible el servidor, lo marcará

como no disponible e intentará con el siguiente en la lista

Nota: Solo funciona en modo Server Server y versiones Delphi XE2 en adelante



Configuración de conexiones en modo Local Es posible utilizar las conexiones a bases de datos en tiempo de diseño dentro del Delphi, sin

embargo para la instalación de los clientes, se recomienda realizar la configuración dinámicamente

dentro del programa.

Las conexiones locales están disponibles solo para Windows y desde Delphi 7 en adelante, para

MAC OSX, IOS o Android solo está disponible la versión de conexión remota al HyperBase Server.

La herramienta para la configuración de las conexiones en Windows es el DbAdmin, en ella es

posible crear conexiones a las bases de datos comerciales más conocidas o por medio de ODBC a

otras conexiones a Bases de Datos.

Es posible Administrar conexiones a bases de datos sobre la LAN, que serán utilizadas por las

aplicaciones tanto en tiempo de ejecución utilizando el componente THBXConnection.

Las conexiones del HyperBase en modo Local LAN utilizan el mismo sistema de conexión del

DBExpress, esto quiere decir que son conexiones nativas a las bases de datos, y tienen

adicionalmente un conector ODBC que permite realizar conexiones por medio de esta tecnología.

Nota: Es necesario iniciar el DbAdmin con permisos de Administrador, ya que requiere

almacenar información en el Registry del systema. Esta opción se realiza así para evitar

configuraciones no autorizadas.



Cómo Configurar una base de datos en tiempo de ejecución

Para implementar la funcionalidad de conexión Local en HyperBase, se distribuye con los

componentes HBX un Mini Servidor de HyperBase, que implementa las funcionalidades básicas del

servidor y que permite mantener la compatibilidad en todas las versiones de Delphi.

En los siguientes diagramas se muestra la arquitectura de los dos modelos, en el modelo Server

las conexiones a las bases de

datos y los permisos de

acceso se le asignan

directamente al servidor

HBServer, por medio de una

herramienta llamada HB

SqlTools, en este modelo no

es posible crear una conexión

a una base de datos en

tiempo de ejecución. Solamente el administrador podrá crear nuevas conexiones y con los

permisos adecuados sobre el servidor.

En el modelo local la conexión se realiza en forma directa y el servidor local se ejecuta en el mismo

equipo con la aplicación y se distribuye como un archivo .dll con el nombre de HBLConn.dll, el cual

debe ser distribuido junto con el ejecutable.

En este modelo Local,

primero es necesario

realizar la conexión con

el servidor HBServer

Local y luego se le indica

la acción que se quiere

realizar, en el caso que

nos ocupa, adicionar una

nueva conexión a la base

de datos.

TDBXConnection HBServer

Query1

Query2

Query3

QueryN

TCP/IPHTTPHTTPS

HyperBase Server

TDBXConnection HBServerLocal

Query1

Query2

Query3

QueryN

Directo

HyperBase Local



En este ejemplo primero es necesario conectarse al servidor local, para ello se instancia la

propiedad DbConn.ConnectionType := TcxLocal, de esta manera el conector utilizará

el modelo Cliente/Servidor local, como la conexión se realiza en el mismo computador, no se

requiere especificar ningún otro parámetro como Host, Login o Password.

Una vez realizada la conexión con el servidor, se procede a adicionar un alias de la base de datos,

junto con los parámetros de conexión, esta función sobrescribe cualquier conexión previa,

incluyendo las definidas en el DBAdmin.

Esta conexión solo estará disponible en tiempo de ejecución, si desea establecer una conexión en

tiempo de diseño, debe realizarse por medio de la herramienta DBAdmin, descrita en la sección

anterior.

Var DbConn: THBXConnection; Query: THbQuery; DbParams : TStringList; begin DbParams := TStringList.Create; DbParams.Add( 'HBDriverType=DBX' ); DbParams.Add( 'RoleName=RoleName' ); DbParams.Add( 'User_Name=sysdba' ); DbParams.Add( 'Password=masterkey' ); DbParams.Add( 'ServerCharSet=' ); DbParams.Add( 'SQLDialect=3' ); DbParams.Add( 'ErrorResourceFile=' ); DbParams.Add( 'LocaleCode=0000' ); DbParams.Add( 'BlobSize=-1' ); DbParams.Add( 'CommitRetain=False' ); DbParams.Add( 'WaitOnLocks=True' ); DbParams.Add( 'IsolationLevel=ReadCommitted' ); DbParams.Add( 'Trim Char=False' ); DbParams.Add( 'GetDriverFunc=getSQLDriverINTERBASE' ); DbParams.Add( 'LibraryName=dbxint.dll' ); DbParams.Add( 'VendorLib=GDS32.DLL' ); DbParams.Add( 'Database=\MYDATABASE.GDB' ); DbParams.Add( 'DriverName=InterBase' ); DbConn := THBXConnection.Create(Self); DbConn.ConnectionType := TcxLocal; DbConn.AddDataBase( 'DbName' , DbParams); DbConn.Open;



Una vez conectado al servidor HbServer Local, es posible realizar otras operaciones con la

conexión como las siguientes:

• Function TestDb(Params: TStrings; Var Msg: String): Boolean

Esta función permite probar la conexión antes de adicionarla, simplemente indica si fue

posible conectarse a la Base de Datos y en caso de error, en la variable Msg retornará el

mensaje correspondiente.

• Function RemoveDataBase(DbName: String): Boolean

Elimina una base de datos de la configuración, se libera la conexión con la base de datos.

• Function ClearDataBases: Boolean

Elimina todas las conexiones a las bases de datos definidas en el HBServer local, el sistema

retornará a las conexiones definidas en el DbAdmin por defecto.

Otras funciones del HBXConnection Procedure GetDataBaseNames(DbNames: TStrings); Procedure GetTableNames(DbName: String; List: TStrings;

SystemTables: Boolean = False); Procedure GetFieldNames(DbName: String; TableName: String; Li st: TStrings); Procedure GetIndexNames(DbName: String; TableName: String; Li st: TStrings); Procedure GetProcedureNames(DbName: String; List: TStrings); Procedure GetProcedureParams(DbName, ProcedureName, PackageName: String; List: TStrings); Function NewQuery(DbName, Sql: String): THbQuery;

Function TestDb(Params: TStrings; Var Msg: String): Boolean; Function AddDataBase(DbName: String; Params: TStrings): Bool ean; Function RemoveDataBase(DbName: String): Boolean; Function ClearDataBases: Boolean;

Function BeginTransaction(DbName: String): String; Procedure CommitTransaction(IdTransaction: String); Procedure RollBackTransaction(IdTransaction: String);



DESCRIPCIÓN DE FUNCIONALIDADES THBXCONNECTION

Manejo de Transacciones (Modo Local) El manejo de transacciones se ha implementado en el modo Local para mantener compatibilidad,

sin embargo en modo servidor no es posible implementar este mismo modelo ya que el modelo es

desconectado y por lo tanto una operación puede iniciarse en un servidor y terminar en otro

completamente diferente.

Existe en el HBServer métodos para implementar las transacciones, sin embargo es un modelo

diferente y por lo tanto será necesario modificar el código en los puntos donde se utilicen

transacciones.

Las transacciones se definen por cada conexión a base de datos, aunque los identificadores de

cada transacción llevan un consecutivo único sin importar la base de datos. Veamos un ejemplo:

Var

DbConn: THBXConnection; Query: THbQuery; IdTran: String; begin DbConn := THBXConnection.Create(Self); IdTran := DbConn.BeginTransaction( 'DBName' ); Query := DbConn.NewQuery( 'DBName' , '' ); Try

Query.Sql.Text := 'insert into Paises values(:CodPais, :NomPais) '; Query.Params.ParamByName( 'CodPais ').AsString := '100' ; Query.Params.ParamByName( 'NomPais' ).AsString := 'Colombia' ; Query.Execute; Query.Sql.Text := 'insert into Ciudades '+ 'values(:CodCiudad, :NomCiudad, :CodPais)' ; Query.Params.ParamByName( 'CodCiudad' ).AsString := '0101' ; Query.Params.ParamByName( 'NomCiudad' ).AsString := 'Armenia' ; Query.Params.ParamByName( 'CodPais' ).AsString := '100' ; Query.Execute; DbConn.CommitTransaction(IdTran); Except On E: Exception do Begin

DbConn.CommitTransaction(IdTran); ShowMessage( 'No se guardaron los cambios, '+ 'se presentó el siguiente error' +#$D#$A+ E.Message); End; End;



El modelo de transacciones funciona igualmente en el entorno visual, se inicia la transacción

almacenando el Id de la transacción en

una variable global, se pueden realizar

todas las operaciones sobre las tablas y

finalmente se realiza el Commit o el

RollBack.

Si se inicia una transacción, todas las

operaciones sobre esa base de datos están

sujetas a la terminación con el Commit o

el RollBack, de no hacerlo se pueden

presentar problemas de consistencia en

los datos presentados al usuario

posteriormente y es posible que la base de

datos aplique automáticamente el

RollBack, perdiendo los datos

definitivamente.

Qué pasa con el ApplyUpdates y las transacciones?

Las modificaciones que se realizan en ambiente visual o directamente sobre el resultado de un

Select se procesan en memoria, por lo tanto se almacenarán en la base de datos definitivamente

al aplicar la función ApplyUpdates.

El ApplyUpdates, crea una transacción en la base de datos y almacena físicamente todos los

cambios realizadas desde la última vez que se ejecutó el ApplyUpdates. pero aún así, si se ha

iniciado una transacción, se puede deshacer ejecutando la función RollBack. En otras palabras

tiene prioridad la transacción sobre el ApplyUpdates.

Debe tener en cuenta que el ApplyUpdates se aplica sobre una sola tabla, mientras que las

transacciones cubren todas las modificaciones realizadas a diferentes tablas de la misma base de

datos.

Observación: Reiteramos que el manejo de transacciones debe limitarse lo más posible, debido a

que en el modelo desconectado no es posible implementar las transacciones de la misma manera

y será necesario crear procedimientos en el servidor HyperBase para implementar esta

funcionalidad.



Multitareas (THRead Safe) Los componentes HBX no son Thread Safe, por lo tanto hay que tener cierto cuidado en el manejo

de las multitareas cuando se conectan a las bases de datos. La mejor forma de trabajar en crear

una Conexión por cada multitarea y liberarla al finalizar la multitarea. Veamos un ejemplo.

Types TMyThread = class(TThread) private DbConn: THBXConnection; Query: THbQuery; protected procedure Execute; override; public constructor Create; end; implementation

constructor TMyThread.Create(); begin inherited Create(True); FreeOnTerminate := True; DbConn := THbxConnection.Create(Nil); DbConn.ConnectionType := tcxLocal; Query := DbConn.NewQuery( 'MyDbName' , 'select * from dosomething' ); Suspended := False; end;

procedure TMyThread.Execute; begin DbConn.Open; Query.Open; Try

Repeat //Aquí hace lo necesario con la base de datos .... //Aquí hace lo necesario con la base de da tos Until Condición; Except On E: Exception do Begin //Aquí toma medidas con respecto a los errores End; End; end;

Cada tarea debe configurar completamente la conexión a base de datos en caso que sea dinámica,

el THBXConnection puede leer las configuraciones creadas por el DbAdmin.



DESCRIPCIÓN DE FUNCIONALIDADES THBQUERY

Conectar a una base de datos Antes de realizar cualquier operación sobre la base de datos, es indispensable conectar el

componente con la base de datos, para ello se utilizan las siguientes propiedades.

Var

Query : THbQuery; begin

Query := THbQuery.Create(Nil); Query.RemoteServer := DbConn; Query.ProviderName := 'dsProvider' ; Query.DatabaseName := 'MyDbName' ; Query.Sql.Text := 'Select * from ciudades' ; Query.OnReconcileError := DoReconcileError ; Query.Open; End;

•

• RemoteServer: Debe apuntar al componente THBXConnection.

• ProviderName: Es una constante, siempre debe ser 'DsProvider';

• DatabaseName: Indica sobre cual base de datos se realizará la consulta.

• Sql: El sql que corresponde a la consulta.

El componente no reporta algunos errores inmediatamente, dado que son validados por el

servidor tanto en el caso Local como el Remoto, así que esos errores disparan un evento llamado

DoReconcileError, Delphi proporciona rutinas especificas para el manejo de este tipo de errores,

siempre es aconsejable crear un evento para controlar estos errores al crear un Query.

Types TyMyClasss = Class... private procedure DoReconcileError(DataSet: TCustomClientDataSet; E: EReconcileError; UpdateKind: TUpdateKind; var Action: TReconcileAction); end; implementation

procedure TFDataModule.DoReconcileError(DataSet: TCustomClie ntDataSet; E: EReconcileError; UpdateKind: TUpdateKind; var Action: TReconcileAction); begin

Raise Exception.Create(E.Message); end;



Ejecución de Procedimientos remotos Los componentes de HBX permiten ejecutar tanto los Procedimientos Almacenados (Store

Procedures) de la base de datos, como los Meta Procedimientos de HyperBase, en esta sección

solo hablaremos de los Store Procedures de la base de datos, en el manual del Server se

presentará la forma de crear Meta Procedures, la asignación de permisos de ejecución y la manera

de llamarlos desde el HbQuery.

Consideremos este ejemplo de un procedimiento en Interbase, el cual tiene como único

parámetro de entrada el valor entero de la edad y retornará una lista de los empleados que son

mayores de dicha edad:

create procedure get_name (employee_age integer) returns (employee_name char(30)) as begin for select name from employee where age > :employee_age into :employee_name do suspend; end

El Sql de ejecución del procedimiento sería así:

Query.Sql.Text := 'Select * from Get_Name(27)' ;

Query.Open;

Paso de Parámetros en un Store Procedure:

El paso de parámetros es igual que en cualquier consulta, se le antepone dos puntos (:) a

la variable, es importante definir el tipo, en especial cuando son fecha, ya que pueden

presentar inconsistencia por formatos:

Query.Sql.Text := 'Select * from Get_Name(:Edad)' ; Query.Params.ParamByName('Edad').AsInterger := 2 7; Query.Open;



Guardar cambios localmente sin aplicar Dado que los componentes trabajan desconectados, es posible que la conexión al servidor se

pierda en cualquier momento, pero esta situación no debe ser un problema, ya que si se recupera

la conexión el sistema continuará normalmente, pero en el caso de no poder recuperarse, es

posible guardar los cambios localmente y posteriormente recuperar los cambios y aplicarlos.

veamos el procedimiento:

Query.Sql.Text := 'Select * from ciudades' ; Query.Open; Query.Append; Query.FieldByName( 'Cod_Ciudad' ).AsString := '2020' ;

Query.FieldByName( 'Nom_Ciudad' ).AsString := 'Bucaramanga'; Query.Post; Try

Query.ApplyUpdates(0); Except

Query.SaveToFile( '\temp\ciudades.xml' , dfXMLUTF8); End; End;

Procedure RecuperaModificados Begin

Query.Sql.Text := 'Select * from ciudades' ; Query.Open; Query.LoadFromFile( '\temp\ciudades.xml' , dfXMLUTF8); Query.ApplyUpdates(0); End;



Leer los datos del Query por bloques La Suite de HyperBase está diseñada para trabajar sobre redes lentas como las de internet, por lo

tanto puede llegar a ser un grave problema intentar traer el resultado de un Sql que retorne un

millón de registros. Así que existen dos el Server tiene una variable que limita el número máximo

de registros que un usuario puede solicitar, después del cual, el servidor da por terminada la

consulta.

En segunda instancia el cliente puede solicitar que solamente traiga un pequeño bloque de esos

registros, por ejemplo, solamente los 100 primeros registros:

Query.Sql.Text := 'Select * from ciudades' ; Query.PacketRecord := 100; Query.Open;

Para traer los siguientes 100 registros es posible ejecutar el comando GetNextPacket, en caso de

querer cambiar el número de registros a traer, es posible cambiar la variable PacketRecord.

Query.PacketRecord := 500; Query.GetNextPacket;

Si se hace un recorrido por la tabla, esta traerá automáticamente cada paquete en la medida que

lo necesite, no es necesario realizar ningún llamado a la función del GetNextPacket. El siguiente

ejemplo recorrerá toda la tabla hasta llegar al final, recuperando bloques de 100 registros cada vez

que llega al final del bloque.

While not Query.Eof do Begin

//Aquí se realizan las operaciones ..... Query.Next; End;

Try

Query.ApplyUpdates(0); Except

Query.SaveToFile( '\temp\ciudades.xml' , dfXMLUTF8); End; End;

Nota: La Propiedad RecordCount se refiere al número de registros que están cargados en

la tabla, no al total de registros de esa tabla en la base de datos.



THBQuery como Memory Table El THBQuery también puede comportarse como una tabla de memoria, sin ninguna conexión a las

bases de datos, Es posible crear la estructura de la tabla manualmente o leer un archivo xml

guardado previamente de una consulta de la base de datos.

Para crear el dataset de forma manual, hay que agregar los campos y los indices, utilizando las

propiedades de FieldDefs e IndexDef, es importante si se desea posteriormente guardar estos

datos en alguna tabla identificar bien los tipos de datos, ya que si no coinciden, deberá realizar la

actualización de la tabla manualmente:

Var


Query := THbQuery.Create(Nil); Query.FieldDefs.Add( 'Codigo' , ftString, 20, True); Query.FieldDefs.Add( 'Nombre' , ftString, 40, True); Query.FieldDefs.Add( 'Fecha' , ftDateTime, 0); Query.IndexDefs.Add( 'Idx' , 'Codigo' , [ixPrimary]);

Query.CreateDataSet;

Note que no se asignó ningún valor a la propiedad RemoteServer ni al ProviderName, de hacerlo,

el DataSet intentará buscar la tabla en el servidor generando un error al no encontrar el sql

correspondiente.

Es posible leer en un DataSet los datos previamente guardados por una consulta, como lo hemos

visto en los ejemplos durante este documento, si se requiere hacer esto, no se requiere asignar

las propiedades de conexión al servidor.

Var


Query := THbQuery.Create(Nil); Query.LoadFromFile( 'c:\temp\consulta.xml' ); ....

Nota: El llamado a la función LoadFromFile o LoadFromStream borra automáticamente cualquier

configuración manual que se haya realizado a la estructura del DataSet.



THBQuery "Live Query" con múltiples tablas Con algunos componentes de conexión a bases de datos solo es posible editar consultas que

hacen referencia a una tabla en particular, usualmente las consultas que involucran múltiples

tablas son de lectura solamente.

Con los HBX es posible crear consultas de múltiples tablas y asignar una como la tabla primaria, de

tal suerte que se pueden modificar los campos de dicha tabla, los campos restantes no estarán

incluidos en las modificaciones.

Dos conceptos se deben tener en cuenta para lograr este objetivo, en primer lugar todos los

campos correspondientes a la llave primaria de la tabla principal deben estar involucrados en la

consulta y en segundo lugar, se debe asignar la propiedad TABLENAME antes de abrir la consulta,

para que el servidor pueda asignar la tabla modificable por defecto.

Var

DBConn: THBXConnection; Query: THbQuery; begin

DBConn := THBXConnection.Create(Self); DbConn.Open; Query := DbConn.NewQuery( 'MyDbName' , '' ); Query.OnReconcileError := DoReconcileError; Query.Sql.Add( 'SELECT *' ); Query.Sql.Add( 'FROM CIUDADES' ); Query.Sql.Add( ' INNER JOIN PAISES ON (CIUDADES.ID_PAIS=PAISES.ID_ PAIS)' ); Query.TableName := 'CIUDADES' ; Query.Open; If Query.Locate( 'IDCIUDAD' , '76001' ,[]) then Begin Query.Edit; Query.FieldByName( 'NOMBRE_CIUDAD').AsString := 'SANTIAGO DE CALI' ; Query.Post; Query.ApplyUpdates(0); End;

Nota: Si no se asigna el evento DoReconcileError, el sistema no captura los errores

correspondientes si llegasen a ocurrir.

componentes de conexiÓn a bases de datos componentes de

Documents