Firebird ha sido capaz de ampliar las capacidades del lenguaje PSQL al escribir funciones externas: UDF (funciones definidas por el usuario). UDF se puede escribir en casi cualquier lenguaje de programación compilado.
Firebird 3.0 introdujo una arquitectura de complemento para ampliar las capacidades de Firebird. Uno de estos complementos es el motor externo (motores externos). El mecanismo UDR (Rutinas definidas por el usuario - Rutinas definidas por el usuario) agrega una capa en la parte superior de la interfaz del motor FirebirdExternal.
En esta guía, le diremos cómo declarar UDR, sobre sus mecanismos internos, capacidades y le daremos ejemplos de cómo escribir UDR en Pascal. Además, se cubrirán algunos aspectos del uso de la nueva API orientada a objetos.
Observación
Este artículo está destinado a enseñarle cómo escribir UDR usando el objeto Firebird API.
Las funciones y procedimientos escritos pueden no tener una aplicación práctica.
Los UDR tienen las siguientes ventajas sobre el UDF heredado:
- puede escribir no solo funciones que devuelven un resultado escalar, sino también procedimientos almacenados (tanto ejecutables como selectivos), así como disparadores;
- Control mejorado de los parámetros de entrada y salida. En algunos casos (pasando por descriptor) los tipos y otras propiedades de los parámetros de entrada no se controlaron en absoluto, sin embargo, puede obtener estas propiedades dentro de UDF. Los UDR proporcionan una forma más unificada de declarar parámetros de entrada y salida, como es el caso de las funciones y procedimientos regulares de PSQL;
- UDR, el contexto de la conexión o transacción actual está disponible, lo que le permite realizar
algunas manipulaciones con la base de datos actual en este contexto; - La generación de errores de Firebird está disponible cuando se producen excepciones; no es necesario devolver un valor especial;
- Los procedimientos y funciones externas (UDR) se pueden agrupar en paquetes PSQL;
- La UDR se puede escribir en cualquier lenguaje de programación (opcionalmente compilado en códigos de objeto), para esto es necesario que se escriba el complemento del motor externo correspondiente. Por ejemplo, hay complementos para escribir módulos externos en Java o en cualquiera de los lenguajes .NET.
Observación
La implementación actual de UDR utiliza un código auxiliar de PSQL. Por ejemplo, se usa para
comprobación de parámetros y valores de retorno para el cumplimiento de restricciones. Trozo
se usó debido a la inflexibilidad para llamar directamente a funciones internas. Resultados
La prueba que compara el rendimiento de UDR y UDF muestra que UDR es aproximadamente
2.5 veces más lento usando la función más simple de agregar dos argumentos como ejemplo. Velocidad
UDR es aproximadamente igual a la velocidad de una función PSQL normal. Quizás en el futuro esto
momento será optimizado. En funciones más complejas, esta sobrecarga puede convertirse
imperceptible
Además en varias partes de este manual, cuando se usan los términos procedimiento externo,
función o disparador significaremos exactamente UDR (y no UDF).
Observación
Todos nuestros ejemplos funcionan en Delphi 2009 y posteriores, así como en Free Pascal. Todos
Se pueden compilar ejemplos en Delphi y Free Pascal, si
no especificado por separado.
API de Firebird
Para escribir procedimientos, funciones o disparadores externos en lenguajes de programación compilados, necesitamos conocer la nueva API Firebird orientada a objetos. Esta guía no incluye una descripción completa de la API de Firebird. Puede leerlo en el directorio de documentación distribuido con Firebird ( doc/Using_OO_API.html ).
Los complementos para varios lenguajes de programación que contienen API no se distribuyen como parte de la distribución de Firebird para Windows, sin embargo, puede extraerlos de archivos tarbar comprimidos distribuidos en Linux (la ruta dentro del archivo /opt/firebird/include/firebird/Firebird.pas ).
CLOOP
CLOOP - Programación orientada a objetos de lenguaje cruzado. Esta herramienta no está incluida con Firebird. Se puede encontrar en el código fuente https://github.com/FirebirdSQL/firebird/tree/B3_0_Release/extern/cloop . Después de ensamblar la herramienta, puede generar una API para su lenguaje de programación ( IdlFbInterfaces.h o Firebird.pas ) basada en el archivo de descripción de interfaz include/firebird/FirebirdInterface.idl .
Para Object pascal, esto se hace con el siguiente comando:
cloop FirebirdInterface.idl pascal Firebird.pas Firebird --uses SysUtils \ --interfaceFile Pascal.interface.pas \ --implementationFile Pascal.implementation.pas \ --exceptionClass FbException --prefix I \ --functionsFile fb_get_master_interface.pas
Los Pascal.interface.pas , Pascal.implementation.pas y fb_get_master_interface.pas se pueden encontrar en https://github.com/FirebirdSQL/firebird/tree/B3_0_Release/src/misc/pascal .
Observación
En este caso, el prefijo I se agregará para las API de Firebird, ya que esto se acepta en Object Pascal.
Constantes
No hay constantes isc_* en el archivo Firebird.pas resultante. Estas constantes para los lenguajes C / C ++ se pueden encontrar en https://github.com/FirebirdSQL/firebird/blob/B3_0_Release/src/include/consts_pub.h . Para obtener las constantes para el lenguaje Pascal, utilizaremos el script AWK para convertir la sintaxis. En Windows, deberá instalar Gawk para Windows o utilizar el Subsistema de Windows para Linux (disponible en Windows 10). Esto se hace con el siguiente comando:
awk -f Pascal.Constants.awk consts_pub.h > const.pas
El contenido del archivo resultante debe copiarse en la sección vacía del archivo Firebird.pas inmediatamente después de la implementación. El archivo Pascal.Constants.awk se puede encontrar en
https://github.com/FirebirdSQL/firebird/tree/B3_0_Release/src/misc/pascal .
Gestión del tiempo de vida
Las interfaces de Firebird no se basan en la especificación COM, por lo que administrar su vida útil es diferente.
Hay dos interfaces en Firebird que se ocupan de la gestión del tiempo de vida: IDisposable e IReferenceCounted. Este último es especialmente activo cuando se crean otras interfaces: IPlugin cuenta los enlaces, como muchas otras interfaces utilizadas por los complementos. Estos incluyen interfaces que describen cómo conectarse a una base de datos, administración de transacciones y declaraciones SQL.
La sobrecarga adicional de la interfaz con recuento de referencias no siempre es necesaria. Por ejemplo, IMaster, la interfaz principal que llama a las funciones disponibles para el resto de la API, tiene una duración ilimitada por definición. Para otras API, la duración está estrictamente determinada por la duración de la interfaz principal; La interfaz IStatus no es
multiproceso Para las interfaces con una vida útil limitada, es útil tener una forma simple de destruirlas, es decir, la función dispose ().
Pista
Si no sabe cómo se destruye un objeto, observe su jerarquía, si tiene
interfaz IReferenceCounted, luego se utiliza el recuento de referencias.
Para las interfaces con recuento de referencias, al finalizar el trabajo con un objeto, es necesario
disminuya el contador de referencia llamando al método release ().
Anuncio de UDR
Los UDR pueden agregarse o eliminarse de la base de datos utilizando comandos DDL, tal como agrega o elimina procedimientos, funciones o desencadenantes regulares de PSQL. En este caso, en lugar del cuerpo del activador, su ubicación en el módulo externo se indica mediante la cláusula EXTERNAL NAME.
Considere la sintaxis de esta oración; será común a los procedimientos externos, funciones y desencadenantes.
Sintaxis:
EXTERNAL NAME '<extname>' ENGINE <engine> [AS <extbody>] <extname> ::= '<module name>!<routine name>[!<misc info>]'
El argumento de esta cláusula NOMBRE EXTERNO es una cadena que indica la ubicación de la función en el módulo externo. Para los módulos externos que usan el motor UDR, esta línea a través del separador indica el nombre del módulo externo, el nombre de la función dentro del módulo y la información definida por el usuario. Se utiliza un signo de exclamación (!) Como separador.
La cláusula ENGINE especifica el nombre del motor para procesar la conexión de módulos externos. Firebird utiliza el motor UDR para trabajar con módulos externos escritos en lenguajes compilados (C, C ++, Pascal). Las funciones externas escritas en Java requieren el motor Java.
Después de la palabra clave AS, se puede especificar un literal de cadena: el "cuerpo" del módulo externo (procedimiento, función o desencadenador), puede ser utilizado por el módulo externo para diversos fines. Por ejemplo, se puede especificar una consulta SQL para acceder a una base de datos externa o texto en algún idioma para su interpretación por parte de su función.
Funciones externas
Sintaxis {CREATE [OR ALTER] | RECREATE} FUNCTION funcname [(<inparam> [, <inparam> ...])] RETURNS <type> [COLLATE collation] [DETERMINISTIC] EXTERNAL NAME <extname> ENGINE <engine> [AS <extbody>] <inparam> ::= <param_decl> [{= |DEFAULT} <value>] <value> ::= {literal | NULL | context_var} <param_decl> ::= paramname <type> [NOT NULL] [COLLATE collation] <extname> ::= '<module name>!<routine name> [!<misc info>]' <type> ::= <datatype> | [TYPE OF] domain | TYPE OF COLUMN rel.col <datatype> ::= {SMALLINT | INT[EGER] | BIGINT} | BOOLEAN | {FLOAT | DOUBLE PRECISION} | {DATE | TIME | TIMESTAMP} | {DECIMAL | NUMERIC} [(precision [, scale])] | {CHAR | CHARACTER | CHARACTER VARYING | VARCHAR} [(size)] [CHARACTER SET charset] | {NCHAR |NATIONAL CHARACTER | NATIONAL CHAR} [VARYING] [(size)] | BLOB [SUB_TYPE {subtype_num | subtype_name}] [SEGMENT SIZE seglen] [CHARACTER SET charset] | BLOB [(seglen [, subtype_num])]
Todos los parámetros de una función externa se pueden cambiar utilizando la instrucción ALTER FUNCTION.
Sintaxis:
ALTER FUNCTION funcname [(<inparam> [, <inparam> ...])] RETURNS <type> [COLLATE collation] [DETERMINISTIC] EXTERNAL NAME <extname> ENGINE <engine> [AS <extbody>] <extname> ::= '<module name>!<routine name>[!<misc info>]'
Puede eliminar una función externa utilizando la instrucción DROP FUNCTION.
Sintaxis:
DROP FUNCTION funcname
Aquí no describiremos la sintaxis de los parámetros de entrada y la salida. Cumple totalmente con la sintaxis para las funciones regulares de PSQL, que se describe en detalle en la Guía del lenguaje SQL. En cambio, damos ejemplos de declarar funciones externas con explicaciones.
La función de agregar tres argumentos
create function sum_args ( n1 integer, n2 integer, n3 integer ) returns integer external name 'udrcpp_example!sum_args' engine udr;
La implementación de la función está en el módulo udrcpp_example. Dentro de este módulo, una función se registra con el nombre sum_args. Una función externa utiliza el motor UDR.
Función de Java
create or alter function regex_replace ( regex varchar(60), str varchar(60), replacement varchar(60) ) returns varchar(60) external name 'org.firebirdsql.fbjava.examples.fbjava_example.FbRegex.replace( String, String, String)' engine java;
La implementación de la función está en la función estática de reemplazo de la clase org.firebirdsql.fbjava.examples.fbjava_example.FbRegex . Una función externa usa el motor Java.
Procedimientos externos
Sintaxis {CREATE [OR ALTER] | RECREATE} PROCEDURE procname [(<inparam> [, <inparam> ...])] RETURNS (<outparam> [<outparam> ...]) EXTERNAL NAME <extname> ENGINE <engine> [AS <extbody>] <inparam> ::= <param_decl> [{= | DEFAULT} <value>] <outparam> ::= <param_decl> <value> ::= {literal | NULL | context_var} <param_decl> ::= paramname <type> [NOT NULL] [COLLATE collation] <extname> ::= '<module name>!<routine name>[!<misc info>]' <type> ::= <datatype> | [TYPE OF] domain | TYPE OF COLUMN rel.col <datatype> ::= {SMALLINT | INT[EGER] | BIGINT} | BOOLEAN | {FLOAT | DOUBLE PRECISION} | {DATE | TIME | TIMESTAMP} | {DECIMAL | NUMERIC} [(precision [,scale])] | {CHAR | CHARACTER | CHARACTER VARYING | VARCHAR} [(size)] [CHARACTER SET charset] | {NCHAR | NATIONAL CHARACTER | NATIONAL CHAR} [VARYING] [(size)] | BLOB [SUB_TYPE {subtype_num | subtype_name}] [SEGMENT SIZE seglen] [CHARACTER SET charset] | BLOB [(seglen [, subtype_num])]
Todos los parámetros del procedimiento externo se pueden cambiar utilizando la instrucción ALTER PROCEDURE.
Sintaxis:
ALTER PROCEDURE procname [(<inparam> [, <inparam> ...])] RETURNS (<outparam> [, <outparam> ...]) EXTERNAL NAME <extname> ENGINE <engine> [AS <extbody>]
Puede eliminar un procedimiento externo utilizando la instrucción DROP PROCEDURE.
Sintaxis:
DROP PROCEDURE procname
Aquí no describiremos la sintaxis de los parámetros de entrada y salida. Cumple totalmente con la sintaxis de los procedimientos regulares de PSQL, que se describe en detalle en la Guía del lenguaje SQL. En cambio, damos ejemplos de declarar procedimientos externos con explicaciones.
create procedure gen_rows_pascal ( start_n integer not null, end_n integer not null ) returns ( result integer not null ) external name 'pascaludr!gen_rows' engine udr;
La implementación de la función está en el módulo pascaludr. Dentro de este módulo, el procedimiento se registra con el nombre gen_rows. Un procedimiento externo utiliza el motor UDR.
create or alter procedure write_log ( message varchar(100) ) external name 'pascaludr!write_log' engine udr;
La implementación de la función está en el módulo pascaludr. Dentro de este módulo, el procedimiento se registra con el nombre write_log. Un procedimiento externo utiliza el motor UDR.
create or alter procedure employee_pgsql (
La implementación de la función está en la función estática executeQuery de la clase
org.firebirdsql.fbjava.examples.fbjava_example.FbJdbc . Después del signo de exclamación (!), La información se encuentra para conectarse a una base de datos externa a través de JDBC. Una función externa usa el motor Java. Aquí, como el "cuerpo" del procedimiento externo, se pasa una consulta SQL para recuperar los datos.
Observación
Este procedimiento utiliza un código auxiliar en el que se pasa un parámetro no utilizado. Esto se debe al hecho de que en Firebird 3.0 hay un error con el procesamiento de procedimientos externos sin parámetros.
Colocación de procedimientos y funciones externas dentro de paquetes
Es conveniente colocar un grupo de procedimientos y funciones interrelacionados en los paquetes de PSQL. Los paquetes pueden contener funciones y procedimientos PSQL externos y regulares.
Sintaxis {CREATE [OR ALTER] | RECREATE} PACKAGE package_name AS BEGIN [<package_item> ...] END {CREATE | RECREATE} PACKAGE BODY package_name AS BEGIN [<package_item> ...] [<package_body_item> ...] END <package_item> ::= <function_decl>; | <procedure_decl>; <function_decl> ::= FUNCTION func_name [(<in_params>)] RETURNS <type> [COLLATE collation] [DETERMINISTIC] <procedure_decl> ::= PROCEDURE proc_name [(<in_params>)] [RETURNS (<out_params>)] <package_body_item> ::= <function_impl> | <procedure_impl> <function_impl> ::= FUNCTION func_name [(<in_impl_params>)] RETURNS <type> [COLLATE collation] [DETERMINISTIC] <routine body> <procedure_impl> ::= PROCEDURE proc_name [(<in_impl_params>)] [RETURNS (<out_params>)] <routine body> <routine body> ::= <sql routine body> | <external body reference> <sql routine body> ::= AS [<declarations>] BEGIN [<PSQL_statements>] END <declarations> ::= <declare_item> [<declare_item> ...] <declare_item> ::= <declare_var>; | <declare_cursor>; | <subroutine declaration>; | <subroutine implimentation> <subroutine declaration> ::= <subfunc_decl> | <subproc_decl> <subroutine implimentation> ::= <subfunc_impl> | <subproc_impl> <external body reference> ::= EXTERNAL NAME <extname> ENGINE <engine> [AS <extbody>] <extname> ::= '<module name>!<routine name>[!<misc info>]'
Para procedimientos y funciones externas, el nombre del paquete, los parámetros de entrada, sus tipos, valores predeterminados y parámetros de salida se indican en el encabezado del paquete, y todo es igual en el cuerpo del paquete, excepto los valores predeterminados, así como la ubicación en el módulo externo (cláusula EXTERNAL NAME) , el nombre del motor y posiblemente el "cuerpo" del procedimiento / función.
Suponga que escribió una UDR para trabajar con expresiones regulares, que se encuentra en el módulo externo PCRE (biblioteca dinámica), y tiene varias UDR más que realizan otras tareas. Si no hubiéramos utilizado los paquetes de PSQL, todos nuestros procedimientos y funciones externas se combinarían entre sí y con los procedimientos y funciones de PSQL ordinarios. Esto complica la búsqueda de dependencias y la realización de cambios en los módulos externos, y además crea confusión y obliga al menos al uso de prefijos para agrupar procedimientos y funciones. Los paquetes PSQL hacen que esta tarea sea mucho más fácil para nosotros.
Paquete RegExp SET TERM ^; CREATE OR ALTER PACKAGE REGEXP AS BEGIN PROCEDURE preg_match( APattern VARCHAR(8192), ASubject VARCHAR(8192)) RETURNS (Matches VARCHAR(8192)); FUNCTION preg_is_match( APattern VARCHAR(8192), ASubject VARCHAR(8192)) RETURNS BOOLEAN; FUNCTION preg_replace( APattern VARCHAR(8192), AReplacement VARCHAR(8192), ASubject VARCHAR(8192)) RETURNS VARCHAR(8192); PROCEDURE preg_split( APattern VARCHAR(8192), ASubject VARCHAR(8192)) RETURNS (Lines VARCHAR(8192)); FUNCTION preg_quote( AStr VARCHAR(8192), ADelimiter CHAR(10) DEFAULT NULL) RETURNS VARCHAR(8192); END^ RECREATE PACKAGE BODY REGEXP AS BEGIN PROCEDURE preg_match( APattern VARCHAR(8192), ASubject VARCHAR(8192)) RETURNS (Matches VARCHAR(8192)) EXTERNAL NAME 'PCRE!preg_match' ENGINE UDR; FUNCTION preg_is_match( APattern VARCHAR(8192), ASubject VARCHAR(8192)) RETURNS BOOLEAN AS BEGIN RETURN EXISTS( SELECT * FROM preg_match(:APattern, :ASubject)); END FUNCTION preg_replace( APattern VARCHAR(8192), AReplacement VARCHAR(8192), ASubject VARCHAR(8192)) RETURNS VARCHAR(8192) EXTERNAL NAME 'PCRE!preg_replace' ENGINE UDR; PROCEDURE preg_split( APattern VARCHAR(8192), ASubject VARCHAR(8192)) RETURNS (Lines VARCHAR(8192)) EXTERNAL NAME 'PCRE!preg_split' ENGINE UDR; FUNCTION preg_quote( AStr VARCHAR(8192), ADelimiter CHAR(10)) RETURNS VARCHAR(8192) EXTERNAL NAME 'PCRE!preg_quote' ENGINE UDR; END^ SET TERM ;^
Disparadores externos
Sintaxis {CREATE [OR ALTER] | RECREATE} TRIGGER trigname {<relation_trigger_legacy> | <relation_trigger_sql2003> | <database_trigger> | <ddl_trigger> } <external-body> <external-body> ::= EXTERNAL NAME <extname> ENGINE <engine> [AS <extbody>] <relation_trigger_legacy> ::= FOR {tablename | viewname} [ACTIVE | INACTIVE] {BEFORE | AFTER} <mutation_list> [POSITION number] <relation_trigger_sql2003> ::= [ACTIVE | INACTIVE] {BEFORE | AFTER} <mutation_list> [POSITION number] ON {tablename | viewname} <database_trigger> ::= [ACTIVE | INACTIVE] ON db_event [POSITION number] <ddl_trigger> ::= [ACTIVE | INACTIVE] {BEFORE | AFTER} <ddl_events> [POSITION number] <mutation_list> ::= <mutation> [OR <mutation> [OR <mutation>]] <mutation> ::= INSERT | UPDATE | DELETE <db_event> ::= CONNECT | DISCONNECT | TRANSACTION START | TRANSACTION COMMIT | TRANSACTION ROLLBACK <ddl_events> ::= ANY DDL STATEMENT | <ddl_event_item> [{OR <ddl_event_item>} ...] <ddl_event_item> ::= CREATE TABLE | ALTER TABLE | DROP TABLE | CREATE PROCEDURE | ALTER PROCEDURE | DROP PROCEDURE | CREATE FUNCTION | ALTER FUNCTION | DROP FUNCTION | CREATE TRIGGER | ALTER TRIGGER | DROP TRIGGER | CREATE EXCEPTION | ALTER EXCEPTION | DROP EXCEPTION | CREATE VIEW | ALTER VIEW | DROP VIEW | CREATE DOMAIN | ALTER DOMAIN | DROP DOMAIN | CREATE ROLE | ALTER ROLE | DROP ROLE | CREATE SEQUENCE | ALTER SEQUENCE | DROP SEQUENCE | CREATE USER | ALTER USER | DROP USER | CREATE INDEX | ALTER INDEX | DROP INDEX | CREATE COLLATION | DROP COLLATION | ALTER CHARACTER SET | CREATE PACKAGE | ALTER PACKAGE | DROP PACKAGE | CREATE PACKAGE BODY | DROP PACKAGE BODY | CREATE MAPPING | ALTER MAPPING | DROP MAPPING
Un disparador externo se puede cambiar usando la instrucción ALTER TRIGGER.
Sintaxis:
ALTER TRIGGER trigname { [ACTIVE | INACTIVE] [ {BEFORE | AFTER} {<mutation_list> | <ddl_events>} | ON db_event ] [POSITION number] [<external-body>] <external-body> ::= EXTERNAL NAME <extname> ENGINE <engine> [AS <extbody>] <extname> ::= '<module name>!<routine name>[!<misc info>]' <mutation_list> ::= <mutation> [OR <mutation> [OR <mutation>]] <mutation> ::= { INSERT | UPDATE | DELETE }
Puede eliminar un activador externo utilizando la instrucción DROP TRIGGER.
Sintaxis:
DROP TRIGGER trigname
Aquí hay ejemplos de declaración de desencadenantes externos con explicaciones.
create database 'c:\temp\slave.fdb'; create table persons ( id integer not null, name varchar(60) not null, address varchar(60), info blob sub_type text ); commit; create database 'c:\temp\master.fdb'; create table persons ( id integer not null, name varchar(60) not null, address varchar(60), info blob sub_type text ); create table replicate_config ( name varchar(31) not null, data_source varchar(255) not null ); insert into replicate_config (name, data_source) values ('ds1', 'c:\temp\slave.fdb'); create trigger persons_replicate after insert on persons external name 'udrcpp_example!replicate!ds1' engine udr;
La implementación del disparador está en el módulo udrcpp_example. Dentro de este módulo, se registra un disparador bajo el nombre replicar. Un disparador externo utiliza el motor UDR.
En el enlace al módulo externo, ds1 un parámetro adicional ds1 , mediante el cual la configuración para leer la base de datos externa se lee desde la tabla replicate_config desde el disparador externo.
Estructura UDR
Ahora es el momento de escribir la primera UDR. Describiremos la estructura de UDR en Pascal. Para explicar la estructura mínima para construir una UDR, usaremos ejemplos estándar de examples/udr/ traducidos a Pascal.
Cree un nuevo proyecto para la nueva biblioteca dinámica, que llamaremos MyUdr. Como resultado, debe obtener el archivo MyUdr.dpr (si creó el proyecto en Delphi) o el archivo MyUdr.lpr (si creó el proyecto en Lazarus). Ahora cambiemos el archivo principal del proyecto para que se vea así:
library MyUdr; {$IFDEF FPC} {$MODE DELPHI}{$H+} {$ENDIF} uses {$IFDEF unix} cthreads,
En este caso, solo necesita exportar una función firebird_udr_plugin , que es el punto de entrada para el complemento de módulos UDR externos. La implementación de esta función se ubicará en el módulo UdrInit.
Observación
Si está desarrollando su UDR en Free Pascal, necesitará directivas adicionales. La {$mode objfpc} es necesaria para habilitar el modo Object Pascal. En su lugar, puede usar la directiva {$mode delphi} para garantizar la compatibilidad con Delphi. Como mis ejemplos deberían compilarse con éxito tanto en FPC como en Delphi, elijo el {$mode delphi} .
La directiva {$H+} incluye soporte para cadenas largas. Esto es necesario si utiliza los tipos string, ansistring y no solo los strings con terminación nula PChar, PAnsiChar, PWideChar.
Además, necesitaremos conectar módulos separados para admitir subprocesos múltiples en Linux y otros sistemas operativos similares a Unix.
Registrar procedimientos, funciones o desencadenantes
Ahora agregue el módulo UdrInit, debería verse así:
unit UdrInit; {$IFDEF FPC} {$MODE DELPHI}{$H+} {$ENDIF} interface uses Firebird;
En la función firebird_udr_plugin , firebird_udr_plugin necesario registrar las fábricas de nuestros procedimientos, funciones y disparadores externos. Para cada función, procedimiento o disparador, debe escribir su propia fábrica. Esto se hace utilizando los métodos de interfaz IUdrPlugin:
- registerFunction — ;
- registerProcedure — ;
- registerTrigger — .
, ( ). // SQL. ( ).
. SumArgsFunc. .
SumArgsFunc unit SumArgsFunc; {$IFDEF FPC} {$MODE DELPHI}{$H+} {$ENDIF} interface uses Firebird;
IUdrFunctionFactory. IUdrFunctionFactoryImpl. . , , . .
dispose , . .
setup . , . .
newItem . , . IRoutineMetadata , . PSQL. . TSumArgsFunction .
IExternalFunction. IExternalFunctionImpl .
dispose , . .
.
getCharSet , . , .
execute . , , .
. , , BLOB. BLOB, .
, . , . , , , NULL ( Null ). , , IMessageMetadata. , execute.
. Para
Null Null
, NULL,
UDR . : . , .. EXECUTE PROCEDURE .
UdrInit firebird_udr_plugin .
function firebird_udr_plugin(AStatus: IStatus; AUnloadFlagLocal: BooleanPtr; AUdrPlugin: IUdrPlugin): BooleanPtr; cdecl; begin
Observación
uses SumArgsProc, .
IUdrProcedureFactory. IUdrProcedureFactoryImpl. . , , . .
dispose , . .
setup . , . .
newItem . , . IRoutineMetadata , . PSQL. . TSumArgsProcedure .
SumArgsProc.
SumArgsProc unit SumArgsProc; {$IFDEF FPC} {$MODE DELPHI}{$H+} {$ENDIF} interface uses Firebird; type
IExternalProcedure. IExternalProcedureImpl .
dispose , . .
getCharSet . , .
open . , , . , nil, . . TSumArgsFunction.execute.
UDR . firebird_udr_plugin .
function firebird_udr_plugin(AStatus: IStatus; AUnloadFlagLocal: BooleanPtr; AUdrPlugin: IUdrPlugin): BooleanPtr; cdecl; begin
Observación
uses GenRowsProc, .
. , open, .
GenRowsProc unit GenRowsProc; {$IFDEF FPC} {$MODE DELPHI}{$H+} {$ENDIF} interface uses Firebird, SysUtils; type TInput = record start: Integer; startNull: WordBool; finish: Integer; finishNull: WordBool; end; PInput = ^TInput; TOutput = record n: Integer; nNull: WordBool; end; POutput = ^TOutput;
open TGenRowsProcedure NULL, NULL, NULL, SELECT, nil.
, , . UDR Firebird. UDR Legacy UDF.
, open , IExternalResultSet. IExternalResultSetImpl .
dispose . .
fetch SELECT. SUSPEND PSQL . , . true, , false , . , .
Observación
Delphi yeild,
while(...) do { ... yield result; }
, open, , fetch. ( SELECT FIRST/ROWS/FETCH FIRST SELECT.)
UDR .
Note
C++ . , . .
UdrInit firebird_udr_plugin .
function firebird_udr_plugin(AStatus: IStatus; AUnloadFlagLocal: BooleanPtr; AUdrPlugin: IUdrPlugin): BooleanPtr; cdecl; begin
Observación
uses TestTrigger, .
IUdrTriggerFactory. IUdrTriggerFactoryImpl.
.
dispose , . .
setup . , . .
newItem . , . IRoutineMetadata , . PSQL. . TMyTrigger .
TestTrigger.
TestTrigger unit TestTrigger; {$IFDEF FPC} {$MODE DELPHI}{$H+} {$ENDIF} interface uses Firebird, SysUtils; type
IExternalTrigger. IExternalTriggerImpl .
dispose , . .
getCharSet . , .
execute . , , () . () IExternalTrigger. ACTION_ . , Firebird . , DDL , , , nil. . , , .
Observación
, , . IMessageMetadata. , . , , /.
, PSQL
if (:new.B IS NULL) THEN :new.B = :new.A + 1;
UDR , . NEW OLD.
, , .
:
( Delphi , .. record);
IMessageMetadata, / , .
, — , UDR.
. :
TMyStruct = record <var_1>: <type_1>; <nullIndicator_1>: WordBool; <var_2>: <type_1>; <nullIndicator_2>: WordBool; ... <var_N>: <type_1>; <nullIndicator_N>: WordBool; end; PMyStruct = ^TMyStruct;
/ ( ). Null- /, NOT NULL. Null- 2 . -1
/ NULL. NULL- NULL, 2- . SQL :
, .
:
function SUM_ARGS(A SMALLINT, B INTEGER) RETURNS BIGINT ....
:
TInput = record A: Smallint; ANull: WordBool; B: Integer; BNull: WordBool; end; PInput = ^TInput; TOutput = record Value: Int64; Null: WordBool; end; POutput = ^TOutput;
( 3 ):
function SUM_ARGS(A NUMERIC(4, 2), B NUMERIC(9, 3)) RETURNS NUMERIC(18, 6) ....
:
TInput = record A: Smallint; ANull: WordBool; B: Integer; BNull: WordBool; end; PInput = ^TInput; TOutput = record Value: Int64; Null: WordBool; end; POutput = ^TOutput;
:
procedure SOME_PROC(A CHAR(3) CHARACTER SET WIN1251, B VARCHAR(10) CHARACTER SET UTF8) ....
:
TInput = record A: array[0..2] of AnsiChar; ANull: WordBool; B: record Length: Smallint; Value: array[0..39] of AnsiChar; end; BNull: WordBool; end; PInput = ^TInput;
IMessageMetadata. /
:
- /;
- ;
- ;
- BLOB;
- /;
- / NULL;
- ;
- NULL-.
getCount
unsigned getCount(StatusType* status)
/ . , , : 0 <= index < getCount().
getField
const char* getField(StatusType* status, unsigned index)
.
getRelation
const char* getRelation(StatusType* status, unsigned index)
( ).
getOwner
const char* getOwner(StatusType* status, unsigned index)
.
getAlias
const char* getAlias(StatusType* status, unsigned index)
.
getType
unsigned getType(StatusType* status, unsigned index)
SQL .
isNullable
FB_BOOLEAN isNullable(StatusType* status, unsigned index)
true, NULL.
getSubType
int getSubType(StatusType* status, unsigned index)
BLOB (0 — , 1 — . .).
getLength
unsigned getLength(StatusType* status, unsigned index)
.
getScale
int getScale(StatusType* status, unsigned index)
.
getCharSet
unsigned getCharSet(StatusType* status, unsigned index)
BLOB.
getOffset
unsigned getOffset(StatusType* status, unsigned index)
( ).
getNullOffset
unsigned getNullOffset(StatusType* status, unsigned index)
NULL .
getBuilder
IMetadataBuilder* getBuilder(StatusType* status)
IMetadataBuilder, .
getMessageLength
unsigned getMessageLength(StatusType* status)
( ).
IMessageMetadata IRoutineMetadata. , . . Por ejemplo:
IMessageMetadata getInputMetadata getOutputMetadata IRoutineMetadata. , , getTriggerMetadata.
, IMessageMetadata . IReferenceCounted. getInputMetadata getOutputMetadata 1 , xInputMetadata xOutputMetadata release.
. IMessageMetadata getOffset . .
null , getNullOffset.
. .
, . IUdrProcedureFactory, IUdrFunctionFactory IUdrTriggerFactory UDR. UDR firebird_udr_plugin .
function firebird_udr_plugin(AStatus: IStatus; AUnloadFlagLocal: BooleanPtr; AUdrPlugin: IUdrPlugin): BooleanPtr; cdecl; begin
TSumArgsFunctionFactory IUdrFunctionFactory, TGenRowsFactory IUdrProcedureFactory, TMyTriggerFactory IUdrTriggerFactory.
, . Firebird. , SuperServer , Classic
.
setup newItem IUdrProcedureFactory, IUdrFunctionFactory IUdrTriggerFactory.
IUdrFunctionFactory = class(IDisposable) const VERSION = 3; procedure setup(status: IStatus; context: IExternalContext; metadata: IRoutineMetadata; inBuilder: IMetadataBuilder; outBuilder: IMetadataBuilder); function newItem(status: IStatus; context: IExternalContext; metadata: IRoutineMetadata): IExternalFunction; end; IUdrProcedureFactory = class(IDisposable) const VERSION = 3; procedure setup(status: IStatus; context: IExternalContext; metadata: IRoutineMetadata; inBuilder: IMetadataBuilder; outBuilder: IMetadataBuilder); function newItem(status: IStatus; context: IExternalContext; metadata: IRoutineMetadata): IExternalProcedure; end; IUdrTriggerFactory = class(IDisposable) const VERSION = 3; procedure setup(status: IStatus; context: IExternalContext; metadata: IRoutineMetadata; fieldsBuilder: IMetadataBuilder); function newItem(status: IStatus; context: IExternalContext; metadata: IRoutineMetadata): IExternalTrigger; end;
, IDisposable, dispose. Firebird , . dispose , , .
IUdrProcedureFactoryImpl , IUdrFunctionFactoryImpl , IUdrTriggerFactoryImpl . .
newItem
newItem , . UDR , .. , . .
. , , , IUdrFunctionFactory . . .
newItem ,
UDR UDR.
function TSumArgsFunctionFactory.newItem(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata): IExternalFunction; begin
IRoutineMetadata , UDR . UDR. UDR .
setup
setup . IMetadataBuilder, , .
setup, setup DLL , . .
. , SumArgs.
,
type
, setup , .
SumArgsFunctionFactory procedure TSumArgsFunctionFactory.dispose; begin Destroy; end; function TSumArgsFunctionFactory.newItem(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata): IExternalFunction; begin Result := TSumArgsFunction.Create(); end; procedure TSumArgsFunctionFactory.setup(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata; AInBuilder, AOutBuilder: IMetadataBuilder); begin
SQL Firebird . , SQL NULL. XSQLDA.
procedure TSumArgsFunction.execute(AStatus: IStatus; AContext: IExternalContext; AInMsg, AOutMsg: Pointer); var xInput: PSumArgsInMsg; xOutput: PSumArgsOutMsg; begin
, , , setup.
create or alter function FN_SUM_ARGS ( N1 varchar(15), N2 varchar(15), N3 varchar(15)) returns varchar(15) EXTERNAL NAME 'MyUdrSetup!sum_args' ENGINE UDR;
select FN_SUM_ARGS('15', '21', '35') from rdb$database
UDR , UDR. . Delphi 2009, Free Pascal FPC 2.2.
Observación
Free Pascal
Delphi. FPC 2.6.0 Delphi
.
:
newItem . IUdrFunctionFactoryImpl , IUdrProcedureFactoryImpl , IUdrTriggerFactoryImpl . :
SimpleFactories unit UdrFactories; {$IFDEF FPC} {$MODE DELPHI}{$H+} {$ENDIF} interface uses SysUtils, Firebird; type
setup , , dispose . newItem T .
implementation procedure TProcedureSimpleFactory<T>.dispose; begin Destroy; end; function TProcedureSimpleFactory<T>.newItem(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata): IExternalProcedure; begin Result := T.Create; end; procedure TProcedureSimpleFactory<T>.setup(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata; AInBuilder, AOutBuilder: IMetadataBuilder); begin end; procedure TFunctionSimpleFactory<T>.dispose; begin Destroy; end; function TFunctionSimpleFactory<T>.newItem(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata): IExternalFunction; begin Result := T.Create; end; procedure TFunctionSimpleFactory<T>.setup(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata; AInBuilder, AOutBuilder: IMetadataBuilder); begin end; procedure TTriggerSimpleFactory<T>.dispose; begin Destroy; end; function TTriggerSimpleFactory<T>.newItem(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata): IExternalTrigger; begin Result := T.Create; end; procedure TTriggerSimpleFactory<T>.setup(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata; AFieldsBuilder: IMetadataBuilder); begin end;
1 , . :
function firebird_udr_plugin(AStatus: IStatus; AUnloadFlagLocal: BooleanPtr; AUdrPlugin: IUdrPlugin): BooleanPtr; cdecl; begin
. , . newItem . UDR IRoutineMetadata , Firebird, UDR. , , UDR, ,
UDR. , , .
unit UdrFactories; {$IFDEF FPC} {$MODE DELPHI}{$H+} {$ENDIF} interface uses SysUtils, Firebird; type ...
, .
unit UdrFactories; {$IFDEF FPC} {$MODE DELPHI}{$H+} {$ENDIF} interface uses SysUtils, Firebird; type ...
, .
UDR .
unit UdrFactories; {$IFDEF FPC} {$MODE DELPHI}{$H+} {$ENDIF} interface uses SysUtils, Firebird; type ...
newItem ,
, .
implementation ... procedure TFunctionFactory<T>.dispose; begin Destroy; end; function TFunctionFactory<T>.newItem(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata): IExternalFunction; begin Result := T.Create; (Result as T).Metadata := AMetadata; end; procedure TFunctionFactory<T>.setup(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata; AInBuilder, AOutBuilder: IMetadataBuilder); begin end; procedure TProcedureFactory<T>.dispose; begin Destroy; end; function TProcedureFactory<T>.newItem(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata): IExternalProcedure; begin Result := T.Create; (Result as T).Metadata := AMetadata; end; procedure TProcedureFactory<T>.setup(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata; AInBuilder, AOutBuilder: IMetadataBuilder); begin end; procedure TTriggerFactory<T>.dispose; begin Destroy; end; function TTriggerFactory<T>.newItem(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata): IExternalTrigger; begin Result := T.Create; (Result as T).Metadata := AMetadata; end; procedure TTriggerFactory<T>.setup(AStatus: IStatus; AContext: IExternalContext; AMetadata: IRoutineMetadata; AFieldsBuilder: IMetadataBuilder); begin end;
https://github.com/sim1984/udr-book/blob/master/examples/Common/UdrFactories.pas .
BLOB
BLOB ( BLOB), . , BLOB , . BLOB . BLOB
IBlob .
BLOB , BLOB , BLOB , BLOB .
BLOB , BLOB (), 64 . getSegment IBlob . putSegment IBlob .
BLOB
BLOB
(
LIST).
create procedure split ( txt blob sub_type text character set utf8, delimiter char(1) character set utf8 = ',' ) returns ( id integer ) external name 'myudr!split' engine udr;
:
function firebird_udr_plugin(AStatus: IStatus; AUnloadFlagLocal: BooleanPtr; AUdrPlugin: IUdrPlugin): BooleanPtr; cdecl; begin
, . .
. .
TInput = record txt: ISC_QUAD; txtNull: WordBool; delimiter: array [0 .. 3] of AnsiChar; delimiterNull: WordBool; end; TInputPtr = ^TInput; TOutput = record Id: Integer; Null: WordBool; end; TOutputPtr = ^TOutput;
BLOB BLOB, ISC_QUAD .
:
Split TSplitProcedure = class(IExternalProcedureImpl) private procedure SaveBlobToStream(AStatus: IStatus; AContext: IExternalContext; ABlobId: ISC_QUADPtr; AStream: TStream); function readBlob(AStatus: IStatus; AContext: IExternalContext; ABlobId: ISC_QUADPtr): string; public
SaveBlobToStream readBlob BLOB. BLOB , — Delphi. OutputArray Counter.
open BLOB . Split . .
TSplitProcedure.open function TSplitProcedure.open(AStatus: IStatus; AContext: IExternalContext; AInMsg, AOutMsg: Pointer): IExternalResultSet; var xInput: TInputPtr; xText: string; xDelimiter: string; begin xInput := AInMsg; if xInput.txtNull or xInput.delimiterNull then begin Result := nil; Exit; end; xText := readBlob(AStatus, AContext, @xInput.txt); xDelimiter := TFBCharSet.CS_UTF8.GetString(TBytes(@xInput.delimiter), 0, 4);
Observación
TFBCharSet Firebird.pas.
Firebird.
UTF-8.
FbCharsets.pas
BLOB . BLOB . openBlob IAttachment . BLOB , . ,
( IExternalContext ).
BLOB (), 64 . getSegment IBlob .
TSplitProcedure.SaveBlobToStream procedure TSplitProcedure.SaveBlobToStream(AStatus: IStatus; AContext: IExternalContext; ABlobId: ISC_QUADPtr; AStream: TStream); var att: IAttachment; trx: ITransaction; blob: IBlob; buffer: array [0 .. 32767] of AnsiChar; l: Integer; begin try att := AContext.getAttachment(AStatus); trx := AContext.getTransaction(AStatus); blob := att.openBlob(AStatus, trx, ABlobId, 0, nil); while True do begin case blob.getSegment(AStatus, SizeOf(buffer), @buffer, @l) of IStatus.RESULT_OK: AStream.WriteBuffer(buffer, l); IStatus.RESULT_SEGMENT: AStream.WriteBuffer(buffer, l); else break; end; end; AStream.Position := 0; blob.close(AStatus); finally if Assigned(att) then att.release; if Assigned(trx) then trx.release; if Assigned(blob) then blob.release; end; end;
Observación
, IAttachment , ITransaction IBlob
IReferenceCounted ,
.
1.
release.
SaveBlobToStream BLOB
:
function TSplitProcedure.readBlob(AStatus: IStatus; AContext: IExternalContext; ABlobId: ISC_QUADPtr): string; var {$IFDEF FPC} xStream: TBytesStream; {$ELSE} xStream: TStringStream; {$ENDIF} begin {$IFDEF FPC} xStream := TBytesStream.Create(nil); {$ELSE} xStream := TStringStream.Create('', 65001); {$ENDIF} try SaveBlobToStream(AStatus, AContext, ABlobId, xStream); {$IFDEF FPC} Result := TEncoding.UTF8.GetString(xStream.Bytes, 0, xStream.Size); {$ELSE} Result := xStream.DataString; {$ENDIF} finally xStream.Free; end; end;
Observación
Free Pascal
Delphi TStringStream . FPC
,
.
fetch Counter , . . isc_convert_error .
isc_convert_error procedure TSplitResultSet.dispose; begin SetLength(OutputArray, 0); Destroy; end; function TSplitResultSet.fetch(AStatus: IStatus): Boolean; var statusVector: array [0 .. 4] of NativeIntPtr; begin if Counter <= High(OutputArray) then begin Output.Null := False;
Observación
isc_random
, .
:
SELECT ids.ID FROM SPLIT((SELECT LIST(ID) FROM MYTABLE), ',') ids
Observación
, BLOB
,
.
,
.
fetch .
BLOB
BLOB
BLOB .
Observación
UDF
BLOB / . UDF
blobsaveload.zip
BLOB /
CREATE PACKAGE BlobFileUtils AS BEGIN PROCEDURE SaveBlobToFile(ABlob BLOB, AFileName VARCHAR(255) CHARACTER SET UTF8); FUNCTION LoadBlobFromFile(AFileName VARCHAR(255) CHARACTER SET UTF8) RETURNS BLOB; END^ CREATE PACKAGE BODY BlobFileUtils AS BEGIN PROCEDURE SaveBlobToFile(ABlob BLOB, AFileName VARCHAR(255) CHARACTER SET UTF8) EXTERNAL NAME 'BlobFileUtils!SaveBlobToFile' ENGINE UDR; FUNCTION LoadBlobFromFile(AFileName VARCHAR(255) CHARACTER SET UTF8) RETURNS BLOB EXTERNAL NAME 'BlobFileUtils!LoadBlobFromFile' ENGINE UDR; END^
:
function firebird_udr_plugin(AStatus: IStatus; AUnloadFlagLocal: BooleanPtr; AUdrPlugin: IUdrPlugin): BooleanPtr; cdecl; begin
BLOB , UDR
06.BlobSaveLoad . LoadBlobFromFile :
interface uses Firebird, Classes, SysUtils; type
execute TLoadBlobFromFile , .
execute procedure TLoadBlobFromFileFunc.execute(AStatus: IStatus; AContext: IExternalContext; AInMsg: Pointer; AOutMsg: Pointer); const MaxBufSize = 16384; var xInput: TInputPtr; xOutput: TOutputPtr; xFileName: string; xStream: TFileStream; att: IAttachment; trx: ITransaction; blob: IBlob; buffer: array [0 .. 32767] of Byte; xStreamSize: Integer; xBufferSize: Integer; xReadLength: Integer; begin xInput := AInMsg; xOutput := AOutMsg; if xInput.filenameNull then begin xOutput.blobDataNull := True; Exit; end; xOutput.blobDataNull := False;
BLOB blobId createBlob IAttachment . BLOB , . , ( IExternalContext ).
BLOB, putSegment IBlob , . close .
BLOB
BLOB
, BLOB .
BLOB,
.
Delphi Free Pascal
.
IBlob
/ Blob.
FbBlob, .
BlobHelper unit FbBlob; interface uses Classes, SysUtils, Firebird; const MAX_SEGMENT_SIZE = $7FFF; type TFbBlobHelper = class helper for IBlob procedure LoadFromStream(AStatus: IStatus; AStream: TStream); procedure SaveToStream(AStatus: IStatus; AStream: TStream); end; implementation uses Math; procedure TFbBlobHelper.LoadFromStream(AStatus: IStatus; AStream: TStream); var xStreamSize: Integer; xReadLength: Integer; xBuffer: array [0 .. MAX_SEGMENT_SIZE] of Byte; begin xStreamSize := AStream.Size; AStream.Position := 0; while xStreamSize <> 0 do begin xReadLength := Min(xStreamSize, MAX_SEGMENT_SIZE); AStream.ReadBuffer(xBuffer, xReadLength); Self.putSegment(AStatus, xReadLength, @xBuffer[0]); Dec(xStreamSize, xReadLength); end; end; procedure TFbBlobHelper.SaveToStream(AStatus: IStatus; AStream: TStream); var xInfo: TFbBlobInfo; Buffer: array [0 .. MAX_SEGMENT_SIZE] of Byte; xBytesRead: Cardinal; xBufferSize: Cardinal; begin AStream.Position := 0; xBufferSize := Min(SizeOf(Buffer), MAX_SEGMENT_SIZE); while True do begin case Self.getSegment(AStatus, xBufferSize, @Buffer[0], @xBytesRead) of IStatus.RESULT_OK: AStream.WriteBuffer(Buffer, xBytesRead); IStatus.RESULT_SEGMENT: AStream.WriteBuffer(Buffer, xBytesRead); else break; end; end; end; end.
BLOB, BLOB :
TLoadBlobFromFileFunc.execute procedure TLoadBlobFromFileFunc.execute(AStatus: IStatus; AContext: IExternalContext; AInMsg: Pointer; AOutMsg: Pointer); var xInput: TInputPtr; xOutput: TOutputPtr; xFileName: string; xStream: TFileStream; att: IAttachment; trx: ITransaction; blob: IBlob; begin xInput := AInMsg; xOutput := AOutMsg; if xInput.filenameNull then begin xOutput.blobDataNull := True; Exit; end; xOutput.blobDataNull := False;
, , , / . , BLOB.
, IExternalContext execute , open . IExternalContext getAttachment , getTransaction . UDR, , , startTransaction IExternalContext . . , , .. (2PC).
, SELECT JSON. :
create function GetJson ( sql_text blob sub_type text character set utf8, sql_dialect smallint not null default 3 ) returns returns blob sub_type text character set utf8 external name 'JsonUtils!getJson' engine udr;
SQL , , . IMessageMetadata . , ,
Firebird.
Observación
JSON .
CHAR, VARCHAR OCTETS NONE BLOB SUB_TYPE BINARY
base64,
JSON.
:
function firebird_udr_plugin(AStatus: IStatus; AUnloadFlagLocal: BooleanPtr; AUdrPlugin: IUdrPlugin): BooleanPtr; cdecl; begin
, :
GetJson unit JsonFunc; {$IFDEF FPC} {$MODE objfpc}{$H+} {$DEFINE DEBUGFPC} {$ENDIF} interface uses Firebird, UdrFactories, FbTypes, FbCharsets, SysUtils, System.NetEncoding, System.Json;
MakeScaleInteger , writeJson Json . , execute .
TJsonFunction.execute procedure TJsonFunction.execute(AStatus: IStatus; AContext: IExternalContext; AInMsg, AOutMsg: Pointer); var xFormatSettings: TFormatSettings; xInput: InputPtr; xOutput: OutputPtr; att: IAttachment; tra: ITransaction; stmt: IStatement; inBlob, outBlob: IBlob; inStream: TBytesStream; outStream: TStringStream; cursorMetaData: IMessageMetadata; rs: IResultSet; msgLen: Cardinal; msg: Pointer; jsonArray: TJsonArray; begin xInput := AInMsg; xOutput := AOutMsg;
getAttachment getTransaction IExternalContext . BLOB SQL . prepare IAttachment . SQL . IStatement.PREPARE_PREFETCH_METADATA , . getOutputMetadata IStatement .
Observación
getOutputMetadata .
IStatement.PREPARE_PREFETCH_METADATA
.
, .
openCursor ( 2). getMessageLength IMessageMetadata . , .
fetchNext IResultSet . msg IStatus.RESULT_OK , . writeJson , TJsonObject TJsonArray .
, close , Json , , Blob.
writeJson . IUtil , . IMessageMetadata . TJsonObject . . NullFlag, null , Json.
writeJson function TJsonFunction.MakeScaleInteger(AValue: Int64; Scale: Smallint): string; var L: Integer; begin Result := AValue.ToString; L := Result.Length; if (-Scale >= L) then Result := '0.' + Result.PadLeft(-Scale, '0') else Result := Result.Insert(Scale + L, '.'); end; procedure TJsonFunction.writeJson(AStatus: IStatus; AContext: IExternalContext; AJson: TJsonArray; ABuffer: PByte; AMeta: IMessageMetadata; AFormatSettings: TFormatSettings); var jsonObject: TJsonObject; i: Integer; FieldName: string; NullFlag: WordBool; pData: PByte; util: IUtil; metaLength: Integer;
Observación
TFbType Firebird.pas .
,
FbTypes .
TFBCharSet Firebird.pas .
FbCharsets . ,
,
, , ,
TEncoding ,
Delphi.
CHAR VARCHAR , OCTETS, base64, Delphi. , VARCHAR 2 .
SMALLINT, INTEGER, BIGINT , . getScale IMessageMetadata . 0, , MakeScaleInteger .
DATE, TIME TIMESTAMP decodeDate decodeTime IUtil . - Delphi TDateTime .
BLOB Delphi. BLOB , TBytesStream . base64. BLOB , TStringStream , . BLOB
.
Eso es todo UDR Firebird, .