COMPONENTES DE CONEXIÓN A BASES DE DATOS COMPONENTES DE ...
Transcript of 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]
home page: http://www.hyper-soft.co
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] 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
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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.
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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.
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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(); ?>
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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"); }
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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;
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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:
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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.
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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.
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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;
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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);
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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;
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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.
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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.
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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;
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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;
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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;
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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.
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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.
Manual de desarrollador - Componentes HBX
Ing. Gustavo E. Enríquez [email protected] www.hyper-soft.co
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.