From 27930ea3c486b3e94bfaab676052eda4e8768087 Mon Sep 17 00:00:00 2001 From: marco Date: Sat, 26 Jan 2008 17:12:43 +0000 Subject: * postgres and sqlite moved git-svn-id: http://svn.freepascal.org/svn/fpc/trunk@9945 3ad0048d-3df7-0310-abae-a5850022a9f2 --- packages/sqlite/Makefile.fpc | 29 ++ packages/sqlite/fpmake.pp | 49 +++ packages/sqlite/src/sqlite.pp | 162 +++++++++ packages/sqlite/src/sqlite3.inc | 576 ++++++++++++++++++++++++++++++++ packages/sqlite/src/sqlite3.pp | 5 + packages/sqlite/src/sqlite3db.pas | 494 +++++++++++++++++++++++++++ packages/sqlite/src/sqlite3dyn.pp | 7 + packages/sqlite/src/sqlitedb.pas | 410 +++++++++++++++++++++++ packages/sqlite/tests/test.pas | 52 +++ packages/sqlite/tests/testapiv3x.README | 44 +++ packages/sqlite/tests/testapiv3x.pp | 83 +++++ 11 files changed, 1911 insertions(+) create mode 100644 packages/sqlite/Makefile.fpc create mode 100644 packages/sqlite/fpmake.pp create mode 100644 packages/sqlite/src/sqlite.pp create mode 100644 packages/sqlite/src/sqlite3.inc create mode 100644 packages/sqlite/src/sqlite3.pp create mode 100644 packages/sqlite/src/sqlite3db.pas create mode 100644 packages/sqlite/src/sqlite3dyn.pp create mode 100644 packages/sqlite/src/sqlitedb.pas create mode 100644 packages/sqlite/tests/test.pas create mode 100644 packages/sqlite/tests/testapiv3x.README create mode 100644 packages/sqlite/tests/testapiv3x.pp (limited to 'packages/sqlite') diff --git a/packages/sqlite/Makefile.fpc b/packages/sqlite/Makefile.fpc new file mode 100644 index 0000000000..2874cfc133 --- /dev/null +++ b/packages/sqlite/Makefile.fpc @@ -0,0 +1,29 @@ +# +# Makefile.fpc for sqlite implementation +# + +[package] +name=sqlite +version=2.0.0 + +[target] +units=sqlite sqlite3 sqlite3dyn sqlitedb sqlite3db + +[require] + +[install] +fpcpackage=y + +[default] +fpcdir=../.. + +[compiler] +includedir=src +sourcedir=src tests examples + +[shared] +build=n + +[rules] +.NOTPARALLEL: + diff --git a/packages/sqlite/fpmake.pp b/packages/sqlite/fpmake.pp new file mode 100644 index 0000000000..2e820d8490 --- /dev/null +++ b/packages/sqlite/fpmake.pp @@ -0,0 +1,49 @@ +{$ifndef ALLPACKAGES} +{$mode objfpc}{$H+} +program fpmake; + +uses fpmkunit; + +Var + P : TPackage; + T : TTarget; +begin + With Installer do + begin +{$endif ALLPACKAGES} + + P:=AddPackage('sqlite'); +{$ifdef ALLPACKAGES} + P.Directory:='sqlite'; +{$endif ALLPACKAGES} + P.Version:='2.0.0'; + P.SourcePath.Add('src'); + + T:=P.Targets.AddUnit('sqlite3db.pas'); + with T.Dependencies do + begin + AddUnit('sqlite3'); + end; + T:=P.Targets.AddUnit('sqlite3dyn.pp'); + with T.Dependencies do + begin + AddInclude('sqlite3.inc'); + end; + T:=P.Targets.AddUnit('sqlite3.pp'); + with T.Dependencies do + begin + AddInclude('sqlite3.inc'); + end; + T:=P.Targets.AddUnit('sqlitedb.pas'); + with T.Dependencies do + begin + AddUnit('sqlite'); + end; + T:=P.Targets.AddUnit('sqlite.pp'); + + +{$ifndef ALLPACKAGES} + Run; + end; +end. +{$endif ALLPACKAGES} diff --git a/packages/sqlite/src/sqlite.pp b/packages/sqlite/src/sqlite.pp new file mode 100644 index 0000000000..277ef1227f --- /dev/null +++ b/packages/sqlite/src/sqlite.pp @@ -0,0 +1,162 @@ +{$mode objfpc} + +{$ifdef bsd} + {$linklib c} +{$endif} + +unit sqlite; + +interface + +{ + Automatically converted by H2Pas 0.99.15 from sqlite.h + The following command line parameters were used: + -S + -D + -p + -l + sqlite + sqlite.h +} + +{$PACKRECORDS C} + +const + External_library='sqlite'; + + SQLITE_ISO8859 = 1;//? + + //sqlite_exec and sqlite_step return values + SQLITE_OK = 0; + SQLITE_ERROR = 1; + SQLITE_INTERNAL = 2; + SQLITE_PERM = 3; + SQLITE_ABORT = 4; + SQLITE_BUSY = 5; + SQLITE_LOCKED = 6; + SQLITE_NOMEM = 7; + SQLITE_READONLY = 8; + SQLITE_INTERRUPT = 9; + SQLITE_IOERR = 10; + SQLITE_CORRUPT = 11; + SQLITE_NOTFOUND = 12; + SQLITE_FULL = 13; + SQLITE_CANTOPEN = 14; + SQLITE_PROTOCOL = 15; + SQLITE_EMPTY = 16; + SQLITE_SCHEMA = 17; + SQLITE_TOOBIG = 18; + SQLITE_CONSTRAINT = 19; + SQLITE_MISMATCH = 20; + SQLITE_MISUSE = 21; + SQLITE_NOLFS = 22; + SQLITE_AUTH = 23; + SQLITE_FORMAT = 24; + SQLITE_RANGE = 25; + SQLITE_ROW = 100; + SQLITE_DONE = 101; + + // values used in sqlite_set_authorizer to define what operations authorize + SQLITE_COPY = 0; + SQLITE_CREATE_INDEX = 1; + SQLITE_CREATE_TABLE = 2; + SQLITE_CREATE_TEMP_INDEX = 3; + SQLITE_CREATE_TEMP_TABLE = 4; + SQLITE_CREATE_TEMP_TRIGGER = 5; + SQLITE_CREATE_TEMP_VIEW = 6; + SQLITE_CREATE_TRIGGER = 7; + SQLITE_CREATE_VIEW = 8; + SQLITE_DELETE = 9; + SQLITE_DROP_INDEX = 10; + SQLITE_DROP_TABLE = 11; + SQLITE_DROP_TEMP_INDEX = 12; + SQLITE_DROP_TEMP_TABLE = 13; + SQLITE_DROP_TEMP_TRIGGER = 14; + SQLITE_DROP_TEMP_VIEW = 15; + SQLITE_DROP_TRIGGER = 16; + SQLITE_DROP_VIEW = 17; + SQLITE_INSERT = 18; + SQLITE_PRAGMA = 19; + SQLITE_READ = 20; + SQLITE_SELECT = 21; + SQLITE_TRANSACTION = 22; + SQLITE_UPDATE = 23; + + //Return values of the authorizer function + SQLITE_DENY = 1; + SQLITE_IGNORE = 2; + + SQLITE_NUMERIC = -1; + SQLITE_TEXT = -2; + SQLITE_ARGS = -3; + +Type + PPPchar = ^ppchar; + Psqlite = Pointer; + Psqlite_vm = Pointer; + PPsqlite_vm = ^Psqlite_vm; + Psqlite_func = Pointer; + + // Procedural types used in functions. + + sqlite_callback = function (_para1:pointer; _para2:longint; _para3:PPchar; _para4:PPchar):longint;cdecl; + sqlite_trace_func = procedure (_para1:pointer; _para2:Pchar);cdecl; + sqlite_create_func = procedure (_para1:Psqlite_func; _para2:longint; _para3:PPchar);cdecl; + sqlite_handler = function (_para1:pointer; _para2:Pchar; _para3:longint):longint;cdecl; + sqlite_step_func = procedure (_para1:Psqlite_func; _para2:longint; _para3:PPchar);cdecl; + sqlite_finalize_func = procedure (_para1:Psqlite_func);cdecl; + sqlite_authorize_func = function (_para1:pointer; _para2:longint; _para3, _para4,_para5,_para6:Pchar):longint;cdecl; + + function sqlite_create_function(_para1:Psqlite; zName:Pchar; nArg:longint; xFunc:sqlite_create_func; pUserData:pointer):longint;cdecl;external External_library name 'sqlite_create_function'; + function sqlite_open(filename:Pchar; mode:longint; errmsg:PPchar):Psqlite;cdecl;external External_library name 'sqlite_open'; + procedure sqlite_close(_para1:Psqlite);cdecl;external External_library name 'sqlite_close'; + function sqlite_exec(_para1:Psqlite; sql:Pchar; _para3:sqlite_callback; _para4:pointer; errmsg:PPchar):longint;cdecl;external External_library name 'sqlite_exec'; + function sqlite_last_insert_rowid(_para1:Psqlite):longint;cdecl;external External_library name 'sqlite_last_insert_rowid'; + function sqlite_changes(_para1:Psqlite):longint;cdecl;external External_library name 'sqlite_changes'; + function sqlite_error_string(_para1:longint):Pchar;cdecl;external External_library name 'sqlite_error_string'; + procedure do_sqlite_interrupt(_para1:Psqlite);cdecl;external External_library name 'sqlite_interrupt'; + function sqlite_complete(sql:Pchar):longint;cdecl;external External_library name 'sqlite_complete'; + procedure sqlite_busy_handler(_para1:Psqlite; _para2:sqlite_handler; _para3:pointer);cdecl;external External_library name 'sqlite_busy_handler'; + procedure sqlite_busy_timeout(_para1:Psqlite; ms:longint);cdecl;external External_library name 'sqlite_busy_timeout'; + function sqlite_get_table(_para1:Psqlite; sql:Pchar; resultp:PPPchar; nrow:Plongint; ncolumn:Plongint; + errmsg:PPchar):longint;cdecl;external External_library name 'sqlite_get_table'; + procedure sqlite_free_table(result:PPchar);cdecl;external External_library name 'sqlite_free_table'; + function sqlite_exec_printf(_para1:Psqlite; sqlFormat:Pchar; _para3:sqlite_callback; _para4:pointer; errmsg:PPchar; + args:array of const):longint;cdecl;external External_library name 'sqlite_exec_printf'; + function sqlite_exec_printf(_para1:Psqlite; sqlFormat:Pchar; _para3:sqlite_callback; _para4:pointer; errmsg:PPchar):longint;cdecl;varargs;external External_library name 'sqlite_exec_printf'; + function sqlite_exec_vprintf(_para1:Psqlite; sqlFormat:Pchar; _para3:sqlite_callback; _para4:pointer; errmsg:PPchar; + ap:array of const):longint;cdecl;external External_library name 'sqlite_exec_vprintf'; + function sqlite_get_table_printf(_para1:Psqlite; sqlFormat:Pchar; resultp:PPPchar; nrow:Plongint; ncolumn:Plongint; + errmsg:PPchar; args:array of const):longint;cdecl;external External_library name 'sqlite_get_table_printf'; + function sqlite_get_table_printf(_para1:Psqlite; sqlFormat:Pchar; resultp:PPPchar; nrow:Plongint; ncolumn:Plongint; + errmsg:PPchar):longint;cdecl;varargs;external External_library name 'sqlite_get_table_printf'; + function sqlite_get_table_vprintf(_para1:Psqlite; sqlFormat:Pchar; resultp:PPPchar; nrow:Plongint; ncolumn:Plongint; + errmsg:PPchar; ap:array of const):longint;cdecl;external External_library name 'sqlite_get_table_vprintf'; + function sqlite_mprintf(_para1:Pchar; args:array of const):Pchar;cdecl;external External_library name 'sqlite_mprintf'; + function sqlite_mprintf(_para1:Pchar):Pchar;cdecl;varargs;external External_library name 'sqlite_mprintf'; + procedure sqlite_freemem(p:pointer);cdecl;external External_library name 'sqlite_freemem'; + function sqlite_libversion:Pchar;cdecl;external External_library name 'sqlite_libversion'; + function sqlite_libencoding:Pchar;cdecl;external External_library name 'sqlite_libencoding'; + function sqlite_create_aggregate(_para1:Psqlite; zName:Pchar; nArg:longint; xStep:sqlite_step_func ; xFinalize:sqlite_finalize_func; + pUserData:pointer):longint;cdecl;external External_library name 'sqlite_create_aggregate'; + function sqlite_function_type(db:Psqlite; zName:Pchar; datatype:longint):longint;cdecl;external External_library name 'sqlite_function_type'; + function sqlite_set_result_string(_para1:Psqlite_func; _para2:Pchar; _para3:longint):Pchar;cdecl;external External_library name 'sqlite_set_result_string'; + procedure sqlite_set_result_int(_para1:Psqlite_func; _para2:longint);cdecl;external External_library name 'sqlite_set_result_int'; + procedure sqlite_set_result_double(_para1:Psqlite_func; _para2:double);cdecl;external External_library name 'sqlite_set_result_double'; + procedure sqlite_set_result_error(_para1:Psqlite_func; _para2:Pchar; _para3:longint);cdecl;external External_library name 'sqlite_set_result_error'; + function sqlite_user_data(_para1:Psqlite_func):pointer;cdecl;external External_library name 'sqlite_user_data'; + function sqlite_aggregate_context(_para1:Psqlite_func; nBytes:longint):pointer;cdecl;external External_library name 'sqlite_aggregate_context'; + function sqlite_aggregate_count(_para1:Psqlite_func):longint;cdecl;external External_library name 'sqlite_aggregate_count'; + function sqlite_set_authorizer(_para1:Psqlite; xAuth:sqlite_authorize_func ; pUserData:pointer):longint;cdecl;external External_library name 'sqlite_set_authorizer'; + function sqlite_trace(_para1:Psqlite; xTrace:sqlite_trace_func; _para3:pointer):pointer;cdecl;external External_library name 'sqlite_trace'; + function sqlite_compile(db:Psqlite; zSql:Pchar; pzTail:PPchar; ppVm:PPsqlite_vm; pzErrmsg:PPchar):longint;cdecl;external External_library name 'sqlite_compile'; + function sqlite_step(pVm:Psqlite_vm; pN:Plongint; pazValue:PPPchar; pazColName:PPPchar):longint;cdecl;external External_library name 'sqlite_step'; + function sqlite_finalize(_para1:Psqlite_vm; pzErrMsg:PPchar):longint;cdecl;external External_library name 'sqlite_finalize'; + + //Use functions instead of external variables to retrieve version and encoding info + function sqlite_version: PChar external External_library name 'sqlite_libversion'; + function sqlite_encoding: PChar external External_library name 'sqlite_libencoding'; + +implementation + +end. diff --git a/packages/sqlite/src/sqlite3.inc b/packages/sqlite/src/sqlite3.inc new file mode 100644 index 0000000000..830f321a88 --- /dev/null +++ b/packages/sqlite/src/sqlite3.inc @@ -0,0 +1,576 @@ +{$mode objfpc} + +{$ifdef BSD} + {$linklib c} + {$linklib pthread} +{$endif} + +interface + +{$ifdef LOAD_DYNAMICALLY} +uses + SysUtils, DynLibs; +{$endif} + +{ + Automatically converted by H2Pas 0.99.16 from sqlite3.h + The following command line parameters were used: + -D + -c + sqlite3.h + + Manual corrections made by Luiz Américo - 2005 +} + +{$PACKRECORDS C} + +const +{$IFDEF WINDOWS} + Sqlite3Lib = 'sqlite3.dll'; +{$else} + Sqlite3Lib = 'libsqlite3.so'; +{$endif} + + SQLITE_INTEGER = 1; + SQLITE_FLOAT = 2; +{ #define SQLITE_TEXT 3 // See below } + SQLITE_BLOB = 4; + SQLITE_NULL = 5; + SQLITE_TEXT = 3; + SQLITE3_TEXT = 3; + SQLITE_UTF8 = 1; + SQLITE_UTF16LE = 2; + SQLITE_UTF16BE = 3; +{ Use native byte order } + SQLITE_UTF16 = 4; +{ sqlite3_create_function only } + SQLITE_ANY = 5; + + //sqlite_exec return values + SQLITE_OK = 0; + SQLITE_ERROR = 1;{ SQL error or missing database } + SQLITE_INTERNAL = 2;{ An internal logic error in SQLite } + SQLITE_PERM = 3; { Access permission denied } + SQLITE_ABORT = 4; { Callback routine requested an abort } + SQLITE_BUSY = 5; { The database file is locked } + SQLITE_LOCKED = 6;{ A table in the database is locked } + SQLITE_NOMEM = 7; { A malloc() failed } + SQLITE_READONLY = 8;{ Attempt to write a readonly database } + SQLITE_INTERRUPT = 9;{ Operation terminated by sqlite3_interrupt() } + SQLITE_IOERR = 10; { Some kind of disk I/O error occurred } + SQLITE_CORRUPT = 11; { The database disk image is malformed } + SQLITE_NOTFOUND = 12; { (Internal Only) Table or record not found } + SQLITE_FULL = 13; { Insertion failed because database is full } + SQLITE_CANTOPEN = 14; { Unable to open the database file } + SQLITE_PROTOCOL = 15; { Database lock protocol error } + SQLITE_EMPTY = 16; { Database is empty } + SQLITE_SCHEMA = 17; { The database schema changed } + SQLITE_TOOBIG = 18; { Too much data for one row of a table } + SQLITE_CONSTRAINT = 19; { Abort due to contraint violation } + SQLITE_MISMATCH = 20; { Data type mismatch } + SQLITE_MISUSE = 21; { Library used incorrectly } + SQLITE_NOLFS = 22; { Uses OS features not supported on host } + SQLITE_AUTH = 23; { Authorization denied } + SQLITE_FORMAT = 24; { Auxiliary database format error } + SQLITE_RANGE = 25; { 2nd parameter to sqlite3_bind out of range } + SQLITE_NOTADB = 26; { File opened that is not a database file } + SQLITE_ROW = 100; { sqlite3_step() has another row ready } + SQLITE_DONE = 101; { sqlite3_step() has finished executing } + + SQLITE_COPY = 0; + SQLITE_CREATE_INDEX = 1; + SQLITE_CREATE_TABLE = 2; + SQLITE_CREATE_TEMP_INDEX = 3; + SQLITE_CREATE_TEMP_TABLE = 4; + SQLITE_CREATE_TEMP_TRIGGER = 5; + SQLITE_CREATE_TEMP_VIEW = 6; + SQLITE_CREATE_TRIGGER = 7; + SQLITE_CREATE_VIEW = 8; + SQLITE_DELETE = 9; + SQLITE_DROP_INDEX = 10; + SQLITE_DROP_TABLE = 11; + SQLITE_DROP_TEMP_INDEX = 12; + SQLITE_DROP_TEMP_TABLE = 13; + SQLITE_DROP_TEMP_TRIGGER = 14; + SQLITE_DROP_TEMP_VIEW = 15; + SQLITE_DROP_TRIGGER = 16; + SQLITE_DROP_VIEW = 17; + SQLITE_INSERT = 18; + SQLITE_PRAGMA = 19; + SQLITE_READ = 20; + SQLITE_SELECT = 21; + SQLITE_TRANSACTION = 22; + SQLITE_UPDATE = 23; + SQLITE_ATTACH = 24; + SQLITE_DETACH = 25; + SQLITE_ALTER_TABLE = 26; + SQLITE_REINDEX = 27; + + SQLITE_DENY = 1; + SQLITE_IGNORE = 2; + +// Original from sqlite3.h: +//#define SQLITE_STATIC ((void(*)(void *))0) +//#define SQLITE_TRANSIENT ((void(*)(void *))-1) +Const + SQLITE_STATIC = 0; + SQLITE_TRANSIENT = -1; + +type + sqlite_int64 = int64; + sqlite_uint64 = qword; + PPPChar = ^PPChar; + Psqlite3 = Pointer; + PPSqlite3 = ^PSqlite3; + Psqlite3_context = Pointer; + Psqlite3_stmt = Pointer; + PPsqlite3_stmt = ^Psqlite3_stmt; + Psqlite3_value = Pointer; + PPsqlite3_value = ^Psqlite3_value; + +//Callback function types +//Notice that most functions were named using as prefix the function name that uses them, +//rather than describing their functions + + sqlite3_callback = function (_para1:pointer; _para2:longint; _para3:PPchar; _para4:PPchar):longint;cdecl; + busy_handler_func = function (_para1:pointer; _para2:longint):longint;cdecl; + sqlite3_set_authorizer_func = function (_para1:pointer; _para2:longint; _para3:Pchar; _para4:Pchar; _para5:Pchar; _para6:Pchar):longint;cdecl; + sqlite3_trace_func = procedure (_para1:pointer; _para2:Pchar);cdecl; + sqlite3_progress_handler_func = function (_para1:pointer):longint;cdecl; + sqlite3_commit_hook_func = function (_para1:pointer):longint;cdecl; + bind_destructor_func = procedure (_para1:pointer);cdecl; + create_function_step_func = procedure (_para1:Psqlite3_context; _para2:longint; _para3:PPsqlite3_value);cdecl; + create_function_func_func = procedure (_para1:Psqlite3_context; _para2:longint; _para3:PPsqlite3_value);cdecl; + create_function_final_func = procedure (_para1:Psqlite3_context);cdecl; + sqlite3_set_auxdata_func = procedure (_para1:pointer);cdecl; + sqlite3_result_func = procedure (_para1:pointer);cdecl; + sqlite3_create_collation_func = function (_para1:pointer; _para2:longint; _para3:pointer; _para4:longint; _para5:pointer):longint;cdecl; + sqlite3_collation_needed_func = procedure (_para1:pointer; _para2:Psqlite3; eTextRep:longint; _para4:Pchar);cdecl; + +{$ifndef win32} +var + //This is not working under windows. Any clues? + sqlite3_temp_directory : Pchar;cvar; external; +{$endif} + +{$IFNDEF LOAD_DYNAMICALLY} + +function sqlite3_close(_para1:Psqlite3):longint;cdecl; external Sqlite3Lib name 'sqlite3_close'; +function sqlite3_exec(_para1:Psqlite3; sql:Pchar; _para3:sqlite3_callback; _para4:pointer; errmsg:PPchar):longint;cdecl; external Sqlite3Lib name 'sqlite3_exec'; +function sqlite3_last_insert_rowid(_para1:Psqlite3):sqlite_int64;cdecl; external Sqlite3Lib name 'sqlite3_last_insert_rowid'; +function sqlite3_changes(_para1:Psqlite3):longint;cdecl; external Sqlite3Lib name 'sqlite3_changes'; +function sqlite3_total_changes(_para1:Psqlite3):longint;cdecl; external Sqlite3Lib name 'sqlite3_total_changes'; +procedure sqlite3_interrupt(_para1:Psqlite3);cdecl; external Sqlite3Lib name 'sqlite3_interrupt'; +function sqlite3_complete(sql:Pchar):longint;cdecl; external Sqlite3Lib name 'sqlite3_complete'; +function sqlite3_complete16(sql:pointer):longint;cdecl; external Sqlite3Lib name 'sqlite3_complete16'; +function sqlite3_busy_handler(_para1:Psqlite3; _para2:busy_handler_func; _para3:pointer):longint;cdecl; external Sqlite3Lib name 'sqlite3_busy_handler'; +function sqlite3_busy_timeout(_para1:Psqlite3; ms:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_busy_timeout'; +function sqlite3_get_table(_para1:Psqlite3; sql:Pchar; resultp:PPPchar; nrow:Plongint; ncolumn:Plongint; errmsg:PPchar):longint;cdecl; external Sqlite3Lib name 'sqlite3_get_table'; +procedure sqlite3_free_table(result:PPchar);cdecl; external Sqlite3Lib name 'sqlite3_free_table'; +// Todo: see how translate sqlite3_mprintf, sqlite3_vmprintf, sqlite3_snprintf +// function sqlite3_mprintf(_para1:Pchar; args:array of const):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_mprintf'; +function sqlite3_mprintf(_para1:Pchar):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_mprintf'; +//function sqlite3_vmprintf(_para1:Pchar; _para2:va_list):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_vmprintf'; +procedure sqlite3_free(z:Pchar);cdecl; external Sqlite3Lib name 'sqlite3_free'; +//function sqlite3_snprintf(_para1:longint; _para2:Pchar; _para3:Pchar; args:array of const):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_snprintf'; +function sqlite3_snprintf(_para1:longint; _para2:Pchar; _para3:Pchar):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_snprintf'; +function sqlite3_set_authorizer(_para1:Psqlite3; xAuth:sqlite3_set_authorizer_func; pUserData:pointer):longint;cdecl; external Sqlite3Lib name 'sqlite3_set_authorizer'; +function sqlite3_trace(_para1:Psqlite3; xTrace:sqlite3_trace_func; _para3:pointer):pointer;cdecl; external Sqlite3Lib name 'sqlite3_trace'; +procedure sqlite3_progress_handler(_para1:Psqlite3; _para2:longint; _para3:sqlite3_progress_handler_func; _para4:pointer);cdecl; external Sqlite3Lib name 'sqlite3_progress_handler'; +function sqlite3_commit_hook(_para1:Psqlite3; _para2:sqlite3_commit_hook_func; _para3:pointer):pointer;cdecl; external Sqlite3Lib name 'sqlite3_commit_hook'; +function sqlite3_open(filename:Pchar; ppDb:PPsqlite3):longint;cdecl; external Sqlite3Lib name 'sqlite3_open'; +function sqlite3_open16(filename:pointer; ppDb:PPsqlite3):longint;cdecl; external Sqlite3Lib name 'sqlite3_open16'; +function sqlite3_errcode(db:Psqlite3):longint;cdecl; external Sqlite3Lib name 'sqlite3_errcode'; +function sqlite3_errmsg(_para1:Psqlite3):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_errmsg'; +function sqlite3_errmsg16(_para1:Psqlite3):pointer;cdecl; external Sqlite3Lib name 'sqlite3_errmsg16'; +function sqlite3_prepare(db:Psqlite3; zSql:Pchar; nBytes:longint; ppStmt:PPsqlite3_stmt; pzTail:PPchar):longint;cdecl; external Sqlite3Lib name 'sqlite3_prepare'; +function sqlite3_prepare16(db:Psqlite3; zSql:pointer; nBytes:longint; ppStmt:PPsqlite3_stmt; pzTail:Ppointer):longint;cdecl; external Sqlite3Lib name 'sqlite3_prepare16'; +function sqlite3_bind_blob(_para1:Psqlite3_stmt; _para2:longint; _para3:pointer; n:longint; _para5:bind_destructor_func):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_blob'; +function sqlite3_bind_double(_para1:Psqlite3_stmt; _para2:longint; _para3:double):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_double'; +function sqlite3_bind_int(_para1:Psqlite3_stmt; _para2:longint; _para3:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_int'; +function sqlite3_bind_int64(_para1:Psqlite3_stmt; _para2:longint; _para3:sqlite_int64):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_int64'; +function sqlite3_bind_null(_para1:Psqlite3_stmt; _para2:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_null'; +function sqlite3_bind_text(_para1:Psqlite3_stmt; _para2:longint; _para3:Pchar; n:longint; _para5:bind_destructor_func):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_text'; +function sqlite3_bind_text16(_para1:Psqlite3_stmt; _para2:longint; _para3:pointer; _para4:longint; _para5:bind_destructor_func):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_text16'; +//function sqlite3_bind_value(_para1:Psqlite3_stmt; _para2:longint; _para3:Psqlite3_value):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_value'; +//These overloaded functions were introduced to allow the use of SQLITE_STATIC and SQLITE_TRANSIENT +//It's the c world man ;-) +function sqlite3_bind_blob(_para1:Psqlite3_stmt; _para2:longint; _para3:pointer; n:longint; _para5:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_blob'; +function sqlite3_bind_text(_para1:Psqlite3_stmt; _para2:longint; _para3:Pchar; n:longint; _para5:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_text'; +function sqlite3_bind_text16(_para1:Psqlite3_stmt; _para2:longint; _para3:pointer; _para4:longint; _para5:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_text16'; + +function sqlite3_bind_parameter_count(_para1:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_parameter_count'; +function sqlite3_bind_parameter_name(_para1:Psqlite3_stmt; _para2:longint):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_bind_parameter_name'; +function sqlite3_bind_parameter_index(_para1:Psqlite3_stmt; zName:Pchar):longint;cdecl; external Sqlite3Lib name 'sqlite3_bind_parameter_index'; +//function sqlite3_clear_bindings(_para1:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_clear_bindings'; +function sqlite3_column_count(pStmt:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_column_count'; +function sqlite3_column_name(_para1:Psqlite3_stmt; _para2:longint):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_column_name'; +function sqlite3_column_name16(_para1:Psqlite3_stmt; _para2:longint):pointer;cdecl; external Sqlite3Lib name 'sqlite3_column_name16'; +function sqlite3_column_decltype(_para1:Psqlite3_stmt; i:longint):Pchar;cdecl; external Sqlite3Lib name 'sqlite3_column_decltype'; +function sqlite3_column_decltype16(_para1:Psqlite3_stmt; _para2:longint):pointer;cdecl; external Sqlite3Lib name 'sqlite3_column_decltype16'; +function sqlite3_step(_para1:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_step'; +function sqlite3_data_count(pStmt:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_data_count'; +function sqlite3_column_blob(_para1:Psqlite3_stmt; iCol:longint):pointer;cdecl; external Sqlite3Lib name 'sqlite3_column_blob'; +function sqlite3_column_bytes(_para1:Psqlite3_stmt; iCol:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_column_bytes'; +function sqlite3_column_bytes16(_para1:Psqlite3_stmt; iCol:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_column_bytes16'; +function sqlite3_column_double(_para1:Psqlite3_stmt; iCol:longint):double;cdecl; external Sqlite3Lib name 'sqlite3_column_double'; +function sqlite3_column_int(_para1:Psqlite3_stmt; iCol:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_column_int'; +function sqlite3_column_int64(_para1:Psqlite3_stmt; iCol:longint):sqlite_int64;cdecl; external Sqlite3Lib name 'sqlite3_column_int64'; +function sqlite3_column_text(_para1:Psqlite3_stmt; iCol:longint):PChar;cdecl; external Sqlite3Lib name 'sqlite3_column_text'; +function sqlite3_column_text16(_para1:Psqlite3_stmt; iCol:longint):pointer;cdecl; external Sqlite3Lib name 'sqlite3_column_text16'; +function sqlite3_column_type(_para1:Psqlite3_stmt; iCol:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_column_type'; +function sqlite3_finalize(pStmt:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_finalize'; +function sqlite3_reset(pStmt:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_reset'; +function sqlite3_create_function(_para1:Psqlite3; zFunctionName:Pchar; nArg:longint; eTextRep:longint; _para5:pointer; xFunc:create_function_func_func; xStep:create_function_step_func; xFinal:create_function_final_func):longint;cdecl; external Sqlite3Lib name 'sqlite3_create_function'; +function sqlite3_create_function16(_para1:Psqlite3; zFunctionName:pointer; nArg:longint; eTextRep:longint; _para5:pointer; xFunc:create_function_func_func; xStep:create_function_step_func; xFinal:create_function_final_func):longint;cdecl; external Sqlite3Lib name 'sqlite3_create_function16'; +function sqlite3_aggregate_count(_para1:Psqlite3_context):longint;cdecl; external Sqlite3Lib name 'sqlite3_aggregate_count'; +function sqlite3_value_blob(_para1:Psqlite3_value):pointer;cdecl; external Sqlite3Lib name 'sqlite3_value_blob'; +function sqlite3_value_bytes(_para1:Psqlite3_value):longint;cdecl; external Sqlite3Lib name 'sqlite3_value_bytes'; +function sqlite3_value_bytes16(_para1:Psqlite3_value):longint;cdecl; external Sqlite3Lib name 'sqlite3_value_bytes16'; +function sqlite3_value_double(_para1:Psqlite3_value):double;cdecl; external Sqlite3Lib name 'sqlite3_value_double'; +function sqlite3_value_int(_para1:Psqlite3_value):longint;cdecl; external Sqlite3Lib name 'sqlite3_value_int'; +function sqlite3_value_int64(_para1:Psqlite3_value):sqlite_int64;cdecl; external Sqlite3Lib name 'sqlite3_value_int64'; +function sqlite3_value_text(_para1:Psqlite3_value):PChar;cdecl; external Sqlite3Lib name 'sqlite3_value_text'; +function sqlite3_value_text16(_para1:Psqlite3_value):pointer;cdecl; external Sqlite3Lib name 'sqlite3_value_text16'; +function sqlite3_value_text16le(_para1:Psqlite3_value):pointer;cdecl; external Sqlite3Lib name 'sqlite3_value_text16le'; +function sqlite3_value_text16be(_para1:Psqlite3_value):pointer;cdecl; external Sqlite3Lib name 'sqlite3_value_text16be'; +function sqlite3_value_type(_para1:Psqlite3_value):longint;cdecl; external Sqlite3Lib name 'sqlite3_value_type'; +function sqlite3_aggregate_context(_para1:Psqlite3_context; nBytes:longint):pointer;cdecl; external Sqlite3Lib name 'sqlite3_aggregate_context'; +function sqlite3_user_data(_para1:Psqlite3_context):pointer;cdecl; external Sqlite3Lib name 'sqlite3_user_data'; +function sqlite3_get_auxdata(_para1:Psqlite3_context; _para2:longint):pointer;cdecl; external Sqlite3Lib name 'sqlite3_get_auxdata'; +procedure sqlite3_set_auxdata(_para1:Psqlite3_context; _para2:longint; _para3:pointer; _para4:sqlite3_set_auxdata_func);cdecl; external Sqlite3Lib name 'sqlite3_set_auxdata'; +procedure sqlite3_result_blob(_para1:Psqlite3_context; _para2:pointer; _para3:longint; _para4:sqlite3_result_func);cdecl; external Sqlite3Lib name 'sqlite3_result_blob'; +procedure sqlite3_result_double(_para1:Psqlite3_context; _para2:double);cdecl; external Sqlite3Lib name 'sqlite3_result_double'; +procedure sqlite3_result_error(_para1:Psqlite3_context; _para2:Pchar; _para3:longint);cdecl; external Sqlite3Lib name 'sqlite3_result_error'; +procedure sqlite3_result_error16(_para1:Psqlite3_context; _para2:pointer; _para3:longint);cdecl; external Sqlite3Lib name 'sqlite3_result_error16'; +procedure sqlite3_result_int(_para1:Psqlite3_context; _para2:longint);cdecl; external Sqlite3Lib name 'sqlite3_result_int'; +procedure sqlite3_result_int64(_para1:Psqlite3_context; _para2:sqlite_int64);cdecl; external Sqlite3Lib name 'sqlite3_result_int64'; +procedure sqlite3_result_null(_para1:Psqlite3_context);cdecl; external Sqlite3Lib name 'sqlite3_result_null'; +procedure sqlite3_result_text(_para1:Psqlite3_context; _para2:Pchar; _para3:longint; _para4:sqlite3_result_func);cdecl; external Sqlite3Lib name 'sqlite3_result_text'; +procedure sqlite3_result_text16(_para1:Psqlite3_context; _para2:pointer; _para3:longint; _para4:sqlite3_result_func);cdecl; external Sqlite3Lib name 'sqlite3_result_text16'; +procedure sqlite3_result_text16le(_para1:Psqlite3_context; _para2:pointer; _para3:longint; _para4:sqlite3_result_func);cdecl; external Sqlite3Lib name 'sqlite3_result_text16le'; +procedure sqlite3_result_text16be(_para1:Psqlite3_context; _para2:pointer; _para3:longint; _para4:sqlite3_result_func);cdecl; external Sqlite3Lib name 'sqlite3_result_text16be'; +procedure sqlite3_result_value(_para1:Psqlite3_context; _para2:Psqlite3_value);cdecl; external Sqlite3Lib name 'sqlite3_result_value'; +function sqlite3_create_collation(_para1:Psqlite3; zName:Pchar; eTextRep:longint; _para4:pointer; xCompare:sqlite3_create_collation_func):longint;cdecl; external Sqlite3Lib name 'sqlite3_create_collation'; +function sqlite3_create_collation16(_para1:Psqlite3; zName:Pchar; eTextRep:longint; _para4:pointer; xCompare:sqlite3_create_collation_func):longint;cdecl; external Sqlite3Lib name 'sqlite3_create_collation16'; +function sqlite3_collation_needed(_para1:Psqlite3; _para2:pointer; _para3:sqlite3_collation_needed_func):longint;cdecl; external Sqlite3Lib name 'sqlite3_collation_needed'; +function sqlite3_collation_needed16(_para1:Psqlite3; _para2:pointer; _para3:sqlite3_collation_needed_func):longint;cdecl; external Sqlite3Lib name 'sqlite3_collation_needed16'; +function sqlite3_libversion:PChar;cdecl; external Sqlite3Lib name 'sqlite3_libversion'; +//Alias for allowing better code portability (win32 is not working with external variables) +function sqlite3_version:PChar;cdecl; external Sqlite3Lib name 'sqlite3_libversion'; + +// Not published functions +function sqlite3_libversion_number:longint;cdecl; external Sqlite3Lib name 'sqlite3_libversion_number'; +//function sqlite3_key(db:Psqlite3; pKey:pointer; nKey:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_key'; +//function sqlite3_rekey(db:Psqlite3; pKey:pointer; nKey:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_rekey'; +//function sqlite3_sleep(_para1:longint):longint;cdecl; external Sqlite3Lib name 'sqlite3_sleep'; +//function sqlite3_expired(_para1:Psqlite3_stmt):longint;cdecl; external Sqlite3Lib name 'sqlite3_expired'; +//function sqlite3_global_recover:longint;cdecl; external Sqlite3Lib name 'sqlite3_global_recover'; + +{$ELSE LOAD_DYNAMICALLY} + +Var + sqlite3_close : function (_para1:Psqlite3):longint;cdecl; + sqlite3_exec : function (_para1:Psqlite3; sql:Pchar; _para3:sqlite3_callback; _para4:pointer; errmsg:PPchar):longint;cdecl; + sqlite3_last_insert_rowid : function (_para1:Psqlite3):sqlite_int64;cdecl; + sqlite3_changes : function (_para1:Psqlite3):longint;cdecl; + sqlite3_total_changes : function (_para1:Psqlite3):longint;cdecl; + sqlite3_interrupt : procedure (_para1:Psqlite3);cdecl; + sqlite3_complete : function (sql:Pchar):longint;cdecl; + sqlite3_complete16 : function (sql:pointer):longint;cdecl; + sqlite3_busy_handler : function (_para1:Psqlite3; _para2:busy_handler_func; _para3:pointer):longint;cdecl; + sqlite3_busy_timeout : function (_para1:Psqlite3; ms:longint):longint;cdecl; + sqlite3_get_table : function (_para1:Psqlite3; sql:Pchar; resultp:PPPchar; nrow:Plongint; ncolumn:Plongint; errmsg:PPchar):longint;cdecl; + sqlite3_free_table : procedure (result:PPchar);cdecl; +// Todo: see how translate sqlite3_mprintf, sqlite3_vmprintf, sqlite3_snprintf +// sqlite3_mprintf : function (_para1:Pchar; args:array of const):Pchar;cdecl; + sqlite3_mprintf : function (_para1:Pchar):Pchar;cdecl; +// sqlite3_vmprintf : function (_para1:Pchar; _para2:va_list):Pchar;cdecl; + sqlite3_free : procedure (z:Pchar);cdecl; +// sqlite3_snprintf : function (_para1:longint; _para2:Pchar; _para3:Pchar; args:array of const):Pchar;cdecl; + sqlite3_snprintf : function (_para1:longint; _para2:Pchar; _para3:Pchar):Pchar;cdecl; + sqlite3_set_authorizer : function (_para1:Psqlite3; xAuth:sqlite3_set_authorizer_func; pUserData:pointer):longint;cdecl; + sqlite3_trace : function (_para1:Psqlite3; xTrace:sqlite3_trace_func; _para3:pointer):pointer;cdecl; + sqlite3_progress_handler : procedure (_para1:Psqlite3; _para2:longint; _para3:sqlite3_progress_handler_func; _para4:pointer);cdecl; + sqlite3_commit_hook : function (_para1:Psqlite3; _para2:sqlite3_commit_hook_func; _para3:pointer):pointer;cdecl; + sqlite3_open : function (filename:Pchar; ppDb:PPsqlite3):longint;cdecl; + sqlite3_open16 : function (filename:pointer; ppDb:PPsqlite3):longint;cdecl; + sqlite3_errcode : function (db:Psqlite3):longint;cdecl; + sqlite3_errmsg : function (_para1:Psqlite3):Pchar;cdecl; + sqlite3_errmsg16 : function (_para1:Psqlite3):pointer;cdecl; + sqlite3_prepare : function (db:Psqlite3; zSql:Pchar; nBytes:longint; ppStmt:PPsqlite3_stmt; pzTail:PPchar):longint;cdecl; + sqlite3_prepare16 : function (db:Psqlite3; zSql:pointer; nBytes:longint; ppStmt:PPsqlite3_stmt; pzTail:Ppointer):longint;cdecl; + sqlite3_bind_blob : function (_para1:Psqlite3_stmt; _para2:longint; _para3:pointer; n:longint; _para5:bind_destructor_func):longint;cdecl; + sqlite3_bind_double : function (_para1:Psqlite3_stmt; _para2:longint; _para3:double):longint;cdecl; + sqlite3_bind_int : function (_para1:Psqlite3_stmt; _para2:longint; _para3:longint):longint;cdecl; + sqlite3_bind_int64 : function (_para1:Psqlite3_stmt; _para2:longint; _para3:sqlite_int64):longint;cdecl; + sqlite3_bind_null : function (_para1:Psqlite3_stmt; _para2:longint):longint;cdecl; + sqlite3_bind_text : function (_para1:Psqlite3_stmt; _para2:longint; _para3:Pchar; n:longint; _para5:bind_destructor_func):longint;cdecl; + sqlite3_bind_text16 : function (_para1:Psqlite3_stmt; _para2:longint; _para3:pointer; _para4:longint; _para5:bind_destructor_func):longint;cdecl; +// sqlite3_bind_value : function (_para1:Psqlite3_stmt; _para2:longint; _para3:Psqlite3_value):longint;cdecl; +//These overloaded functions were introduced to allow the use of SQLITE_STATIC and SQLITE_TRANSIENT +//It's the c world man ;-) + sqlite3_bind_blob1 : function (_para1:Psqlite3_stmt; _para2:longint; _para3:pointer; n:longint; _para5:longint):longint;cdecl; + sqlite3_bind_text1 : function (_para1:Psqlite3_stmt; _para2:longint; _para3:Pchar; n:longint; _para5:longint):longint;cdecl; + sqlite3_bind_text161 : function (_para1:Psqlite3_stmt; _para2:longint; _para3:pointer; _para4:longint; _para5:longint):longint;cdecl; + + sqlite3_bind_parameter_count : function (_para1:Psqlite3_stmt):longint;cdecl; + sqlite3_bind_parameter_name : function (_para1:Psqlite3_stmt; _para2:longint):Pchar;cdecl; + sqlite3_bind_parameter_index : function (_para1:Psqlite3_stmt; zName:Pchar):longint;cdecl; +// sqlite3_clear_bindings : function (_para1:Psqlite3_stmt):longint;cdecl; + sqlite3_column_count : function (pStmt:Psqlite3_stmt):longint;cdecl; + sqlite3_column_name : function (_para1:Psqlite3_stmt; _para2:longint):Pchar;cdecl; + sqlite3_column_name16 : function (_para1:Psqlite3_stmt; _para2:longint):pointer;cdecl; + sqlite3_column_decltype : function (_para1:Psqlite3_stmt; i:longint):Pchar;cdecl; + sqlite3_column_decltype16 : function (_para1:Psqlite3_stmt; _para2:longint):pointer;cdecl; + sqlite3_step : function (_para1:Psqlite3_stmt):longint;cdecl; + sqlite3_data_count : function (pStmt:Psqlite3_stmt):longint;cdecl; + sqlite3_column_blob : function (_para1:Psqlite3_stmt; iCol:longint):pointer;cdecl; + sqlite3_column_bytes : function (_para1:Psqlite3_stmt; iCol:longint):longint;cdecl; + sqlite3_column_bytes16 : function (_para1:Psqlite3_stmt; iCol:longint):longint;cdecl; + sqlite3_column_double : function (_para1:Psqlite3_stmt; iCol:longint):double;cdecl; + sqlite3_column_int : function (_para1:Psqlite3_stmt; iCol:longint):longint;cdecl; + sqlite3_column_int64 : function (_para1:Psqlite3_stmt; iCol:longint):sqlite_int64;cdecl; + sqlite3_column_text : function (_para1:Psqlite3_stmt; iCol:longint):PChar;cdecl; + sqlite3_column_text16 : function (_para1:Psqlite3_stmt; iCol:longint):pointer;cdecl; + sqlite3_column_type : function (_para1:Psqlite3_stmt; iCol:longint):longint;cdecl; + sqlite3_finalize : function (pStmt:Psqlite3_stmt):longint;cdecl; + sqlite3_reset : function (pStmt:Psqlite3_stmt):longint;cdecl; + sqlite3_create_function : function (_para1:Psqlite3; zFunctionName:Pchar; nArg:longint; eTextRep:longint; _para5:pointer; xFunc:create_function_func_func; xStep:create_function_step_func; xFinal:create_function_final_func):longint;cdecl; + sqlite3_create_function16 : function (_para1:Psqlite3; zFunctionName:pointer; nArg:longint; eTextRep:longint; _para5:pointer; xFunc:create_function_func_func; xStep:create_function_step_func; xFinal:create_function_final_func):longint;cdecl; + sqlite3_aggregate_count : function (_para1:Psqlite3_context):longint;cdecl; + sqlite3_value_blob : function (_para1:Psqlite3_value):pointer;cdecl; + sqlite3_value_bytes : function (_para1:Psqlite3_value):longint;cdecl; + sqlite3_value_bytes16 : function (_para1:Psqlite3_value):longint;cdecl; + sqlite3_value_double : function (_para1:Psqlite3_value):double;cdecl; + sqlite3_value_int : function (_para1:Psqlite3_value):longint;cdecl; + sqlite3_value_int64 : function (_para1:Psqlite3_value):sqlite_int64;cdecl; + sqlite3_value_text : function (_para1:Psqlite3_value):PChar;cdecl; + sqlite3_value_text16 : function (_para1:Psqlite3_value):pointer;cdecl; + sqlite3_value_text16le : function (_para1:Psqlite3_value):pointer;cdecl; + sqlite3_value_text16be : function (_para1:Psqlite3_value):pointer;cdecl; + sqlite3_value_type : function (_para1:Psqlite3_value):longint;cdecl; + sqlite3_aggregate_context : function (_para1:Psqlite3_context; nBytes:longint):pointer;cdecl; + sqlite3_user_data : function (_para1:Psqlite3_context):pointer;cdecl; + sqlite3_get_auxdata : function (_para1:Psqlite3_context; _para2:longint):pointer;cdecl; + sqlite3_set_auxdata : procedure (_para1:Psqlite3_context; _para2:longint; _para3:pointer; _para4:sqlite3_set_auxdata_func);cdecl; + sqlite3_result_blob : procedure (_para1:Psqlite3_context; _para2:pointer; _para3:longint; _para4:sqlite3_result_func);cdecl; + sqlite3_result_double : procedure (_para1:Psqlite3_context; _para2:double);cdecl; + sqlite3_result_error : procedure (_para1:Psqlite3_context; _para2:Pchar; _para3:longint);cdecl; + sqlite3_result_error16 : procedure (_para1:Psqlite3_context; _para2:pointer; _para3:longint);cdecl; + sqlite3_result_int : procedure (_para1:Psqlite3_context; _para2:longint);cdecl; + sqlite3_result_int64 : procedure (_para1:Psqlite3_context; _para2:sqlite_int64);cdecl; + sqlite3_result_null : procedure (_para1:Psqlite3_context);cdecl; + sqlite3_result_text : procedure (_para1:Psqlite3_context; _para2:Pchar; _para3:longint; _para4:sqlite3_result_func);cdecl; + sqlite3_result_text16 : procedure (_para1:Psqlite3_context; _para2:pointer; _para3:longint; _para4:sqlite3_result_func);cdecl; + sqlite3_result_text16le : procedure (_para1:Psqlite3_context; _para2:pointer; _para3:longint; _para4:sqlite3_result_func);cdecl; + sqlite3_result_text16be : procedure (_para1:Psqlite3_context; _para2:pointer; _para3:longint; _para4:sqlite3_result_func);cdecl; + sqlite3_result_value : procedure (_para1:Psqlite3_context; _para2:Psqlite3_value);cdecl; + sqlite3_create_collation : function (_para1:Psqlite3; zName:Pchar; eTextRep:longint; _para4:pointer; xCompare:sqlite3_create_collation_func):longint;cdecl; + sqlite3_create_collation16 : function (_para1:Psqlite3; zName:Pchar; eTextRep:longint; _para4:pointer; xCompare:sqlite3_create_collation_func):longint;cdecl; + sqlite3_collation_needed : function (_para1:Psqlite3; _para2:pointer; _para3:sqlite3_collation_needed_func):longint;cdecl; + sqlite3_collation_needed16 : function (_para1:Psqlite3; _para2:pointer; _para3:sqlite3_collation_needed_func):longint;cdecl; + sqlite3_libversion: function : PChar;cdecl; +//Alias for allowing better code portability (win32 is not working with external variables) + sqlite3_version: function: PChar;cdecl; + +// Not published functions + sqlite3_libversion_number : Function :longint;cdecl; +// sqlite3_key : function (db:Psqlite3; pKey:pointer; nKey:longint):longint;cdecl; +// sqlite3_rekey : function (db:Psqlite3; pKey:pointer; nKey:longint):longint;cdecl; +// sqlite3_sleep : function (_para1:longint):longint;cdecl; +// sqlite3_expired : function (_para1:Psqlite3_stmt):longint;cdecl; +//function sqlite3_global_recover:longint;cdecl; + +Procedure InitialiseSQLite; +Procedure InitialiseSQLite(LibraryName : String); +Procedure ReleaseSQLite; + +var + SQLiteLibraryHandle : TLibHandle; + DefaultLibrary : String = Sqlite3Lib; + +{$ENDIF LOAD_DYNAMICALLY} + +implementation + +{$IFDEF LOAD_DYNAMICALLY} + +ResourceString + SErrLoadFailed = 'Can not load SQLite client library "%s". Check your installation.'; + SErrAlreadyLoaded = 'SQLIte interface already initialized from library %s.'; + +Procedure LoadAddresses(LibHandle : TLibHandle); + +begin + pointer(sqlite3_close) := GetProcedureAddress(LibHandle,'sqlite3_close'); + pointer(sqlite3_exec) := GetProcedureAddress(LibHandle,'sqlite3_exec'); + pointer(sqlite3_last_insert_rowid) := GetProcedureAddress(LibHandle,'sqlite3_last_insert_rowid'); + pointer(sqlite3_changes) := GetProcedureAddress(LibHandle,'sqlite3_changes'); + pointer(sqlite3_total_changes) := GetProcedureAddress(LibHandle,'sqlite3_total_changes'); + pointer(sqlite3_interrupt) := GetProcedureAddress(LibHandle,'sqlite3_interrupt'); + pointer(sqlite3_complete) := GetProcedureAddress(LibHandle,'sqlite3_complete'); + pointer(sqlite3_complete16) := GetProcedureAddress(LibHandle,'sqlite3_complete16'); + pointer(sqlite3_busy_handler) := GetProcedureAddress(LibHandle,'sqlite3_busy_handler'); + pointer(sqlite3_busy_timeout) := GetProcedureAddress(LibHandle,'sqlite3_busy_timeout'); + pointer(sqlite3_get_table) := GetProcedureAddress(LibHandle,'sqlite3_get_table'); + pointer(sqlite3_free_table) := GetProcedureAddress(LibHandle,'sqlite3_free_table'); +// Todo: see how translate sqlite3_mprintf, sqlite3_vmprintf, sqlite3_snprintf +// pointer(sqlite3_mprintf) := GetProcedureAddress(LibHandle,'sqlite3_mprintf'); + pointer(sqlite3_mprintf) := GetProcedureAddress(LibHandle,'sqlite3_mprintf'); +// pointer(sqlite3_vmprintf) := GetProcedureAddress(LibHandle,'sqlite3_vmprintf'); + pointer(sqlite3_free) := GetProcedureAddress(LibHandle,'sqlite3_free'); +// pointer(sqlite3_snprintf) := GetProcedureAddress(LibHandle,'sqlite3_snprintf'); + pointer(sqlite3_snprintf) := GetProcedureAddress(LibHandle,'sqlite3_snprintf'); + pointer(sqlite3_set_authorizer) := GetProcedureAddress(LibHandle,'sqlite3_set_authorizer'); + pointer(sqlite3_trace) := GetProcedureAddress(LibHandle,'sqlite3_trace'); + pointer(sqlite3_progress_handler) := GetProcedureAddress(LibHandle,'sqlite3_progress_handler'); + pointer(sqlite3_commit_hook) := GetProcedureAddress(LibHandle,'sqlite3_commit_hook'); + pointer(sqlite3_open) := GetProcedureAddress(LibHandle,'sqlite3_open'); + pointer(sqlite3_open16) := GetProcedureAddress(LibHandle,'sqlite3_open16'); + pointer(sqlite3_errcode) := GetProcedureAddress(LibHandle,'sqlite3_errcode'); + pointer(sqlite3_errmsg) := GetProcedureAddress(LibHandle,'sqlite3_errmsg'); + pointer(sqlite3_errmsg16) := GetProcedureAddress(LibHandle,'sqlite3_errmsg16'); + pointer(sqlite3_prepare) := GetProcedureAddress(LibHandle,'sqlite3_prepare'); + pointer(sqlite3_prepare16) := GetProcedureAddress(LibHandle,'sqlite3_prepare16'); + pointer(sqlite3_bind_blob) := GetProcedureAddress(LibHandle,'sqlite3_bind_blob'); + pointer(sqlite3_bind_double) := GetProcedureAddress(LibHandle,'sqlite3_bind_double'); + pointer(sqlite3_bind_int) := GetProcedureAddress(LibHandle,'sqlite3_bind_int'); + pointer(sqlite3_bind_int64) := GetProcedureAddress(LibHandle,'sqlite3_bind_int64'); + pointer(sqlite3_bind_null) := GetProcedureAddress(LibHandle,'sqlite3_bind_null'); + pointer(sqlite3_bind_text) := GetProcedureAddress(LibHandle,'sqlite3_bind_text'); + pointer(sqlite3_bind_text16) := GetProcedureAddress(LibHandle,'sqlite3_bind_text16'); +// pointer(sqlite3_bind_value) := GetProcedureAddress(LibHandle,'sqlite3_bind_value'); +//These overloaded functions were introduced to allow the use of SQLITE_STATIC and SQLITE_TRANSIENT +//It's the c world man ;-) + pointer(sqlite3_bind_blob1) := GetProcedureAddress(LibHandle,'sqlite3_bind_blob'); + pointer(sqlite3_bind_text1) := GetProcedureAddress(LibHandle,'sqlite3_bind_text'); + pointer(sqlite3_bind_text161) := GetProcedureAddress(LibHandle,'sqlite3_bind_text16'); + + pointer(sqlite3_bind_parameter_count) := GetProcedureAddress(LibHandle,'sqlite3_bind_parameter_count'); + pointer(sqlite3_bind_parameter_name) := GetProcedureAddress(LibHandle,'sqlite3_bind_parameter_name'); + pointer(sqlite3_bind_parameter_index) := GetProcedureAddress(LibHandle,'sqlite3_bind_parameter_index'); +// pointer(sqlite3_clear_bindings) := GetProcedureAddress(LibHandle,'sqlite3_clear_bindings'); + pointer(sqlite3_column_count) := GetProcedureAddress(LibHandle,'sqlite3_column_count'); + pointer(sqlite3_column_name) := GetProcedureAddress(LibHandle,'sqlite3_column_name'); + pointer(sqlite3_column_name16) := GetProcedureAddress(LibHandle,'sqlite3_column_name16'); + pointer(sqlite3_column_decltype) := GetProcedureAddress(LibHandle,'sqlite3_column_decltype'); + pointer(sqlite3_column_decltype16) := GetProcedureAddress(LibHandle,'sqlite3_column_decltype16'); + pointer(sqlite3_step) := GetProcedureAddress(LibHandle,'sqlite3_step'); + pointer(sqlite3_data_count) := GetProcedureAddress(LibHandle,'sqlite3_data_count'); + pointer(sqlite3_column_blob) := GetProcedureAddress(LibHandle,'sqlite3_column_blob'); + pointer(sqlite3_column_bytes) := GetProcedureAddress(LibHandle,'sqlite3_column_bytes'); + pointer(sqlite3_column_bytes16) := GetProcedureAddress(LibHandle,'sqlite3_column_bytes16'); + pointer(sqlite3_column_double) := GetProcedureAddress(LibHandle,'sqlite3_column_double'); + pointer(sqlite3_column_int) := GetProcedureAddress(LibHandle,'sqlite3_column_int'); + pointer(sqlite3_column_int64) := GetProcedureAddress(LibHandle,'sqlite3_column_int64'); + pointer(sqlite3_column_text) := GetProcedureAddress(LibHandle,'sqlite3_column_text'); + pointer(sqlite3_column_text16) := GetProcedureAddress(LibHandle,'sqlite3_column_text16'); + pointer(sqlite3_column_type) := GetProcedureAddress(LibHandle,'sqlite3_column_type'); + pointer(sqlite3_finalize) := GetProcedureAddress(LibHandle,'sqlite3_finalize'); + pointer(sqlite3_reset) := GetProcedureAddress(LibHandle,'sqlite3_reset'); + pointer(sqlite3_create_function) := GetProcedureAddress(LibHandle,'sqlite3_create_function'); + pointer(sqlite3_create_function16) := GetProcedureAddress(LibHandle,'sqlite3_create_function16'); + pointer(sqlite3_aggregate_count) := GetProcedureAddress(LibHandle,'sqlite3_aggregate_count'); + pointer(sqlite3_value_blob) := GetProcedureAddress(LibHandle,'sqlite3_value_blob'); + pointer(sqlite3_value_bytes) := GetProcedureAddress(LibHandle,'sqlite3_value_bytes'); + pointer(sqlite3_value_bytes16) := GetProcedureAddress(LibHandle,'sqlite3_value_bytes16'); + pointer(sqlite3_value_double) := GetProcedureAddress(LibHandle,'sqlite3_value_double'); + pointer(sqlite3_value_int) := GetProcedureAddress(LibHandle,'sqlite3_value_int'); + pointer(sqlite3_value_int64) := GetProcedureAddress(LibHandle,'sqlite3_value_int64'); + pointer(sqlite3_value_text) := GetProcedureAddress(LibHandle,'sqlite3_value_text'); + pointer(sqlite3_value_text16) := GetProcedureAddress(LibHandle,'sqlite3_value_text16'); + pointer(sqlite3_value_text16le) := GetProcedureAddress(LibHandle,'sqlite3_value_text16le'); + pointer(sqlite3_value_text16be) := GetProcedureAddress(LibHandle,'sqlite3_value_text16be'); + pointer(sqlite3_value_type) := GetProcedureAddress(LibHandle,'sqlite3_value_type'); + pointer(sqlite3_aggregate_context) := GetProcedureAddress(LibHandle,'sqlite3_aggregate_context'); + pointer(sqlite3_user_data) := GetProcedureAddress(LibHandle,'sqlite3_user_data'); + pointer(sqlite3_get_auxdata) := GetProcedureAddress(LibHandle,'sqlite3_get_auxdata'); + pointer(sqlite3_set_auxdata) := GetProcedureAddress(LibHandle,'sqlite3_set_auxdata'); + pointer(sqlite3_result_blob) := GetProcedureAddress(LibHandle,'sqlite3_result_blob'); + pointer(sqlite3_result_double) := GetProcedureAddress(LibHandle,'sqlite3_result_double'); + pointer(sqlite3_result_error) := GetProcedureAddress(LibHandle,'sqlite3_result_error'); + pointer(sqlite3_result_error16) := GetProcedureAddress(LibHandle,'sqlite3_result_error16'); + pointer(sqlite3_result_int) := GetProcedureAddress(LibHandle,'sqlite3_result_int'); + pointer(sqlite3_result_int64) := GetProcedureAddress(LibHandle,'sqlite3_result_int64'); + pointer(sqlite3_result_null) := GetProcedureAddress(LibHandle,'sqlite3_result_null'); + pointer(sqlite3_result_text) := GetProcedureAddress(LibHandle,'sqlite3_result_text'); + pointer(sqlite3_result_text16) := GetProcedureAddress(LibHandle,'sqlite3_result_text16'); + pointer(sqlite3_result_text16le) := GetProcedureAddress(LibHandle,'sqlite3_result_text16le'); + pointer(sqlite3_result_text16be) := GetProcedureAddress(LibHandle,'sqlite3_result_text16be'); + pointer(sqlite3_result_value) := GetProcedureAddress(LibHandle,'sqlite3_result_value'); + pointer(sqlite3_create_collation) := GetProcedureAddress(LibHandle,'sqlite3_create_collation'); + pointer(sqlite3_create_collation16) := GetProcedureAddress(LibHandle,'sqlite3_create_collation16'); + pointer(sqlite3_collation_needed) := GetProcedureAddress(LibHandle,'sqlite3_collation_needed'); + pointer(sqlite3_collation_needed16) := GetProcedureAddress(LibHandle,'sqlite3_collation_needed16'); + pointer(sqlite3_libversion):=GetProcedureAddress(LibHandle,'sqlite3_libversion'); +//Alias for allowing better code portability (win32 is not working with external variables) + pointer(sqlite3_version):=GetProcedureAddress(LibHandle,'sqlite3_libversion'); + +// Not published functions + pointer(sqlite3_libversion_number):=GetProcedureAddress(LibHandle,'sqlite3_libversion_number'); +// pointer(sqlite3_key) := GetProcedureAddress(LibHandle,'sqlite3_key'); +// pointer(sqlite3_rekey) := GetProcedureAddress(LibHandle,'sqlite3_rekey'); +// pointer(sqlite3_sleep) := GetProcedureAddress(LibHandle,'sqlite3_sleep'); +// pointer(sqlite3_expired) := GetProcedureAddress(LibHandle,'sqlite3_expired'); +// function sqlite3_global_recover:longint;cdecl; +end; + +var + RefCount : integer; + LoadedLibrary : String; + + +Function TryInitialiseSqlite(Const LibraryName : String) : Boolean; + +begin + Result:=False; + if (RefCount=0) then + begin + SQLiteLibraryHandle:=LoadLibrary(LibraryName); + Result:=(SQLiteLibraryHandle<>nilhandle); + If not Result then + Exit; + inc(RefCount); + LoadedLibrary:=LibraryName; + LoadAddresses(SQLiteLibraryHandle); + end + else + begin + If (LoadedLibrary<>LibraryName) then + Raise EInoutError.CreateFmt(SErrAlreadyLoaded,[LoadedLibrary]); + inc(RefCount); + Result:=True; + end; +end; + +Procedure InitialiseSQLite; + +begin + InitialiseSQLite(DefaultLibrary); +end; + + +Procedure InitialiseSQLite(LibraryName : String); + +begin + If Not TryInitialiseSQLIte(LibraryName) then + Raise EInOutError.CreateFmt(SErrLoadFailed,[LibraryName]); +end; + +Procedure ReleaseSQLITE; + +begin + if RefCount>1 then + Dec(RefCount) + else if UnloadLibrary(SQLITELibraryHandle) then + begin + Dec(RefCount); + SQLITELibraryHandle := NilHandle; + LoadedLibrary:=''; + end; +end; + +{$ENDIF} + +end. diff --git a/packages/sqlite/src/sqlite3.pp b/packages/sqlite/src/sqlite3.pp new file mode 100644 index 0000000000..044542cf9e --- /dev/null +++ b/packages/sqlite/src/sqlite3.pp @@ -0,0 +1,5 @@ +unit sqlite3; + +{$i sqlite3.inc} + +end. \ No newline at end of file diff --git a/packages/sqlite/src/sqlite3db.pas b/packages/sqlite/src/sqlite3db.pas new file mode 100644 index 0000000000..a7625b00db --- /dev/null +++ b/packages/sqlite/src/sqlite3db.pas @@ -0,0 +1,494 @@ +{$mode objfpc} +{$h+} +{************************************************************* +SQLite3 Object Oriented handle +O. Rinaudo - 2005 - orinaudo@gmail.com +G. Marcou - 2007 - g.marcou@chimie.u-strasbg.fr +*************************************************************} + +unit SQLite3db; + +interface + +uses Classes,strings,sqlite3; +{*************************************************************} +{*************************************************************} +type + TSQLiteExecCallback = function(Sender: pointer; Columns: Integer; ColumnValues: ppchar; ColumnNames: ppchar): integer of object; cdecl; + TSQLiteBusyCallback = function(Sender: TObject; BusyCount: integer): longint of object; cdecl; + TOnData = Procedure(Sender: TObject; Columns: Integer; ColumnNames, ColumnValues: String) of object; + TOnBusy = Procedure(Sender: TObject; BusyCount: integer; var Cancel: Boolean) of object; + TOnQueryComplete = Procedure(Sender: TObject) of object; + + TSQLite = class(TObject) +{*************************************************************} +{*************************************************************} + private + fPSQlite: PPsqlite3; + fSQLite:Psqlite3; + fMsg: String; + fIsOpen: Boolean; + fBusy: Boolean; + fError: longint; + fVersion: String; + fEncoding: String; + fTable: TStrings; + fLstName: TStringList; + fLstVal: TStringList; + fOnData: TOnData; + fOnBusy: TOnBusy; + fOnQueryComplete: TOnQueryComplete; + fBusyTimeout: longint; + fPMsg: PChar; + fChangeCount: longint; + fNb_Champ : Integer; + fList_FieldName : TStringList; + fList_Field : TList; + procedure SetBusyTimeout(Timeout: integer); +{*************************************************************} +{*************************************************************} + public + constructor Create(DBFileName: String); + destructor Destroy; override; + function Query(Sql: String; Table: TStrings ): boolean; + function ErrorMessage(ErrNo: Integer): string; + function IsComplete(Sql: String): boolean; + function LastInsertRow: integer; + function Cancel: boolean; + function DatabaseDetails(Table: TStrings): boolean; + property LastErrorMessage: string read fMsg; + property LastError: longint read fError; + property Version: String read fVersion; + property Encoding: String read fEncoding; + property OnData: TOnData read fOnData write fOnData; + property OnBusy: TOnBusy read fOnBusy write fOnBusy; + property OnQueryComplete: TOnQueryComplete read fOnQueryComplete write fOnQueryComplete; + property BusyTimeout: longint read fBusyTimeout write SetBusyTimeout; + property ChangeCount: longint read fChangeCount; + property List_FieldName: TStringList read fList_FieldName write fList_FieldName; + property List_Field: TList read fList_Field write fList_Field; + property Nb_Champ: integer read fNb_Champ write fNb_Champ; + procedure SQLOnData(Sender: TObject; Columns: Integer; ColumnNames, ColumnValues: String); + + end; +function Pas2SQLStr(const PasString: string): string; +function SQL2PasStr(const SQLString: string): string; +function QuoteStr(const s: string; QuoteChar: Char ): string; +function UnQuoteStr(const s: string; QuoteChar: Char ): string; +procedure ValueList(const ColumnNames, ColumnValues: String; NameValuePairs: TStrings); +{*************************************************************} +{*************************************************************} +implementation +Const + DblQuote: Char = '"'; + SngQuote: Char = #39; + DblSngQuote: String = #39#39; + Crlf: String = #13#10; + Tab: Char = #9; +var + MsgNoError : String; +{*************************************************************} +{*************************************************************} +function QuoteStr(const s: string; QuoteChar: Char ): string; +{************************************************************* +SQlite3 enclosing string with quotes +G. Marcou +*************************************************************} +begin + Result := Concat(QuoteChar, s, QuoteChar); +end; +{*************************************************************} +function UnQuoteStr(const s: string; QuoteChar: Char ): string; +{************************************************************* +SQlite3 Remove enclosing quotes from string +G. Marcou +*************************************************************} +begin + Result := s; + if length(Result) > 1 then + begin + if Result[1] = QuoteChar then + Delete(Result, 1, 1); + if Result[Length(Result)] = QuoteChar then + Delete(Result, Length(Result), 1); + end; +end; +{*************************************************************} +function Pas2SQLStr(const PasString: string): string; +{************************************************************* +SQlite3 SQL string are use double quotes, Pascal string use +single quote. +G. Marcou +*************************************************************} +var + n : integer; +begin + Result := SQL2PasStr(PasString); + n := Length(Result); + while n > 0 do + begin + if Result[n] = SngQuote then + Insert(SngQuote, Result, n); + dec(n); + end; + Result := QuoteStr(Result,SngQuote); +end; +{*************************************************************} +function SQL2PasStr(const SQLString: string): string; +{************************************************************* +SQlite3 SQL string are use double quotes, Pascal string use +single quote. +G. Marcou +*************************************************************} +var + p : integer; +begin + Result := SQLString; + p := pos(DblSngQuote, Result); + while p > 0 do + begin + Delete(Result, p, 1); + p := pos(DblSngQuote, Result); + end; + Result := UnQuoteStr(Result,SngQuote); +end; +{*************************************************************} +procedure ValueList(const ColumnNames, ColumnValues : String; +NameValuePairs : TStrings); +{************************************************************* +SQlite3 build (name=value) pair list +G. Marcou +*************************************************************} +var + n : integer; + lstName, lstValue : TStringList; +begin + if NameValuePairs <> nil then + begin + lstName := TStringList.Create; + lstValue := TStringList.Create; + lstName.CommaText := ColumnNames; + lstValue.CommaText := ColumnValues; + NameValuePairs.Clear; + if lstName.Count = LstValue.Count then + if lstName.Count > 0 then + for n := 0 to lstName.Count - 1 do + NameValuePairs.Append(Concat(lstName.Strings[n], '=', lstValue.Strings[n])); + lstValue.Free; + lstName.Free; + end; +end; +{*************************************************************} +{function SystemErrorMsg(ErrNo: Integer ): String; +var + buf: PChar; + size: Integer; + MsgLen: Integer; +begin} +{ size := 256; + GetMem(buf, size); + If ErrNo = - 1 then + ErrNo := GetLastError; + MsgLen := FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, nil, ErrNo, 0, buf, size, nil); + if MsgLen = 0 then + Result := 'ERROR' + else + Result := buf;} +{end;} +{*************************************************************} +function BusyCallback(Sender : pointer; +BusyCount : integer): longint; cdecl; +{************************************************************* +SQlite3 busy callback +G. Marcou +*************************************************************} +var + bCancel: Boolean; +begin + Result := -1; + with TObject(Sender) as TSQLite do + begin + if Assigned(fOnBusy) then + begin + bCancel := False; + fOnBusy(Tobject(Sender), BusyCount, bCancel); + if bCancel then + Result := 0; + end; + end; +end; +{*************************************************************} +function ExecCallback(Sender : Pointer; +Columns : Integer; +ColumnValues : PPChar; +ColumnNames : PPchar): integer; cdecl; +{************************************************************* +SQlite3 Build table and data from callback +G. Marcou +*************************************************************} +var + PVal, PName : ^PChar; + n : integer; + sVal, sName : String; +begin + Result := 0; + with TObject(Sender) as TSQLite do + begin + if (Assigned(fOnData) or Assigned(fTable)) then + begin + fLstName.Clear; + fLstVal.Clear; + if Columns > 0 then + begin + PName := ColumnNames; + PVal := ColumnValues; + for n := 0 to Columns - 1 do + begin + fLstName.Append(PName^); + fLstVal.Append(PVal^); + inc(PName); + inc(PVal); + end; + end; + sVal := fLstVal.CommaText; + sName := fLstName.CommaText; + if Assigned(fOnData) then + fOnData(TObject(Sender), Columns, sName, sVal); + if Assigned(fTable) then + begin + if fTable.Count = 0 then + fTable.Append(sName); + fTable.Append(sVal); + end; + end; + end; +end; +{*************************************************************} +procedure TSQLite.SQLOnData(Sender : TObject; +Columns : Integer; +ColumnNames, ColumnValues : String); +{************************************************************* +SQlite3 Fill up field list names and field list values +G. Marcou +*************************************************************} +Var + InterS,val : String; + Field : TStringList; + {************************************************} + function Pos1(a: String ; s : char) : integer; + var i,j : Integer; + begin + j:=-1; + for i:=1 to length(a) Do + begin + if a[i] = s then + begin + j:=i; + break; + end; + end; + result:=j; + end; { Pos1 } + {*************************************************} +begin + If Nb_Champ = -1 Then + Begin {Put the fields name in List_FieldName} + Nb_Champ:=Columns; + InterS:=ColumnNames; + While (Pos1(InterS,',') > 0) do + begin + val:=copy(InterS,1,Pos1(InterS,',')-1); + InterS:=copy(InterS,Pos1(InterS,',')+1,length(InterS)); + List_FieldName.add(val); + end; + if length(InterS) > 0 then List_FieldName.add(InterS); + end; + {Put the list of TStringList of value} + Field :=TStringList.Create; + InterS:=ColumnValues; + While (Pos1(InterS,',') > 0) do + begin + val:=copy(InterS,1,Pos1(InterS,',')-1); + InterS:=copy(InterS,Pos1(InterS,',')+1,length(InterS)); + Field.add(val); + end; + if length(InterS) > 0 then Field.add(InterS); + List_Field.add(Field); +end; +{*************************************************************} +constructor TSQLite.Create(DBFileName: String); +{************************************************************* +SQlite3 constructor +G. Marcou +*************************************************************} +var + name : pchar; +begin + inherited Create; + List_FieldName := TStringList.Create; + List_Field := TList.Create; + fError := SQLITE_ERROR; + fIsOpen := False; + fLstName := TStringList.Create; + fLstVal := TStringList.Create; + fOnData := nil; + fOnBusy := nil; + fOnQueryComplete := nil; + fChangeCount := 0; + name:=StrAlloc (length(DBFileName)+1); + strpcopy(name,DBFileName); + OnData:=@SQLOnData; + writeln('Try to open'); + sqlite3_open(name,@fSQLite); + writeln('Open success'); + sqlite3_free(fPMsg); + writeln('Free memory'); + if fSQLite <> nil then + begin + //fVersion := String(SQLite_Version); + //fEncoding := SQLite_Encoding; + fIsOpen := True; + fError := SQLITE_OK; + end; + fMsg := sqlite3_errmsg(fSQLite); +end; +{*************************************************************} +destructor TSQLite.Destroy; +{************************************************************* +SQLite3 destructor +G. Marcou +*************************************************************} +begin + if fIsOpen then + fError:=sqlite3_close(fSQLite); + fIsOpen := False; + fLstName.Free; + fLstVal.Free; + fSQLite := nil; + fOnData := nil; + fOnBusy := nil; + fOnQueryComplete := nil; + fLstName := nil; + fLstVal := nil; + List_FieldName.destroy; + List_Field.destroy; + inherited Destroy; +end; +{*************************************************************} +function TSQLite.Query(Sql: String; Table: TStrings ): boolean; +{************************************************************* +SQLite3 query the database +G. Marcou +*************************************************************} +//var +// fPMsg: PChar; +//var Psql : pchar; +begin + fError := SQLITE_ERROR; + if fIsOpen then + begin + fPMsg := nil; + fBusy := True; + fTable := Table; + if fTable <> nil then + fTable.Clear; + List_FieldName.clear; + List_Field.clear; + Nb_Champ:=-1; + fError := sqlite3_exec(fSQLite, PChar(sql), @ExecCallback, Self, @fPMsg); + sqlite3_free(fPMsg); + fChangeCount := sqlite3_changes(fSQLite); + fTable := nil; + fBusy := False; + if Assigned(fOnQueryComplete) then + fOnQueryComplete(Self); + end; + fMsg := ErrorMessage(fError); + Result := (fError = SQLITE_OK); +end; +{*************************************************************} +function TSQLite.Cancel: boolean; +{************************************************************* +SQLite3 interrupt database +G. Marcou +*************************************************************} +begin + Result := False; + if fBusy and fIsOpen then + begin + sqlite3_interrupt(fSQLite); + fBusy := false; + Result := True; + end; +end; +{*************************************************************} +procedure TSQLite.SetBusyTimeout(Timeout: Integer); +{************************************************************* +SQLite3 busy timeout +G. Marcou +*************************************************************} +begin + fBusyTimeout := Timeout; + if fIsOpen then + begin + fError:=sqlite3_busy_timeout(fSQLite, fBusyTimeout); + if fBusyTimeout > 0 then + sqlite3_busy_handler(fSQLite, @BusyCallback, Self) + else + sqlite3_busy_handler(fSQLite, nil, nil); + end; +end; +{*************************************************************} +function TSQLite.LastInsertRow: longint; +{************************************************************* +SQLite3 Get ID of the last inserted row +G. Marcou +*************************************************************} +begin + if fIsOpen then + Result := sqlite3_last_insert_rowid(fSQLite) + else + Result := -1; +end; +{*************************************************************} +function TSQLite.ErrorMessage(ErrNo: Integer): string; +{************************************************************* +SQLite3 Return comprehensive error message +G. Marcou +*************************************************************} +begin + if ErrNo = 0 then + Result := MsgNoError + else + Result := sqlite3_errmsg(fSQLite); +end; +{*************************************************************} +function TSQLite.IsComplete(Sql: String): boolean; +{************************************************************* +SQLite3 Return true when complete +G. Marcou +*************************************************************} +var Psql : pchar; +begin + Psql:=StrAlloc (length(Sql)+1); + strpcopy(Psql,Sql); +// Writeln('Testing: ',psql); + Result := sqlite3_complete(Psql)<>0; + strdispose(Psql); +end; +{*************************************************************} +function TSQLite.DatabaseDetails(Table: TStrings): boolean; +{************************************************************* +SQLite3 Query the database +G. Marcou +*************************************************************} +begin + Result := Query('SELECT * FROM SQLITE_MASTER;', Table); +end; +{*************************************************************} +{*************************************************************} +initialization + +finalization + +end. diff --git a/packages/sqlite/src/sqlite3dyn.pp b/packages/sqlite/src/sqlite3dyn.pp new file mode 100644 index 0000000000..b720814741 --- /dev/null +++ b/packages/sqlite/src/sqlite3dyn.pp @@ -0,0 +1,7 @@ +unit sqlite3dyn; + +{$DEFINE LOAD_DYNAMICALLY} + +{$i sqlite3.inc} + +end. \ No newline at end of file diff --git a/packages/sqlite/src/sqlitedb.pas b/packages/sqlite/src/sqlitedb.pas new file mode 100644 index 0000000000..b07ae23950 --- /dev/null +++ b/packages/sqlite/src/sqlitedb.pas @@ -0,0 +1,410 @@ +{$mode objfpc} +{$h+} + +unit SQLitedb; + +interface + +uses Classes,strings,sqlite; + +type + TSQLiteExecCallback = function(Sender: pointer; Columns: Integer; ColumnValues: ppchar; ColumnNames: ppchar): integer of object; cdecl; + TSQLiteBusyCallback = function(Sender: TObject; ObjectName: PChar; BusyCount: integer): integer of object; cdecl; + TOnData = Procedure(Sender: TObject; Columns: Integer; ColumnNames, ColumnValues: String) of object; + TOnBusy = Procedure(Sender: TObject; ObjectName: String; BusyCount: integer; var Cancel: Boolean) of object; + TOnQueryComplete = Procedure(Sender: TObject) of object; + + TSQLite = class(TObject) + private + fSQLite: Pointer; + fMsg: String; + fIsOpen: Boolean; + fBusy: Boolean; + fError: Integer; + fVersion: String; + fEncoding: String; + fTable: TStrings; + fLstName: TStringList; + fLstVal: TStringList; + fOnData: TOnData; + fOnBusy: TOnBusy; + fOnQueryComplete: TOnQueryComplete; + fBusyTimeout: integer; + fPMsg: PChar; + fChangeCount: integer; + fNb_Champ : Integer; + fList_FieldName : TStringList; + fList_Field : TList; + procedure SetBusyTimeout(Timeout: integer); + public + constructor Create(DBFileName: String); + destructor Destroy; override; + function Query(Sql: String; Table: TStrings ): boolean; + function ErrorMessage(ErrNo: Integer): string; + function IsComplete(Sql: String): boolean; + function LastInsertRow: integer; + function Cancel: boolean; + function DatabaseDetails(Table: TStrings): boolean; + property LastErrorMessage: string read fMsg; + property LastError: Integer read fError; + property Version: String read fVersion; + property Encoding: String read fEncoding; + property OnData: TOnData read fOnData write fOnData; + property OnBusy: TOnBusy read fOnBusy write fOnBusy; + property OnQueryComplete: TOnQueryComplete read fOnQueryComplete write fOnQueryComplete; + property BusyTimeout: Integer read fBusyTimeout write SetBusyTimeout; + property ChangeCount: Integer read fChangeCount; + property List_FieldName: TStringList read fList_FieldName write fList_FieldName; + property List_Field: TList read fList_Field write fList_Field; + property Nb_Champ: integer read fNb_Champ write fNb_Champ; + + procedure SQLOnData(Sender: TObject; Columns: Integer; ColumnNames, ColumnValues: String); + + end; + function Pas2SQLStr(const PasString: string): string; + function SQL2PasStr(const SQLString: string): string; + function QuoteStr(const s: string; QuoteChar: Char ): string; + function UnQuoteStr(const s: string; QuoteChar: Char ): string; + procedure ValueList(const ColumnNames, ColumnValues: String; NameValuePairs: TStrings); + +implementation + +Const + DblQuote: Char = '"'; + SngQuote: Char = #39; + Crlf: String = #13#10; + Tab: Char = #9; + +var + MsgNoError: String; + +function QuoteStr(const s: string; QuoteChar: Char ): string; +begin + Result := Concat(QuoteChar, s, QuoteChar); +end; + +function UnQuoteStr(const s: string; QuoteChar: Char ): string; +begin + Result := s; + if length(Result) > 1 then + begin + if Result[1] = QuoteChar then + Delete(Result, 1, 1); + if Result[Length(Result)] = QuoteChar then + Delete(Result, Length(Result), 1); + end; +end; + +function Pas2SQLStr(const PasString: string): string; +var + n: integer; +begin + Result := SQL2PasStr(PasString); + n := Length(Result); + while n > 0 do + begin + if Result[n] = SngQuote then + Insert(SngQuote, Result, n); + dec(n); + end; + Result := QuoteStr(Result,#39); +end; + +function SQL2PasStr(const SQLString: string): string; +const + DblSngQuote: String = #39#39; +var + p: integer; +begin + Result := SQLString; + p := pos(DblSngQuote, Result); + while p > 0 do + begin + Delete(Result, p, 1); + p := pos(DblSngQuote, Result); + end; + Result := UnQuoteStr(Result,#39); +end; + +procedure ValueList(const ColumnNames, ColumnValues: String; NameValuePairs: TStrings); +var + n: integer; + lstName, lstValue: TStringList; +begin + if NameValuePairs <> nil then + begin + lstName := TStringList.Create; + lstValue := TStringList.Create; + lstName.CommaText := ColumnNames; + lstValue.CommaText := ColumnValues; + NameValuePairs.Clear; + if lstName.Count = LstValue.Count then + if lstName.Count > 0 then + for n := 0 to lstName.Count - 1 do + NameValuePairs.Append(Concat(lstName.Strings[n], '=', lstValue.Strings[n])); + lstValue.Free; + lstName.Free; + end; +end; + + + +function SystemErrorMsg(ErrNo: Integer ): String; +var + buf: PChar; + size: Integer; + MsgLen: Integer; +begin +{ size := 256; + GetMem(buf, size); + If ErrNo = - 1 then + ErrNo := GetLastError; + MsgLen := FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, nil, ErrNo, 0, buf, size, nil); + if MsgLen = 0 then + Result := 'ERROR' + else + Result := buf;} +end; + +function BusyCallback(Sender: pointer; ObjectName: PChar; BusyCount: integer): integer; cdecl; +var + sObjName: String; + bCancel: Boolean; +begin + Result := -1; + with TObject(Sender) as TSQLite do + begin + if Assigned(fOnBusy) then + begin + bCancel := False; + sObjName := ObjectName; + fOnBusy(Tobject(Sender), sObjName, BusyCount, bCancel); + if bCancel then + Result := 0; + end; + end; +end; + +function ExecCallback(Sender: Pointer; Columns: Integer; ColumnValues: PPChar; ColumnNames: PPchar): integer; cdecl; +var + PVal, PName: ^PChar; + n: integer; + sVal, sName: String; +begin + Result := 0; + with TObject(Sender) as TSQLite do + begin + if (Assigned(fOnData) or Assigned(fTable)) then + begin + fLstName.Clear; + fLstVal.Clear; + if Columns > 0 then + begin + PName := ColumnNames; + PVal := ColumnValues; + for n := 0 to Columns - 1 do + begin + fLstName.Append(PName^); + fLstVal.Append(PVal^); + inc(PName); + inc(PVal); + end; + end; + sVal := fLstVal.CommaText; + sName := fLstName.CommaText; + if Assigned(fOnData) then + fOnData(TObject(Sender), Columns, sName, sVal); + if Assigned(fTable) then + begin + if fTable.Count = 0 then + fTable.Append(sName); + fTable.Append(sVal); + end; + end; + end; +end; + + +procedure TSQLite.SQLOnData(Sender: TObject; Columns: Integer; ColumnNames, ColumnValues: String); +Var i : Integer; + InterS,val : String; + Field : TStringList; + + function Pos1(a: String ; s : char) : integer; + var i,j : Integer; + + begin + j:=-1; + for i:=1 to length(a) Do + begin + if a[i] = s then + begin + j:=i; + break; + end; + end; + result:=j; + end; +begin + If Nb_Champ = -1 Then + Begin // Put the fields name in List_FieldName + Nb_Champ:=Columns; + InterS:=ColumnNames; + While (Pos1(InterS,',') > 0) do + begin + val:=copy(InterS,1,Pos1(InterS,',')-1); + InterS:=copy(InterS,Pos1(InterS,',')+1,length(InterS)); + List_FieldName.add(val); + end; + if length(InterS) > 0 then List_FieldName.add(InterS); + end; + // Put the list of TStringList of value + Field :=TStringList.Create; + InterS:=ColumnValues; + While (Pos1(InterS,',') > 0) do + begin + val:=copy(InterS,1,Pos1(InterS,',')-1); + InterS:=copy(InterS,Pos1(InterS,',')+1,length(InterS)); + Field.add(val); + end; + if length(InterS) > 0 then Field.add(InterS); + List_Field.add(Field); +end; + +constructor TSQLite.Create(DBFileName: String); +var + fPMsg1: PChar; + name : pchar; +begin + inherited Create; + List_FieldName := TStringList.Create; + List_Field := TList.Create; + fError := SQLITE_ERROR; + fIsOpen := False; + fLstName := TStringList.Create; + fLstVal := TStringList.Create; + fOnData := nil; + fOnBusy := nil; + fOnQueryComplete := nil; + fChangeCount := 0; + name:=StrAlloc (length(DBFileName)+1); + strpcopy(name,DBFileName); + OnData:=@SQLOnData; + fSQLite := SQLite_Open(name, 1, @fPMsg); + SQLite_FreeMem(fPMsg); + if fSQLite <> nil then + begin + //fVersion := String(SQLite_Version); + //fEncoding := SQLite_Encoding; + fIsOpen := True; + fError := SQLITE_OK; + end; + fMsg := ErrorMessage(fError); +end; + +destructor TSQLite.Destroy; +begin + if fIsOpen then + SQLite_Close(fSQLite); + fIsOpen := False; + fLstName.Free; + fLstVal.Free; + fSQLite := nil; + fOnData := nil; + fOnBusy := nil; + fOnQueryComplete := nil; + fLstName := nil; + fLstVal := nil; + List_FieldName.destroy; + List_Field.destroy; + inherited Destroy; +end; + +function TSQLite.Query(Sql: String; Table: TStrings ): boolean; +//var +// fPMsg: PChar; +//var Psql : pchar; +begin + fError := SQLITE_ERROR; + if fIsOpen then + begin + fPMsg := nil; + fBusy := True; + fTable := Table; + if fTable <> nil then + fTable.Clear; + List_FieldName.clear; + List_Field.clear; + Nb_Champ:=-1; + fError := SQLite_Exec(fSQLite, PChar(sql), @ExecCallback, Self, @fPMsg); + SQLite_FreeMem(fPMsg); + fChangeCount := SQLite_Changes(fSQLite); + fTable := nil; + fBusy := False; + if Assigned(fOnQueryComplete) then + fOnQueryComplete(Self); + end; + fMsg := ErrorMessage(fError); + Result := (fError = SQLITE_OK); +end; + +function TSQLite.Cancel: boolean; +begin + Result := False; + if fBusy and fIsOpen then + begin + do_SQLite_interrupt(fSQLite); + fBusy := false; + Result := True; + end; +end; + +procedure TSQLite.SetBusyTimeout(Timeout: Integer); +begin + fBusyTimeout := Timeout; + if fIsOpen then + begin + SQLite_Busy_Timeout(fSQLite, fBusyTimeout); + if fBusyTimeout > 0 then + SQLite_Busy_Handler(fSQLite, @BusyCallback, Self) + else + SQLite_Busy_Handler(fSQLite, nil, nil); + end; +end; + +function TSQLite.LastInsertRow: integer; +begin + if fIsOpen then + Result := SQLite_Last_Insert_RowID(fSQLite) + else + Result := -1; +end; + +function TSQLite.ErrorMessage(ErrNo: Integer): string; +begin + if ErrNo = 0 then + Result := MsgNoError + else + Result := SQLite_Error_String(ErrNo); +end; + +function TSQLite.IsComplete(Sql: String): boolean; +var Psql : pchar; +begin + Psql:=StrAlloc (length(Sql)+1); + strpcopy(Psql,Sql); + Writeln('Testing: ',psql); + Result := SQLite_Complete(Psql)<>0; + strdispose(Psql); +end; + +function TSQLite.DatabaseDetails(Table: TStrings): boolean; +begin + Result := Query('SELECT * FROM SQLITE_MASTER;', Table); +end; + +initialization + +finalization + +end. diff --git a/packages/sqlite/tests/test.pas b/packages/sqlite/tests/test.pas new file mode 100644 index 0000000000..0a7121c75e --- /dev/null +++ b/packages/sqlite/tests/test.pas @@ -0,0 +1,52 @@ +program test; + +uses sqlite,sqlitedb, strings,classes; + +var + MySQL: TSQLite; + SQL: String; + i, j: Integer; + a: TStringList; +begin + Writeln('Creating class'); + MySQL := TSQLite.Create('test.db'); + MySQL.BusyTimeout := 1000; + + // writeln(MySQL.Version); + Writeln('Creating table'); + SQL := 'CREATE TABLE Test(No int, Nom varchar(32),Prenom varchar(32));'; + MySQL.Query(sql, nil); + SQL := 'INSERT INTO Test VALUES(1,''Coursiere'', ''Olivier'');'; + if MySQL.IsComplete(sql) then + begin + Writeln('Inserting first row'); + MySQL.Query(sql, nil); + end; + SQL := 'INSERT INTO Test VALUES(2,''Jourde'', ''Eric'');'; + if MySQL.IsComplete(sql) then + begin + Writeln('Inserting second row') ; + MySQL.Query(sql, nil); + end; + Writeln('Selecting rows') ; + + SQL := 'SELECT * FROM Test;'; + MySQL.Query(sql, nil); + writeln('Fields Names -------------------'); + for i:=0 to MySQL.List_FieldName.count-1 do + writeln(i,' -> ',MySQL.List_FieldName.Strings[i]); + writeln('Fields -------------------'); + for i:=0 to MySQL.List_Field.count-1 do + begin + a:=TStringList(MySQL.List_Field.items[i]); + write(i,' -> '); + for j:=0 to a.count-1 do + write(a.Strings[j],' '); + writeln(''); + end; + +// Uncomment to remove table again. +// SQL := 'DROP TABLE Test;'; +// MySQL.Query(sql, nil); + MySQL.Free; +end. diff --git a/packages/sqlite/tests/testapiv3x.README b/packages/sqlite/tests/testapiv3x.README new file mode 100644 index 0000000000..90df74814e --- /dev/null +++ b/packages/sqlite/tests/testapiv3x.README @@ -0,0 +1,44 @@ +Testing SQLite v3 + +This prog is a simple direct api call +sample for sqlite v3x. + +I.install +1°)win32 + +sqlite3.dll should be in default path or current dir +and can be downloaded from here : + http://www.sqlite.org/ + + +2°)wince-arm + +.sqlite3.dll should be in default path or current dir +and wince version can be downloaded from here : + http://sourceforge.net/projects/sqlite-wince +this is a source only release need evc++4 +also pre-compiled libraries for arm-wince are +on ftp://ftp.freepascal.org/pub/fpc/contrib/arm-wince-sqlite322.zip +..shell/console is required on target system +more info here : http://www.freepascal.org/wiki/index.php/WinCE_port +...sqlite unit is not build automaticaly for arm-wince target +add it in the path or build it manually + +II.tests + +2005/09/19 : + wince-arm : + testapvv3x have been tested with v3.2.2 + compiled fpc2.1.1 today svn rep + command line for cross-compiling from XP: + fpc.exe -a -dNORMAL -Twince -Parm -XParm-wince-pe- -FDd:\binutils\win32-arm-pe -FE. -va testapiv3x.pp >test-arm-wince.log + + win32 : + testapvv3x have been tested with v3.2.4 + compiled fpc2.1.1 today svn rep under lazarus + + + +Regards +olivier +orinaudo@gmail.com diff --git a/packages/sqlite/tests/testapiv3x.pp b/packages/sqlite/tests/testapiv3x.pp new file mode 100644 index 0000000000..ea820980ce --- /dev/null +++ b/packages/sqlite/tests/testapiv3x.pp @@ -0,0 +1,83 @@ +program testapiv3x; + +{$APPTYPE CONSOLE} +{$MODE DELPHI} + +uses sqlite3, sysutils; + +const + DBFILE='dbtest.db'; + +var + rc : Integer; + db : PPsqlite3; + sql : string; + pzErrMsg : PChar; + +function MyCallback(_para1:pointer; plArgc:longint; argv:PPchar; argcol:PPchar):longint; cdecl; +var i: Integer; + PVal, PName: ^PChar; +begin + PVal:=argv; + PName:=argcol; + for i:=0 to plArgc-1 do begin + writeln(Format('%s = ''%s'''#13, [PName^, PVal^])); + inc(PVal); + inc(PName); + end; + writeln(#13); + Result:=0; +end; + +begin + writeln(Format('SQLite version : %d',[sqlite3_libversion_number])); + rc := sqlite3_open(PChar(DBFILE), @db); + try + if rc<>SQLITE_OK then begin + writeln(Format('Can''t open database: %s',[DBFILE])); + end; + + sql:= 'DROP TABLE Test;'; + rc:=sqlite3_exec(db, PChar(sql), @MyCallback, nil, @pzErrMsg); + if( rc<>SQLITE_OK ) + then writeln(Format('SQL error: %s', [pzErrMsg^])); + + sql:='CREATE TABLE Test(No integer, name varchar(32),shortname varchar(32), age integer);'; + rc:=sqlite3_exec(db, PChar(sql), @MyCallback, nil, @pzErrMsg); + if( rc<>SQLITE_OK ) + then writeln(Format('SQL error: %s', [pzErrMsg^])); + + sql:='INSERT INTO Test VALUES(1,''hi'', ''by'', -1);'; + rc:=sqlite3_exec(db, PChar(sql), @MyCallback, nil, @pzErrMsg); + Writeln('Inserting row'); + if( rc<>SQLITE_OK ) + then writeln(Format('SQL error: %s', [pzErrMsg^])); + + SQL := 'INSERT INTO Test VALUES(2,''dualcore'', ''runwell'',-1);'; + rc:=sqlite3_exec(db, PChar(sql), @MyCallback, nil, @pzErrMsg); + Writeln('Inserting row') ; + if( rc<>SQLITE_OK ) + then writeln(Format('SQL error: %s', [pzErrMsg^])); + + SQL := 'INSERT INTO Test VALUES(3,''Hello'', ''World'',NULL);'; + rc:=sqlite3_exec(db, PChar(sql), @MyCallback, nil, @pzErrMsg); + Writeln('Inserting row') ; + if( rc<>SQLITE_OK ) + then writeln(Format('SQL error: %s', [pzErrMsg^])); + + SQL := 'INSERT INTO Test VALUES(4,''just a little'', ''test'',-1);'; + rc:=sqlite3_exec(db, PChar(sql), @MyCallback, nil, @pzErrMsg); + Writeln('Inserting row') ; + if( rc<>SQLITE_OK ) + then writeln(Format('SQL error: %s', [pzErrMsg^])); + + SQL := 'select * from Test;'; + rc:=sqlite3_exec(db, PChar(sql), @MyCallback, nil, @pzErrMsg); + if( rc<>SQLITE_OK ) + then writeln(Format('SQL error: %s', [pzErrMsg^])); + finally sqlite3_close(db); end; + + sleep(5000); +end. + + -- cgit v1.2.1