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,"Login","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).getFFieldName()+"="+
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\\queryciudades.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',
dfXMLUTF8);
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.
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.
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; List: TStrings);
Procedure GetIndexNames(DbName: String;
TableName: String; List: 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): Boolean;
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 datos
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:
TCustomClientDataSet;
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 := 27;
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;
begin
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;
begin
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.
