--- Merging r34618 into '.':

U    packages/sqlite/src/sqlite3.inc
--- Recording mergeinfo for merge of r34618 into '.':
 U   .
--- Merging r34867 into '.':
U    packages/odbc/src/odbcsql.inc
--- Recording mergeinfo for merge of r34867 into '.':
 G   .

# revisions: 34618,34867

git-svn-id: branches/fixes_3_0@36008 -

packages/odbc/src/odbcsql.inc

@@ -68,6 +68,7 @@ uses
 
 type
   SQLCHAR      = cuchar;
+  SQLWCHAR     = WideChar;
   SQLSCHAR     = cschar;
   SQLSMALLINT  = csshort;
   SQLUSMALLINT = cushort;
@@ -87,7 +88,8 @@ type
   SQLHDESC     = SQLHANDLE;
   SQLHWND      = pointer;
   SQLSETPOSIROW= {$IF DEFINED(CPU64) AND DEFINED(ODBCVER352)}cuint64{$ELSE}SQLUSMALLINT{$ENDIF};
-  PSQLCHAR      = PChar;
+  PSQLCHAR      = PAnsiChar;
+  PSQLWCHAR     = PWideChar;
   PSQLSMALLINT  = ^SQLSMALLINT;
   PSQLUSMALLINT = ^SQLUSMALLINT;
   PSQLINTEGER   = ^SQLINTEGER;
@@ -211,6 +213,7 @@ const
   { C datatype to SQL datatype mapping }
   SQL_C_CHAR   = SQL_CHAR;
   SQL_C_WCHAR  = SQL_WCHAR;
+  SQL_C_TCHAR  = {$IFDEF UNICODE}SQL_C_WCHAR{$ELSE}SQL_C_CHAR{$ENDIF};
   SQL_C_LONG   = SQL_INTEGER;
   SQL_C_SHORT  = SQL_SMALLINT;
   SQL_C_FLOAT  = SQL_REAL;
@@ -1066,10 +1069,10 @@ const
 
 {$ifdef DYNLOADINGODBC}
 
-type   tSQLAllocHandle =function(HandleType: SQLSMALLINT;
+type   TSQLAllocHandle =function(HandleType: SQLSMALLINT;
            InputHandle:SQLHANDLE;Var OutputHandlePtr: SQLHANDLE):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
 
-type   tSQLSetEnvAttr=function (EnvironmentHandle:SQLHENV;
+type   TSQLSetEnvAttr=function (EnvironmentHandle:SQLHENV;
            Attribute:SQLINTEGER;Value:SQLPOINTER;
            StringLength:SQLINTEGER):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
 
@@ -1078,9 +1081,15 @@ type   TSQLFreeHandle=function (HandleType:SQLSMALLINT;
 
 type   TSQLGetDiagRec=function (HandleType:SQLSMALLINT;
            Handle:SQLHANDLE;RecNumber:SQLSMALLINT;
-           Sqlstate:PSQLCHAR;var NativeError:SQLINTEGER;
+           SqlState:PSQLCHAR;var NativeError:SQLINTEGER;
            MessageText:PSQLCHAR;BufferLength:SQLSMALLINT;
            var TextLength:SQLSMALLINT ):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
+       TSQLGetDiagRecW=function (HandleType:SQLSMALLINT;
+           Handle:SQLHANDLE;RecNumber:SQLSMALLINT;
+           SqlState:PSQLWCHAR;var NativeError:SQLINTEGER;
+           MessageText:PSQLWCHAR;BufferLength:SQLSMALLINT;
+           var TextLength:SQLSMALLINT ):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
+
 
 type   TSQLGetDiagField=function (HandleType:SQLSMALLINT;
            Handle:SQLHANDLE;RecNumber:SQLSMALLINT;
@@ -1091,20 +1100,33 @@ type   TSQLConnect=function (ConnectionHandle:SQLHDBC;
            ServerName:PSQLCHAR;NameLength1:SQLSMALLINT;
            UserName:PSQLCHAR;NameLength2:SQLSMALLINT;
            Authentication:PSQLCHAR;NameLength3:SQLSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
+       TSQLConnectW=function (ConnectionHandle:SQLHDBC;
+           ServerName:PSQLWCHAR;NameLength1:SQLSMALLINT;
+           UserName:PSQLWCHAR;NameLength2:SQLSMALLINT;
+           Authentication:PSQLWCHAR;NameLength3:SQLSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
 
 type   TSQLDisconnect=function(ConnectionHandle:SQLHDBC):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
 
-type   TSQLDriverConnect=function (hdbc: SQLHDBC;
-           hwnd: SQLHWND;szCsin: PChar;
-           szCLen: SQLSMALLINT;szCsout: PChar;
-           cbCSMax: SQLSMALLINT;Var cbCsOut: SQLSMALLINT;
-           f: SQLUSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
+type   TSQLDriverConnect=function (ConnectionHandle: SQLHDBC;
+           WindowHandle: SQLHWND; InConnectionString: PSQLCHAR;
+           StringLength1: SQLSMALLINT; OutConnectionString: PSQLCHAR;
+           BufferLength: SQLSMALLINT; Var StringLength2: SQLSMALLINT;
+           DriverCompletion: SQLUSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
+       TSQLDriverConnectW=function (ConnectionHandle: SQLHDBC;
+           WindowHandle: SQLHWND; InConnectionString: PSQLWCHAR;
+           StringLength1: SQLSMALLINT; OutConnectionString: PSQLWCHAR;
+           BufferLength: SQLSMALLINT; Var StringLength2: SQLSMALLINT;
+           DriverCompletion: SQLUSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
 
 type   TSQLExecDirect=function (StatementHandle:SQLHSTMT;
            StatementText:PSQLCHAR;TextLength:SQLINTEGER):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
+       TSQLExecDirectW=function (StatementHandle:SQLHSTMT;
+           StatementText:PSQLWCHAR;TextLength:SQLINTEGER):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
 
 type   TSQLPrepare=function (StatementHandle:SQLHSTMT;
            StatementText:PSQLCHAR;TextLength:SQLINTEGER):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
+       TSQLPrepareW=function (StatementHandle:SQLHSTMT;
+           StatementText:PSQLWCHAR;TextLength:SQLINTEGER):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
 
 type   TSQLCloseCursor=function (StatementHandle:SQLHSTMT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
 
@@ -1120,6 +1142,11 @@ type   TSQLDescribeCol=function (StatementHandle:SQLHSTMT;
            BufferLength:SQLSMALLINT;var NameLength:SQLSMALLINT;
            var DataType:SQLSMALLINT;var ColumnSize:SQLULEN;
            var DecimalDigits:SQLSMALLINT;var Nullable:SQLSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
+       TSQLDescribeColW=function (StatementHandle:SQLHSTMT;
+           ColumnNumber:SQLUSMALLINT;ColumnName:PSQLWCHAR;
+           BufferLength:SQLSMALLINT;var NameLength:SQLSMALLINT;
+           var DataType:SQLSMALLINT;var ColumnSize:SQLULEN;
+           var DecimalDigits:SQLSMALLINT;var Nullable:SQLSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
 
 type   TSQLFetchScroll=function (StatementHandle:SQLHSTMT;
            FetchOrientation:SQLSMALLINT;FetchOffset:SQLLEN):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
@@ -1150,7 +1177,7 @@ type   TSQLSetDescRec=function (DescriptorHandle:SQLHDESC;
            Length:SQLLEN; Precision, Scale: SQLSMALLINT;
            DataPtr:SQLPOINTER; StringLengthPtr,IndicatorPtr:PSQLLEN):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
 
-type   tSQLGetInfo=function (ConnectionHandle:SQLHDBC;
+type   TSQLGetInfo=function (ConnectionHandle:SQLHDBC;
            InfoType:SQLUSMALLINT;InfoValue:SQLPOINTER;
            BufferLength:SQLSMALLINT;StringLength:PSQLSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
 
@@ -1207,8 +1234,8 @@ type   TSQLFreeStmt=function (StatementHandle:SQLHSTMT;
 
 type   TSQLColAttribute=function (StatementHandle:SQLHSTMT;
            ColumnNumber:SQLUSMALLINT;FieldIdentifier:SQLUSMALLINT;
-           CharacterAttribute:PSQLCHAR;BufferLength:SQLSMALLINT;
-           StringLength:PSQLSMALLINT;NumericAttribute:PSQLLEN):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
+           CharacterAttributePtr:SQLPOINTER;BufferLength:SQLSMALLINT;
+           StringLengthPtr:PSQLSMALLINT;NumericAttributePtr:PSQLLEN):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
 
 type   TSQLEndTran=function (HandleType:SQLSMALLINT;
            Handle:SQLHANDLE;CompletionType:SQLSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
@@ -1218,12 +1245,22 @@ type   TSQLTables=function ( hstmt : SQLHSTMT;
            szTableOwner : PSQLCHAR;cbTableOwner : SQLSMALLINT;
            szTableName : PSQLCHAR;cbTableName : SQLSMALLINT;
            szTableType : PSQLCHAR;cbTableType : SQLSMALLINT ) : SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif};
+       TSQLTablesW=function ( hstmt : SQLHSTMT;
+           szTableQualifier : PSQLWCHAR;cbTableQualifier : SQLSMALLINT;
+           szTableOwner : PSQLWCHAR;cbTableOwner : SQLSMALLINT;
+           szTableName : PSQLWCHAR;cbTableName : SQLSMALLINT;
+           szTableType : PSQLWCHAR;cbTableType : SQLSMALLINT ) : SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif};
 
 type   TSQLColumns=function ( hstmt : SQLHSTMT;
            szTableQualifier : PSQLCHAR;cbTableQualifier : SQLSMALLINT;
            szTableOwner : PSQLCHAR;cbTableOwner : SQLSMALLINT;
            szTableName : PSQLCHAR;cbTableName : SQLSMALLINT;
            szColumnName : PSQLCHAR;cbColumnName : SQLSMALLINT ) : SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif};
+      TSQLColumnsW=function ( hstmt : SQLHSTMT;
+           szTableQualifier : PSQLWCHAR;cbTableQualifier : SQLSMALLINT;
+           szTableOwner : PSQLWCHAR;cbTableOwner : SQLSMALLINT;
+           szTableName : PSQLWCHAR;cbTableName : SQLSMALLINT;
+           szColumnName : PSQLWCHAR;cbColumnName : SQLSMALLINT ) : SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif};
 
 type   TSQLSpecialColumns=function (StatementHandle:SQLHSTMT;
            IdentifierType:SQLUSMALLINT;CatalogName:PSQLCHAR;
@@ -1236,42 +1273,60 @@ type   TSQLProcedures=function ( hstmt : SQLHSTMT;
            szTableQualifier : PSQLCHAR;cbTableQualifier : SQLSMALLINT;
            szTableOwner : PSQLCHAR;cbTableOwner : SQLSMALLINT;
            szTableName : PSQLCHAR;cbTableName : SQLSMALLINT ) : SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif};
+       TSQLProceduresW=function ( hstmt : SQLHSTMT;
+           szTableQualifier : PSQLWCHAR;cbTableQualifier : SQLSMALLINT;
+           szTableOwner : PSQLWCHAR;cbTableOwner : SQLSMALLINT;
+           szTableName : PSQLWCHAR;cbTableName : SQLSMALLINT ) : SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif};
 
-type   TSQLPrimaryKeys=function (hstmt : SQLHSTMT;
-           CatalogName:PSQLCHAR;NameLength1:SQLSMALLINT;
-           SchemaName:PSQLCHAR;NameLength2:SQLSMALLINT;
-           TableName:PSQLCHAR;NameLength3:SQLSMALLINT ):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
 type   TSQLProcedureColumns = function(hstmt: SQLHSTMT;
            CatalogName: PSQLCHAR; NameLength1: SQLSMALLINT;
            SchemaName: PSQLCHAR; NameLength2: SQLSMALLINT;
            ProcName: PSQLCHAR; NameLength3: SQLSMALLINT;
            ColumnName: PSQLCHAR; NameLength4: SQLSMALLINT): SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif};
+
+type   TSQLPrimaryKeys=function (hstmt : SQLHSTMT;
+           CatalogName:PSQLCHAR;NameLength1:SQLSMALLINT;
+           SchemaName:PSQLCHAR;NameLength2:SQLSMALLINT;
+           TableName:PSQLCHAR;NameLength3:SQLSMALLINT ):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
+       TSQLPrimaryKeysW=function (hstmt : SQLHSTMT;
+           CatalogName:PSQLWCHAR;NameLength1:SQLSMALLINT;
+           SchemaName:PSQLWCHAR;NameLength2:SQLSMALLINT;
+           TableName:PSQLWCHAR;NameLength3:SQLSMALLINT ):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};
+
 type   TSQLStatistics = function (hstmt: SQLHSTMT;
            CatalogName:PSQLCHAR; NameLength1:SQLSMALLINT;
            SchemaName:PSQLCHAR; NameLength2:SQLSMALLINT;
            TableName:PSQLCHAR; NameLength3:SQLSMALLINT;
            Unique:SQLUSMALLINT;
            Reserved:SQLUSMALLINT): SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif};
+       TSQLStatisticsW = function (hstmt: SQLHSTMT;
+           CatalogName:PSQLWCHAR; NameLength1:SQLSMALLINT;
+           SchemaName:PSQLWCHAR; NameLength2:SQLSMALLINT;
+           TableName:PSQLWCHAR; NameLength3:SQLSMALLINT;
+           Unique:SQLUSMALLINT;
+           Reserved:SQLUSMALLINT): SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif};
 
 var    SQLAllocHandle:tSQLAllocHandle;
 var    SQLSetEnvAttr:tSQLSetEnvAttr;
 var    SQLFreeHandle:tSQLFreeHandle;
 var    SQLGetInfo:tSQLGetInfo;
-var    SQLProcedures:TSQLProcedures;
-var    SQLColumns:TSQLColumns;
-var    SQLSpecialColumns:TSQLSpecialColumns;
 var    SQLGetDiagRec:TSQLGetDiagRec;
 var    SQLGetDiagField:TSQLGetDiagField;
 var    SQLConnect:TSQLConnect;
+       SQLConnectW:TSQLConnectW;
 var    SQLDisconnect:TSQLDisconnect;
 var    SQLDriverConnect:TSQLDriverConnect;
+       SQLDriverConnectW:TSQLDriverConnectW;
 var    SQLExecDirect:TSQLExecDirect;
+       SQLExecDirectW:TSQLExecDirectW;
 var    SQLPrepare:TSQLPrepare;
+       SQLPrepareW:TSQLPrepareW;
 var    SQLCloseCursor:TSQLCloseCursor;
 var    SQLExecute:TSQLExecute;
 var    SQLFetch:TSQLFetch;
 var    SQLNumResultCols:TSQLNumResultCols;
 var    SQLDescribeCol:TSQLDescribeCol;
+       SQLDescribeColW:TSQLDescribeColW;
 var    SQLFetchScroll:TSQLFetchScroll;
 var    SQLExtendedFetch:TSQLExtendedFetch;
 var    SQLGetData:TSQLGetData;
@@ -1294,9 +1349,18 @@ var    SQLFreeStmt:TSQLFreeStmt;
 var    SQLColAttribute:TSQLColAttribute;
 var    SQLEndTran:TSQLEndTran;
 var    SQLTables:TSQLTables;
+       SQLTablesW:TSQLTablesW;
+var    SQLColumns:TSQLColumns;
+       SQLColumnsW:TSQLColumnsW;
+var    SQLSpecialColumns:TSQLSpecialColumns;
 var    SQLPrimaryKeys:TSQLPrimaryKeys;
+       SQLPrimaryKeysW:TSQLPrimaryKeysW;
+var    SQLProcedures:TSQLProcedures;
+       SQLProceduresW:TSQLProceduresW;
 var    SQLProcedureColumns : TSQLProcedureColumns;
 var    SQLStatistics: TSQLStatistics;
+       SQLStatisticsW: TSQLStatisticsW;
+
 var    odbcversion:word;
 
 {$else}
@@ -1323,11 +1387,20 @@ var    odbcversion:word;
                HandleType:   SQLSMALLINT;
                Handle:       SQLHANDLE;
                RecNumber:    SQLSMALLINT;
-               Sqlstate:     PSQLCHAR;
+               SqlState:     PSQLCHAR;
                var NativeError: SQLINTEGER;
                MessageText:     PSQLCHAR;
                BufferLength:    SQLSMALLINT;
                var TextLength:  SQLSMALLINT ):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
+   function SQLGetDiagRecW(
+               HandleType:   SQLSMALLINT;
+               Handle:       SQLHANDLE;
+               RecNumber:    SQLSMALLINT;
+               SqlState:     PSQLWCHAR;
+               var NativeError: SQLINTEGER;
+               MessageText:     PSQLWCHAR;
+               BufferLength:    SQLSMALLINT;
+               var TextLength:  SQLSMALLINT ):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
    function SQLGetDiagField(
                HandleType:SQLSMALLINT;
                Handle:SQLHANDLE;
@@ -1342,17 +1415,26 @@ var    odbcversion:word;
                UserName:PSQLCHAR;      NameLength2:SQLSMALLINT;
                Authentication:PSQLCHAR;NameLength3:SQLSMALLINT
               ):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
+   function SQLConnectW(
+               ConnectionHandle: SQLHDBC;
+               ServerName:PSQLWCHAR;    NameLength1:SQLSMALLINT;
+               UserName:PSQLWCHAR;      NameLength2:SQLSMALLINT;
+               Authentication:PSQLWCHAR;NameLength3:SQLSMALLINT
+              ):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
    function SQLDisconnect(
                ConnectionHandle:SQLHDBC):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
    function SQLDriverConnect(
-               hdbc: SQLHDBC;
-               hwnd: SQLHWND;
-               szCsin: PChar;
-               szCLen: SQLSMALLINT;
-               szCsout: PChar;
-               cbCSMax: SQLSMALLINT;
-               Var cbCsOut: SQLSMALLINT;
-               f: SQLUSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
+               ConnectionHandle: SQLHDBC;
+               WindowHandle: SQLHWND; InConnectionString: PSQLCHAR;
+               StringLength1: SQLSMALLINT; OutConnectionString: PSQLCHAR;
+               BufferLength: SQLSMALLINT; Var StringLength2: SQLSMALLINT;
+               DriverCompletion: SQLUSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
+   function SQLDriverConnectW(
+               ConnectionHandle: SQLHDBC;
+               WindowHandle: SQLHWND; InConnectionString: PSQLWCHAR;
+               StringLength1: SQLSMALLINT; OutConnectionString: PSQLWCHAR;
+               BufferLength: SQLSMALLINT; Var StringLength2: SQLSMALLINT;
+               DriverCompletion: SQLUSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
    function SQLBrowseConnect(
                hdbc : SQLHDBC;
                szConnStrIn :PSQLCHAR;
@@ -1364,10 +1446,18 @@ var    odbcversion:word;
                StatementHandle:SQLHSTMT;
                StatementText:  PSQLCHAR;
                TextLength:     SQLINTEGER):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
+   function SQLExecDirectW(
+               StatementHandle:SQLHSTMT;
+               StatementText:  PSQLWCHAR;
+               TextLength:     SQLINTEGER):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
    function SQLPrepare(
                StatementHandle:SQLHSTMT;
                StatementText:PSQLCHAR;
                TextLength:SQLINTEGER):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
+   function SQLPrepareW(
+               StatementHandle:SQLHSTMT;
+               StatementText:PSQLWCHAR;
+               TextLength:SQLINTEGER):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
    function SQLCloseCursor(
                StatementHandle:SQLHSTMT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
    function SQLExecute(
@@ -1387,6 +1477,16 @@ var    odbcversion:word;
                var ColumnSize:SQLULEN;
                var DecimalDigits:SQLSMALLINT;
                var Nullable:SQLSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
+   function SQLDescribeColW(
+               StatementHandle:SQLHSTMT;
+               ColumnNumber:SQLUSMALLINT;
+               ColumnName:PSQLWCHAR;
+               BufferLength:SQLSMALLINT;
+               var NameLength:SQLSMALLINT;
+               var DataType:SQLSMALLINT;
+               var ColumnSize:SQLULEN;
+               var DecimalDigits:SQLSMALLINT;
+               var Nullable:SQLSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
    function SQLFetchScroll(
                StatementHandle:SQLHSTMT;
                FetchOrientation:SQLSMALLINT;
@@ -1491,10 +1591,10 @@ var    odbcversion:word;
                StatementHandle:SQLHSTMT;
                ColumnNumber:SQLUSMALLINT;
                FieldIdentifier:SQLUSMALLINT;
-               CharacterAttribute:PSQLCHAR;
+               CharacterAttributePtr:SQLPOINTER;
                BufferLength:SQLSMALLINT;
-               StringLength:PSQLSMALLINT;
-               NumericAttribute:PSQLLEN):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
+               StringLengthPtr:PSQLSMALLINT;
+               NumericAttributePtr:PSQLLEN):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
 {$ifdef ODBCVER3}
    function SQLEndTran(
                HandleType:SQLSMALLINT;
@@ -1510,6 +1610,15 @@ var    odbcversion:word;
                 cbTableName : SQLSMALLINT;
                 szTableType : PSQLCHAR;
                 cbTableType : SQLSMALLINT ) : SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif}; external odbclib;
+   function SQLTablesW( hstmt : SQLHSTMT;
+                szTableQualifier : PSQLWCHAR;
+                cbTableQualifier : SQLSMALLINT;
+                szTableOwner : PSQLWCHAR;
+                cbTableOwner : SQLSMALLINT;
+                szTableName : PSQLWCHAR;
+                cbTableName : SQLSMALLINT;
+                szTableType : PSQLWCHAR;
+                cbTableType : SQLSMALLINT ) : SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif}; external odbclib;
    function SQLColumns( hstmt : SQLHSTMT;
                 szTableQualifier : PSQLCHAR;
                 cbTableQualifier : SQLSMALLINT;
@@ -1519,6 +1628,15 @@ var    odbcversion:word;
                 cbTableName : SQLSMALLINT;
                 szColumnName : PSQLCHAR;
                 cbColumnName : SQLSMALLINT ) : SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif}; external odbclib;
+   function SQLColumnsW( hstmt : SQLHSTMT;
+                szTableQualifier : PSQLWCHAR;
+                cbTableQualifier : SQLSMALLINT;
+                szTableOwner : PSQLWCHAR;
+                cbTableOwner : SQLSMALLINT;
+                szTableName : PSQLWCHAR;
+                cbTableName : SQLSMALLINT;
+                szColumnName : PSQLWCHAR;
+                cbColumnName : SQLSMALLINT ) : SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif}; external odbclib;
    function SQLSpecialColumns(StatementHandle:SQLHSTMT;
                 IdentifierType:SQLUSMALLINT;
                 CatalogName:PSQLCHAR;
@@ -1536,23 +1654,38 @@ var    odbcversion:word;
                 cbTableOwner : SQLSMALLINT;
                 szTableName : PSQLCHAR;
                 cbTableName : SQLSMALLINT ) : SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif}; external odbclib;
+   function SQLProceduresW( hstmt : SQLHSTMT;
+                szTableQualifier : PSQLWCHAR;
+                cbTableQualifier : SQLSMALLINT;
+                szTableOwner : PSQLWCHAR;
+                cbTableOwner : SQLSMALLINT;
+                szTableName : PSQLWCHAR;
+                cbTableName : SQLSMALLINT ) : SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif}; external odbclib;
    function SQLPrimaryKeys(hstmt : SQLHSTMT;
-                CatalogName:PSQLCHAR;NameLength1:SQLSMALLINT;
-                SchemaName:PSQLCHAR;NameLength2:SQLSMALLINT;
-                TableName:PSQLCHAR;
-                NameLength3:SQLSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
+                CatalogName:PSQLCHAR; NameLength1:SQLSMALLINT;
+                SchemaName:PSQLCHAR; NameLength2:SQLSMALLINT;
+                TableName:PSQLCHAR; NameLength3:SQLSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
+   function SQLPrimaryKeysW(hstmt : SQLHSTMT;
+                CatalogName:PSQLWCHAR; NameLength1:SQLSMALLINT;
+                SchemaName:PSQLWCHAR; NameLength2:SQLSMALLINT;
+                TableName:PSQLWCHAR; NameLength3:SQLSMALLINT):SQLRETURN;{$ifdef fpc} extdecl {$else} stdcall {$endif};external odbclib;
    function SQLProcedureColumns(hstmt: SQLHSTMT;
                 CatalogName: PSQLCHAR; NameLength1: SQLSMALLINT;
                 SchemaName: PSQLCHAR; NameLength2: SQLSMALLINT;
                 ProcName: PSQLCHAR; NameLength3: SQLSMALLINT;
-                ColumnName: PSQLCHAR; NameLength4: SQLSMALLINT): SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif};
-                external odbclib;
+                ColumnName: PSQLCHAR; NameLength4: SQLSMALLINT): SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif}; external odbclib;
    function SQLStatistics(hstmt: SQLHSTMT;
                 CatalogName:PSQLCHAR; NameLength1:SQLSMALLINT;
                 SchemaName:PSQLCHAR; NameLength2:SQLSMALLINT;
                 TableName:PSQLCHAR; NameLength3:SQLSMALLINT;
                 Unique:SQLUSMALLINT;
                 Reserved:SQLUSMALLINT): SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif}; external odbclib;
+   function SQLStatisticsW(hstmt: SQLHSTMT;
+                CatalogName:PSQLWCHAR; NameLength1:SQLSMALLINT;
+                SchemaName:PSQLWCHAR; NameLength2:SQLSMALLINT;
+                TableName:PSQLWCHAR; NameLength3:SQLSMALLINT;
+                Unique:SQLUSMALLINT;
+                Reserved:SQLUSMALLINT): SQLRETURN; {$ifdef fpc} extdecl {$else} stdcall {$endif}; external odbclib;
 {$endif}
 // This function always load dynamic
 
@@ -1598,12 +1731,11 @@ begin
       end;
 
 {$ifdef fpc}
+    // Ansi versions:
     pointer(SQLAllocHandle) := GetProcedureAddress(ODBCLibraryHandle,'SQLAllocHandle');
     pointer(SQLSetEnvAttr) := GetProcedureAddress(ODBCLibraryHandle,'SQLSetEnvAttr');
     pointer(SQLFreeHandle) := GetProcedureAddress(ODBCLibraryHandle,'SQLFreeHandle');
     pointer(SQLGetInfo) := GetProcedureAddress(ODBCLibraryHandle,'SQLGetInfo');
-    pointer(SQLProcedures) := GetProcedureAddress(ODBCLibraryHandle,'SQLProcedures');
-    pointer(SQLColumns) := GetProcedureAddress(ODBCLibraryHandle,'SQLColumns');
     pointer(SQLSpecialColumns) := GetProcedureAddress(ODBCLibraryHandle,'SQLSpecialColumns');
     pointer(SQLGetDiagRec) := GetProcedureAddress(ODBCLibraryHandle,'SQLGetDiagRec');
     pointer(SQLGetDiagField) := GetProcedureAddress(ODBCLibraryHandle,'SQLGetDiagField');
@@ -1639,9 +1771,22 @@ begin
     pointer(SQLColAttribute) := GetProcedureAddress(ODBCLibraryHandle,'SQLColAttribute');
     pointer(SQLEndTran) := GetProcedureAddress(ODBCLibraryHandle,'SQLEndTran');
     pointer(SQLTables) := GetProcedureAddress(ODBCLibraryHandle,'SQLTables');
+    pointer(SQLColumns) := GetProcedureAddress(ODBCLibraryHandle,'SQLColumns');
     pointer(SQLPrimaryKeys) := GetProcedureAddress(ODBCLibraryHandle,'SQLPrimaryKeys');
+    pointer(SQLProcedures) := GetProcedureAddress(ODBCLibraryHandle,'SQLProcedures');
     pointer(SQLProcedureColumns) := GetProcedureAddress(ODBCLibraryHandle,'SQLProcedureColumns');
     pointer(SQLStatistics) := GetProcedureAddress(ODBCLibraryHandle,'SQLStatistics');
+    // Unicode versions:
+    pointer(SQLConnectW) := GetProcedureAddress(ODBCLibraryHandle,'SQLConnectW');
+    pointer(SQLDriverConnectW) := GetProcedureAddress(ODBCLibraryHandle,'SQLDriverConnectW');
+    pointer(SQLExecDirectW) := GetProcedureAddress(ODBCLibraryHandle,'SQLExecDirectW');
+    pointer(SQLPrepareW) := GetProcedureAddress(ODBCLibraryHandle,'SQLPrepareW');
+    pointer(SQLDescribeColW) := GetProcedureAddress(ODBCLibraryHandle,'SQLDescribeColW');
+    pointer(SQLTablesW) := GetProcedureAddress(ODBCLibraryHandle,'SQLTablesW');
+    pointer(SQLColumnsW) := GetProcedureAddress(ODBCLibraryHandle,'SQLColumnsW');
+    pointer(SQLProceduresW) := GetProcedureAddress(ODBCLibraryHandle,'SQLProceduresW');
+    pointer(SQLPrimaryKeysW) := GetProcedureAddress(ODBCLibraryHandle,'SQLPrimaryKeysW');
+    pointer(SQLStatisticsW) := GetProcedureAddress(ODBCLibraryHandle,'SQLStatisticsW');
 {$else}
     SQLAllocHandle := GetProcedureAddress(ODBCLibraryHandle,'SQLAllocHandle');
     SQLSetEnvAttr := GetProcedureAddress(ODBCLibraryHandle,'SQLSetEnvAttr');

packages/sqlite/src/sqlite3.inc

@@ -18,9 +18,9 @@ uses
 {$else}
   DynLibs;
 
-{$ifdef darwin}
-{$linklib sqlite3}
-{$endif}
+  {$ifdef darwin}
+    {$linklib sqlite3}
+  {$endif}
 {$endif}
 
 const
@@ -37,8 +37,7 @@ const
 {$ENDIF}
 
 {
-  Header converted from Sqlite version 3.7.9
-  SOURCE_ID = '2011-11-01 00:52:41 c7c6050ef060877ebe77b41d959e9df13f8c9b5e'
+  Header converted from Sqlite version 3.14.2
 }
 
 //SQLITE_EXTERN const char sqlite3_version[];
@@ -59,7 +58,7 @@ type
 
 const
   SQLITE_STATIC      = sqlite3_destructor_type(nil);
-  SQLITE_TRANSIENT   = pointer(-1);//sqlite3_destructor_type(-1);
+  SQLITE_TRANSIENT   = pointer(-1); //sqlite3_destructor_type(-1);
   
 
 type
@@ -76,6 +75,7 @@ type
   sqlite3_uint64 = sqlite_uint64;
 
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_close{$IFDEF D}: function{$ENDIF}(ref: psqlite3): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_close_v2{$IFDEF D}: function{$ENDIF}(ref: psqlite3): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 
 type
   sqlite3_callback = function(user: pointer; cols: cint; values, name: ppansichar): cint; cdecl;
@@ -117,6 +117,8 @@ const
   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_NOTICE     = 27;   (* Notifications from sqlite3_log() *)
+  SQLITE_WARNING    = 28;   (* Warnings from sqlite3_log() *)
   SQLITE_ROW        = 100;  (* sqlite3_step() has another row ready *)
   SQLITE_DONE       = 101;  (* sqlite3_step() has finished executing *)
 
@@ -142,18 +144,49 @@ const
   SQLITE_IOERR_SHMLOCK           = (SQLITE_IOERR or (20 shl 8));
   SQLITE_IOERR_SHMMAP            = (SQLITE_IOERR or (21 shl 8));
   SQLITE_IOERR_SEEK              = (SQLITE_IOERR or (22 shl 8));
+  SQLITE_IOERR_DELETE_NOENT      = (SQLITE_IOERR or (23 shl 8));
+  SQLITE_IOERR_MMAP              = (SQLITE_IOERR or (24 shl 8));
+  SQLITE_IOERR_GETTEMPPATH       = (SQLITE_IOERR or (25 shl 8));
+  SQLITE_IOERR_CONVPATH          = (SQLITE_IOERR or (26 shl 8));
+  SQLITE_IOERR_VNODE             = (SQLITE_IOERR or (27 shl 8));
+  SQLITE_IOERR_AUTH              = (SQLITE_IOERR or (28 shl 8));
   SQLITE_LOCKED_SHAREDCACHE      = (SQLITE_LOCKED or  (1 shl 8));
   SQLITE_BUSY_RECOVERY           = (SQLITE_BUSY   or  (1 shl 8));
+  SQLITE_BUSY_SNAPSHOT           = (SQLITE_BUSY   or  (2 shl 8));
   SQLITE_CANTOPEN_NOTEMPDIR      = (SQLITE_CANTOPEN or (1 shl 8));
+  SQLITE_CANTOPEN_ISDIR          = (SQLITE_CANTOPEN or (2 shl 8));
+  SQLITE_CANTOPEN_FULLPATH       = (SQLITE_CANTOPEN or (3 shl 8));
+  SQLITE_CANTOPEN_CONVPATH       = (SQLITE_CANTOPEN or (4 shl 8));
   SQLITE_CORRUPT_VTAB            = (SQLITE_CORRUPT or (1 shl 8));
   SQLITE_READONLY_RECOVERY       = (SQLITE_READONLY or (1 shl 8));
   SQLITE_READONLY_CANTLOCK       = (SQLITE_READONLY or (2 shl 8));
+  SQLITE_READONLY_ROLLBACK       = (SQLITE_READONLY or (3 shl 8));
+  SQLITE_READONLY_DBMOVED        = (SQLITE_READONLY or (4 shl 8));
+  SQLITE_ABORT_ROLLBACK          = (SQLITE_ABORT or (2 shl 8));
+  SQLITE_CONSTRAINT_CHECK        = (SQLITE_CONSTRAINT or (1 shl 8));
+  SQLITE_CONSTRAINT_COMMITHOOK   = (SQLITE_CONSTRAINT or (2 shl 8));
+  SQLITE_CONSTRAINT_FOREIGNKEY   = (SQLITE_CONSTRAINT or (3 shl 8));
+  SQLITE_CONSTRAINT_FUNCTION     = (SQLITE_CONSTRAINT or (4 shl 8));
+  SQLITE_CONSTRAINT_NOTNULL      = (SQLITE_CONSTRAINT or (5 shl 8));
+  SQLITE_CONSTRAINT_PRIMARYKEY   = (SQLITE_CONSTRAINT or (6 shl 8));
+  SQLITE_CONSTRAINT_TRIGGER      = (SQLITE_CONSTRAINT or (7 shl 8));
+  SQLITE_CONSTRAINT_UNIQUE       = (SQLITE_CONSTRAINT or (8 shl 8));
+  SQLITE_CONSTRAINT_VTAB         = (SQLITE_CONSTRAINT or (9 shl 8));
+  SQLITE_CONSTRAINT_ROWID        = (SQLITE_CONSTRAINT or (10 shl 8));
+  SQLITE_NOTICE_RECOVER_WAL      = (SQLITE_NOTICE or (1 shl 8));
+  SQLITE_NOTICE_RECOVER_ROLLBACK = (SQLITE_NOTICE or (2 shl 8));
+  SQLITE_WARNING_AUTOINDEX       = (SQLITE_WARNING or (1 shl 8));
+  SQLITE_AUTH_USER               = (SQLITE_AUTH or (1 shl 8));
+  SQLITE_OK_LOAD_PERMANENTLY     = (SQLITE_OK or (1 shl 8));
 
   SQLITE_OPEN_READONLY         = $00000001;
   SQLITE_OPEN_READWRITE        = $00000002;
   SQLITE_OPEN_CREATE           = $00000004;
   SQLITE_OPEN_DELETEONCLOSE    = $00000008;
   SQLITE_OPEN_EXCLUSIVE        = $00000010;
+  SQLITE_OPEN_AUTOPROXY        = $00000020;  (* VFS only *)
+  SQLITE_OPEN_URI              = $00000040;  (* Ok for sqlite3_open_v2() *)
+  SQLITE_OPEN_MEMORY           = $00000080;  (* Ok for sqlite3_open_v2() *)
   SQLITE_OPEN_MAIN_DB          = $00000100;
   SQLITE_OPEN_TEMP_DB          = $00000200;
   SQLITE_OPEN_TRANSIENT_DB     = $00000400;
@@ -180,7 +213,9 @@ const
   SQLITE_IOCAP_SAFE_APPEND     = $00000200;
   SQLITE_IOCAP_SEQUENTIAL      = $00000400;
   SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN  = $00000800;
-  
+  SQLITE_IOCAP_POWERSAFE_OVERWRITE    = $00001000;
+  SQLITE_IOCAP_IMMUTABLE              = $00002000;
+
   SQLITE_LOCK_NONE          = 0;
   SQLITE_LOCK_SHARED        = 1;
   SQLITE_LOCK_RESERVED      = 2;
@@ -218,21 +253,46 @@ type
      xShmLock : function(f : psqlite3_file; offset: cint; n : cint; flags : cint) : cint; stdcall;
      xShmBarrier  : procedure (f : psqlite3_file); stdcall;
      xShmUnmap : function(f : psqlite3_file; deleteFlag : cint) : cint; stdcall;
-          (* Additional methods may be added in future releases *)
+     (* Methods above are valid for version 2 *)
+     xFetch : function(f: psqlite3_file; iOfst: sqlite3_int64; iAmt: cint; pp: PPointer) : cint; stdcall;
+     xUnfetch : function(f: psqlite3_file; iOfst: sqlite3_int64; p: Pointer) : cint; stdcall;
+     (* Methods above are valid for version 3 *)
+     (* Additional methods may be added in future releases *)
   end;
 
 const
-  SQLITE_FCNTL_LOCKSTATE        = 1;
-  SQLITE_GET_LOCKPROXYFILE      = 2;
-  SQLITE_SET_LOCKPROXYFILE      = 3;
-  SQLITE_LAST_ERRNO             = 4;
-  SQLITE_FCNTL_SIZE_HINT        = 5;
-  SQLITE_FCNTL_CHUNK_SIZE       = 6;
-  SQLITE_FCNTL_FILE_POINTER     = 7;
-  SQLITE_FCNTL_SYNC_OMITTED     = 8;
-  SQLITE_FCNTL_WIN32_AV_RETRY   = 9;
-  SQLITE_FCNTL_PERSIST_WAL      = 10;
-  SQLITE_FCNTL_OVERWRITE        = 11;
+  SQLITE_FCNTL_LOCKSTATE           = 1;
+  SQLITE_FCNTL_GET_LOCKPROXYFILE   = 2;
+  SQLITE_FCNTL_SET_LOCKPROXYFILE   = 3;
+  SQLITE_FCNTL_LAST_ERRNO          = 4;
+  SQLITE_FCNTL_SIZE_HINT           = 5;
+  SQLITE_FCNTL_CHUNK_SIZE          = 6;
+  SQLITE_FCNTL_FILE_POINTER        = 7;
+  SQLITE_FCNTL_SYNC_OMITTED        = 8;
+  SQLITE_FCNTL_WIN32_AV_RETRY      = 9;
+  SQLITE_FCNTL_PERSIST_WAL         = 10;
+  SQLITE_FCNTL_OVERWRITE           = 11;
+  SQLITE_FCNTL_VFSNAME             = 12;
+  SQLITE_FCNTL_POWERSAFE_OVERWRITE = 13;
+  SQLITE_FCNTL_PRAGMA              = 14;
+  SQLITE_FCNTL_BUSYHANDLER         = 15;
+  SQLITE_FCNTL_TEMPFILENAME        = 16;
+  SQLITE_FCNTL_MMAP_SIZE           = 18;
+  SQLITE_FCNTL_TRACE               = 19;
+  SQLITE_FCNTL_HAS_MOVED           = 20;
+  SQLITE_FCNTL_SYNC                = 21;
+  SQLITE_FCNTL_COMMIT_PHASETWO     = 22;
+  SQLITE_FCNTL_WIN32_SET_HANDLE    = 23;
+  SQLITE_FCNTL_WAL_BLOCK           = 24;
+  SQLITE_FCNTL_ZIPVFS              = 25;
+  SQLITE_FCNTL_RBU                 = 26;
+  SQLITE_FCNTL_VFS_POINTER         = 27;
+  SQLITE_FCNTL_JOURNAL_POINTER     = 28;
+
+  (* deprecated names *)
+  SQLITE_GET_LOCKPROXYFILE    = SQLITE_FCNTL_GET_LOCKPROXYFILE;
+  SQLITE_SET_LOCKPROXYFILE    = SQLITE_FCNTL_SET_LOCKPROXYFILE;
+  SQLITE_LAST_ERRNO           = SQLITE_FCNTL_LAST_ERRNO;
 
 type
   psqlite3_mutex = ^sqlite3_mutex;
@@ -335,10 +395,21 @@ Const
   SQLITE_CONFIG_GETPCACHE    = 15;
   SQLITE_CONFIG_LOG          = 16;
   SQLITE_CONFIG_URI          = 17;
+  SQLITE_CONFIG_PCACHE2      = 18;  (* sqlite3_pcache_methods2* *)
+  SQLITE_CONFIG_GETPCACHE2   = 19;  (* sqlite3_pcache_methods2* *)
+  SQLITE_CONFIG_COVERING_INDEX_SCAN = 20;  (* int *)
+  SQLITE_CONFIG_SQLLOG              = 21;  (* xSqllog, void* *)
+  SQLITE_CONFIG_MMAP_SIZE           = 22;  (* sqlite3_int64, sqlite3_int64 *)
+  SQLITE_CONFIG_WIN32_HEAPSIZE      = 23;  (* int nByte *)
+  SQLITE_CONFIG_PCACHE_HDRSZ        = 24;  (* int *psz *)
+  SQLITE_CONFIG_PMASZ               = 25;  (* unsigned int szPma *)
+  SQLITE_CONFIG_STMTJRNL_SPILL      = 26;  (* int nByte *)
 
   SQLITE_DBCONFIG_LOOKASIDE      = 1001;
   SQLITE_DBCONFIG_ENABLE_FKEY    = 1002;
   SQLITE_DBCONFIG_ENABLE_TRIGGER = 1003;
+  SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER = 1004;
+  SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION = 1005;
 
   
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_extended_result_codes{$IFDEF D}: function{$ENDIF}(db: psqlite3; onoff: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
@@ -369,8 +440,11 @@ type
 //char *sqlite3_snprintf(int,char*,const char*, ...);
 
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_malloc{$IFDEF D}: function{$ENDIF}(size: cint): pointer;cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_malloc64{$IFDEF D}: function{$ENDIF}(size: sqlite3_uint64): pointer;cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_realloc{$IFDEF D}: function{$ENDIF}(ptr: pointer; size: cint): pointer;cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_realloc64{$IFDEF D}: function{$ENDIF}(ptr: pointer; size: sqlite3_uint64): pointer;cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_free{$IFDEF D}: procedure{$ENDIF}(ptr: pointer);cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_msize{$IFDEF D}: function{$ENDIF}(ptr: pointer): sqlite3_uint64;cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_memory_used{$IFDEF D}: function{$ENDIF}(): sqlite3_int64; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_memory_highwater{$IFDEF D}: function{$ENDIF}(resetFlag: cint): sqlite3_int64; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
@@ -424,11 +498,12 @@ const
   SQLITE_FUNCTION             = 31;   (* Function Name   NULL            *)
   SQLITE_SAVEPOINT            = 32;   (* Operation       Savepoint Name  *)
   SQLITE_COPY                 =  0;   (* No longer used *)
+  SQLITE_RECURSIVE            = 33;   (* NULL            NULL            *)
 
 
 type
-  xTrace = procedure(user: pointer; s: pansichar); cdecl;
-  xProfile = procedure(user: pointer; s: pansichar; i: sqlite3_uint64); cdecl;
+  xTrace = procedure(user: pointer; s: pansichar); cdecl; deprecated;
+  xProfile = procedure(user: pointer; s: pansichar; i: sqlite3_uint64); cdecl; deprecated;
 
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_trace{$IFDEF D}: function{$ENDIF}(db: psqlite3; cb: xTrace; user: pointer): pointer; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_profile{$IFDEF D}: function{$ENDIF}(db: psqlite3; cb: xProfile; user: pointer): pointer; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
@@ -455,18 +530,15 @@ type
   zVfs: pansichar         (* Name of VFS module to use *)
 ): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 
-{$IFDEF S}
-function sqlite3_uri_parameter(zFilename : pansichar; zParam :pansichar) : pansichar;cdecl;external Sqlite3Lib;
-{$ENDIF}
-{$IFDEF D}
-var
- sqlite3_uri_parameter : function(zFilename : pansichar; zParam :pansichar) : pansichar;cdecl;
-{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_uri_parameter{$IFDEF D}: function{$ENDIF}(zFilename : pansichar; zParam: pansichar) : pansichar; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_uri_boolean{$IFDEF D}: function{$ENDIF}(zFile : pansichar; zParam :pansichar; bDefault: cint) : cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_uri_int64{$IFDEF D}: function{$ENDIF}(zFile : pansichar; zParam :pansichar; iDefault: sqlite3_int64) : sqlite3_int64; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_errcode{$IFDEF D}: function{$ENDIF}(db: psqlite3): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_extended_errcode{$IFDEF D}: function{$ENDIF}(db: psqlite3): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_errmsg{$IFDEF D}: function{$ENDIF}(db: psqlite3): pansichar; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_errmsg16{$IFDEF D}: function{$ENDIF}(db: psqlite3): pwidechar; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_errstr{$IFDEF D}: function{$ENDIF}(errCode: cint): pansichar; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 
 type
   ppsqlite3_stmt = ^psqlite3_stmt;
@@ -489,7 +561,8 @@ const
   SQLITE_LIMIT_LIKE_PATTERN_LENGTH       = 8;
   SQLITE_LIMIT_VARIABLE_NUMBER           = 9;
   SQLITE_LIMIT_TRIGGER_DEPTH             = 10;
-   
+  SQLITE_LIMIT_WORKER_THREADS            = 11;
+
 
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_prepare{$IFDEF D}: function{$ENDIF}(
   db: psqlite3;             (* Database handle *)
@@ -525,6 +598,7 @@ const
 
 
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_sql{$IFDEF D}: function{$ENDIF}(pStmt: psqlite3_stmt): pansichar; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_expanded_sql{$IFDEF D}: function{$ENDIF}(pStmt: psqlite3_stmt): pansichar; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 
 
 type
@@ -537,14 +611,17 @@ type
 
 
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_blob{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; N: cint; V: pointer; L: cint; D: sqlite3_destructor_type): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_blob64{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; N: cint; V: pointer; L: sqlite3_uint64; D: sqlite3_destructor_type): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_double{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; N: cint; V: cdouble): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_int{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; N: cint; V: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_int64{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; N: cint; V: sqlite3_int64): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_null{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; N: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_text{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; N: cint; V: pansichar; L: cint; D: sqlite3_destructor_type): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_text16{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; N: cint; V: pwidechar; L: cint; D: sqlite3_destructor_type): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_text64{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; N: cint; V: pansichar; L: sqlite3_uint64; D: sqlite3_destructor_type; encoding: cuchar): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_value{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; N: cint; V: psqlite3_value): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_zeroblob{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; N: cint; V: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_zeroblob64{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; N: cint; V: sqlite3_uint64): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_parameter_count{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_parameter_name{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; N: cint): pansichar; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_bind_parameter_index{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt; zName: pansichar): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
@@ -630,9 +707,11 @@ const
   SQLITE_UTF16LE        = 2;
   SQLITE_UTF16BE        = 3;
   SQLITE_UTF16          = 4;    (* Use native byte order *)
-  SQLITE_ANY            = 5;    (* sqlite3_create_function only *)
+  SQLITE_ANY            = 5;    (* Deprecated *)
   SQLITE_UTF16_ALIGNED  = 8;    (* sqlite3_create_collation only *)
 
+  SQLITE_DETERMINISTIC  = $800;
+
 {$IFDEF SQLITE_OBSOLETE}
 type
   memory_alarm_cb = function(user: pointer; i64: sqlite3_int64; i: cint): pointer; cdecl;
@@ -657,6 +736,10 @@ type
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_value_text16be{$IFDEF D}: function{$ENDIF}(val: psqlite3_value): pwidechar; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_value_type{$IFDEF D}: function{$ENDIF}(val: psqlite3_value): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_value_numeric_type{$IFDEF D}: function{$ENDIF}(val: psqlite3_value): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_value_subtype{$IFDEF D}: function{$ENDIF}(val: psqlite3_value): cuint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_value_dup{$IFDEF D}: function{$ENDIF}(val: psqlite3_value): psqlite3_value; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_value_free{$IFDEF D}: procedure{$ENDIF}(val: psqlite3_value); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_aggregate_context{$IFDEF D}: function{$ENDIF}(ctx: psqlite3_context; nBytes: cint): pointer; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_user_data{$IFDEF D}: function{$ENDIF}(ctx: psqlite3_context): pointer; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_context_db_handle{$IFDEF D}: function{$ENDIF}(ctx: psqlite3_context): psqlite3; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
@@ -668,6 +751,7 @@ type
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_get_auxdata{$IFDEF D}: function{$ENDIF}(ctx: psqlite3_context; N: cint): pointer; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_set_auxdata{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; N: cint; P: pointer; cb: set_auxdata_cb); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_blob{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; V: pointer; N: cint; D: sqlite3_destructor_type); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_blob64{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; V: pointer; N: sqlite3_uint64; D: sqlite3_destructor_type); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_double{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; V: cdouble); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_error{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; V: pansichar; N: cint); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_error16{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; V: pwidechar; N: cint); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
@@ -678,11 +762,13 @@ type
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_int64{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; V: sqlite3_int64); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_null{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_text{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; V: pansichar; N: cint; D: sqlite3_destructor_type); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_text64{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; V: pansichar; N: sqlite3_uint64; D: sqlite3_destructor_type; encoding: cuchar); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_text16{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; V: pwidechar; N: cint; D: sqlite3_destructor_type); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_text16le{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; V: pwidechar; N: cint; D: sqlite3_destructor_type); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_text16be{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; V: pwidechar; N: cint; D: sqlite3_destructor_type); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_value{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; V: psqlite3_value); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
-{$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_zeroblob{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; V: cint); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_result_zeroblob{$IFDEF D}: procedure{$ENDIF}(ctx: psqlite3_context; N: cint); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_result_zeroblob64{$IFDEF D}: function{$ENDIF}(ctx: psqlite3_context; N: sqlite3_uint64): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 
 type
   xCompare = function(user: pointer; A: cint; B: pointer; C: cint; D: pointer): cint; cdecl;
@@ -726,25 +812,39 @@ type
   user: pointer;
   cb: collation_needed_cb
 ): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_key{$IFDEF D}: function{$ENDIF}(
   db: psqlite3;                   (* Database to be rekeyed *)
   pKey: pointer; nKey: cint       (* The key *)
 ): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_key_v2{$IFDEF D}: function{$ENDIF}(
+  db: psqlite3;                   (* Database to be rekeyed *)
+  zDbName: pansichar;             (* Name of the database *)
+  pKey: pointer; nKey: cint       (* The key *)
+): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_rekey{$IFDEF D}: function{$ENDIF}(
   db: psqlite3;                   (* Database to be rekeyed *)
   pKey: pointer; nKey: cint       (* The new key *)
 ): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_rekey_v2{$IFDEF D}: function{$ENDIF}(
+  db: psqlite3;                   (* Database to be rekeyed *)
+  zDbName: pansichar;             (* Name of the database *)
+  pKey: pointer; nKey: cint       (* The new key *)
+): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_sleep{$IFDEF D}: function{$ENDIF}(M: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 
 
 {$ifndef win32}
 var
   sqlite3_temp_directory: pansichar; cvar; external {Sqlite3Lib};
+  sqlite3_data_directory: pansichar; cvar; external {Sqlite3Lib};
 {$endif}
 
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_get_autocommit{$IFDEF D}: function{$ENDIF}(db: psqlite3): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_db_handle{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt): psqlite3; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
-{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_next_stmt{$IFDEF D}: function{$ENDIF}(db: psqlite3;stmt: psqlite3_stmt):psqlite3_stmt;cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF} 
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_db_filename{$IFDEF D}: function{$ENDIF}(db: psqlite3; zDbName: pansichar): pansichar; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_db_readonly{$IFDEF D}: function{$ENDIF}(db: psqlite3; zDbName: pansichar): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_next_stmt{$IFDEF D}: function{$ENDIF}(db: psqlite3;stmt: psqlite3_stmt):psqlite3_stmt;cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
  
 type
   commit_callback = function(user: pointer): cint; cdecl;
@@ -757,6 +857,7 @@ type
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_update_hook{$IFDEF D}: function{$ENDIF}(db: psqlite3; cb: update_callback; user: pointer): pointer; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_enable_shared_cache{$IFDEF D}: function{$ENDIF}(B: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_release_memory{$IFDEF D}: function{$ENDIF}(N: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_db_release_memory{$IFDEF D}: function{$ENDIF}(db: psqlite3): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_soft_heap_limit{$IFDEF D}: procedure{$ENDIF}(N: cint); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_soft_heap_limit64{$IFDEF D}: function{$ENDIF}(N: int64):int64;cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
  
@@ -780,6 +881,7 @@ type
 ): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_enable_load_extension{$IFDEF D}: function{$ENDIF}(db: psqlite3; onoff: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_auto_extension{$IFDEF D}: function{$ENDIF}(xEntrypoint: pointer): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_cancel_auto_extension{$IFDEF D}: function{$ENDIF}(xEntrypoint: pointer): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}procedure{$ELSE}var{$ENDIF}sqlite3_reset_auto_extension{$IFDEF D}: procedure{$ENDIF}(); cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 
 
@@ -819,7 +921,7 @@ type
 type
   psqlite3_index_constracint = ^sqlite3_index_constracint;
   sqlite3_index_constracint = record
-     iColumn: cint;              (* Column on left-hand side of constracint *)
+     iColumn: cint;              (* Column constrained.  -1 for ROWID *)
      op: char;                   (* Constracint operator *)
      usable: char;               (* True if this constracint is usable *)
      iTermOffset: cint;          (* Used cinternally - xBestIndex should ignore *)
@@ -839,29 +941,39 @@ type
 
   psqlite3_index_info = ^sqlite3_index_info;
   sqlite3_index_info = record
-  (* Inputs *)
+    (* Inputs *)
     nConstracint: cint;         (* Number of entries in aConstracint *)
     aConstracint: psqlite3_index_constracint;
     nOrderBy: cint;             (* Number of terms in the ORDER BY clause *)
     aOrderBy: psqlite3_index_orderby;
 
-  (* Outputs *)
+    (* Outputs *)
     aConstracintUsage: psqlite3_index_constracint_usage;
 
-    idxNum: cint;               (* Number used to identify the index *)
-    idxStr: pansichar;          (* String; possibly obtained from sqlite3_malloc *)
-    needToFreeIdxStr: cint;     (* Free idxStr using sqlite3_free() if true *)
-    orderByConsumed: cint;      (* True if output is already ordered *)
-    estimatedCost: cdouble;     (* Estimated cost of using this index *)
+    idxNum: cint;                 (* Number used to identify the index *)
+    idxStr: pansichar;            (* String; possibly obtained from sqlite3_malloc *)
+    needToFreeIdxStr: cint;       (* Free idxStr using sqlite3_free() if true *)
+    orderByConsumed: cint;        (* True if output is already ordered *)
+    estimatedCost: cdouble;       (* Estimated cost of using this index *)
+    (* Fields below are only available in SQLite 3.8.2 and later *)
+    estimatedRows: sqlite3_int64; (* Estimated number of rows returned *)
+    (* Fields below are only available in SQLite 3.9.0 and later *)
+    idxFlags: cint ;              (* Mask of SQLITE_INDEX_SCAN_* flags *)
+    (* Fields below are only available in SQLite 3.10.0 and later *)
+    colUsed: sqlite3_uint64;      (* Input: Mask of columns used by statement *)
   end;
 
 const
+  SQLITE_INDEX_SCAN_UNIQUE      = 1;
   SQLITE_INDEX_CONSTRAINT_EQ    = 2;
   SQLITE_INDEX_CONSTRAINT_GT    = 4;
   SQLITE_INDEX_CONSTRAINT_LE    = 8;
   SQLITE_INDEX_CONSTRAINT_LT    = 16;
   SQLITE_INDEX_CONSTRAINT_GE    = 32;
   SQLITE_INDEX_CONSTRAINT_MATCH = 64;
+  SQLITE_INDEX_CONSTRAINT_LIKE  = 65;
+  SQLITE_INDEX_CONSTRAINT_GLOB  = 66;
+  SQLITE_INDEX_CONSTRAINT_REGEXP= 67;
 
 
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_create_module{$IFDEF D}: function{$ENDIF}(
@@ -942,14 +1054,16 @@ const
   SQLITE_MUTEX_STATIC_PRNG      = 5;  (* sqlite3_random() *)
   SQLITE_MUTEX_STATIC_LRU       = 6;  (* lru page list *)
   SQLITE_MUTEX_STATIC_LRU2      = 7;  (* lru page list *)
+  SQLITE_MUTEX_STATIC_APP1      = 8;  (* For use by application *)
+  SQLITE_MUTEX_STATIC_APP2      = 9;  (* For use by application *)
+  SQLITE_MUTEX_STATIC_APP3      = 10; (* For use by application *)
+  SQLITE_MUTEX_STATIC_VFS1      = 11; (* For use by built-in VFS *)
+  SQLITE_MUTEX_STATIC_VFS2      = 12; (* For use by extension VFS *)
+  SQLITE_MUTEX_STATIC_VFS3      = 13; (* For use by application VFS *)
 
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_file_control{$IFDEF D}: function{$ENDIF}(db: psqlite3; zDbName: pansichar; op: cint; p: pointer): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 {$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_test_control{$IFDEF D}: function{$ENDIF}(op: cint; args: array of const): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 
-{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_status{$IFDEF D}: function{$ENDIF}(op: cint; pcurrent:pcint; pHighwater: pcint; resetFlag: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
-{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_db_status{$IFDEF D}: function{$ENDIF}(db : psqlite3;op: cint; pcurrent:pcint; pHighwater: pcint; resetFlag: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
-{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_stmt_status{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt;op: cint; pcurrent:pcint; pHighwater: pcint; resetFlag: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
-
 const
   SQLITE_TESTCTRL_FAULT_CONFIG             = 1;
   SQLITE_TESTCTRL_FAULT_FAILURES           = 2;
@@ -959,6 +1073,55 @@ const
   SQLITE_TESTCTRL_PRNG_RESTORE             = 6;
   SQLITE_TESTCTRL_PRNG_RESET               = 7;
   SQLITE_TESTCTRL_BITVEC_TEST              = 8;
+  SQLITE_TESTCTRL_FAULT_INSTALL            = 9;
+  SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS      = 10;
+  SQLITE_TESTCTRL_PENDING_BYTE             = 11;
+  SQLITE_TESTCTRL_ASSERT                   = 12;
+  SQLITE_TESTCTRL_ALWAYS                   = 13;
+  SQLITE_TESTCTRL_RESERVE                  = 14;
+  SQLITE_TESTCTRL_OPTIMIZATIONS            = 15;
+  SQLITE_TESTCTRL_ISKEYWORD                = 16;
+  SQLITE_TESTCTRL_SCRATCHMALLOC            = 17;
+  SQLITE_TESTCTRL_LOCALTIME_FAULT          = 18;
+  SQLITE_TESTCTRL_EXPLAIN_STMT             = 19;  (* NOT USED *)
+  SQLITE_TESTCTRL_NEVER_CORRUPT            = 20;
+  SQLITE_TESTCTRL_VDBE_COVERAGE            = 21;
+  SQLITE_TESTCTRL_BYTEORDER                = 22;
+  SQLITE_TESTCTRL_ISINIT                   = 23;
+  SQLITE_TESTCTRL_SORTER_MMAP              = 24;
+  SQLITE_TESTCTRL_IMPOSTER                 = 25;
+  SQLITE_TESTCTRL_LAST                     = 25;
+
+
+  SQLITE_STATUS_MEMORY_USED          = 0;
+  SQLITE_STATUS_PAGECACHE_USED       = 1;
+  SQLITE_STATUS_PAGECACHE_OVERFLOW   = 2;
+  SQLITE_STATUS_SCRATCH_USED         = 3;
+  SQLITE_STATUS_SCRATCH_OVERFLOW     = 4;
+  SQLITE_STATUS_MALLOC_SIZE          = 5;
+  SQLITE_STATUS_PARSER_STACK         = 6;
+  SQLITE_STATUS_PAGECACHE_SIZE       = 7;
+  SQLITE_STATUS_SCRATCH_SIZE         = 8;
+  SQLITE_STATUS_MALLOC_COUNT         = 9;
+
+  SQLITE_DBSTATUS_LOOKASIDE_USED      = 0;
+  SQLITE_DBSTATUS_CACHE_USED          = 1;
+  SQLITE_DBSTATUS_SCHEMA_USED         = 2;
+  SQLITE_DBSTATUS_STMT_USED           = 3;
+  SQLITE_DBSTATUS_LOOKASIDE_HIT       = 4;
+  SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE = 5;
+  SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL = 6;
+  SQLITE_DBSTATUS_CACHE_HIT           = 7;
+  SQLITE_DBSTATUS_CACHE_MISS          = 8;
+  SQLITE_DBSTATUS_CACHE_WRITE         = 9;
+  SQLITE_DBSTATUS_DEFERRED_FKS        = 10;
+  SQLITE_DBSTATUS_CACHE_USED_SHARED   = 11;
+  SQLITE_DBSTATUS_MAX                 = 11;   (* Largest defined DBSTATUS *)
+
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_status{$IFDEF D}: function{$ENDIF}(op: cint; pCurrent: pcint; pHighwater: pcint; resetFlag: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_status64{$IFDEF D}: function{$ENDIF}(op: cint; pCurrent: psqlite3_int64; pHighwater: psqlite3_int64; resetFlag: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_db_status{$IFDEF D}: function{$ENDIF}(db : psqlite3;op: cint; pCurrent:pcint; pHighwater: pcint; resetFlag: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF}sqlite3_stmt_status{$IFDEF D}: function{$ENDIF}(stmt: psqlite3_stmt;op: cint; pcurrent:pcint; pHighwater: pcint; resetFlag: cint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 
 
 {Backup api}
@@ -984,7 +1147,17 @@ Type
 {$IFDEF S}function{$ELSE}var{$ENDIF} sqlite3_wal_autocheckpoint{$IFDEF D}: function{$ENDIF}(db:psqlite3;n : cint): cint;cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF} 
 {$IFDEF S}function{$ELSE}var{$ENDIF} sqlite3_wal_checkpoint{$IFDEF D}: function{$ENDIF}(db:psqlite3;zDB: pansichar): cint;cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF} 
 {$IFDEF S}function{$ELSE}var{$ENDIF} sqlite3_wal_checkpoint_v2{$IFDEF D}: function{$ENDIF}(db:psqlite3;zDB: pansichar;emode:cint;nLog:pcint;nCkpt:pcint): cint;cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF} 
-                             
+
+Const
+  SQLITE_CHECKPOINT_PASSIVE  = 0;  (* Do as much as possible w/o blocking *)
+  SQLITE_CHECKPOINT_FULL     = 1;  (* Wait for writers, then checkpoint *)
+  SQLITE_CHECKPOINT_RESTART  = 2;  (* Like FULL but wait for for readers *)
+  SQLITE_CHECKPOINT_TRUNCATE = 3;  (* Like RESTART but also truncate WAL *)
+
+
+{String handling api}
+{$IFDEF S}function{$ELSE}var{$ENDIF} sqlite3_strglob {$IFDEF D}:function{$ENDIF}(zGlob, zStr: pansichar): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
+{$IFDEF S}function{$ELSE}var{$ENDIF} sqlite3_strlike {$IFDEF D}:function{$ENDIF}(zGlob, zStr: pansichar; cEsc: cuint): cint; cdecl;{$IFDEF S}external Sqlite3Lib;{$ENDIF}
 
 {$IFDEF LOAD_DYNAMICALLY}
 
@@ -1022,6 +1195,7 @@ begin
   pointer(sqlite3_libversion_number) := GetProcedureAddress(LibHandle,'sqlite3_libversion_number');
   pointer(sqlite3_threadsafe) := GetProcedureAddress(LibHandle,'sqlite3_threadsafe');
   pointer(sqlite3_close) := GetProcedureAddress(LibHandle,'sqlite3_close');
+  pointer(sqlite3_close_v2) := GetProcedureAddress(LibHandle,'sqlite3_close_v2');
   pointer(sqlite3_exec) := GetProcedureAddress(LibHandle,'sqlite3_exec');
   pointer(sqlite3_extended_result_codes) := GetProcedureAddress(LibHandle,'sqlite3_extended_result_codes');
   pointer(sqlite3_last_insert_rowid) := GetProcedureAddress(LibHandle,'sqlite3_last_insert_rowid');
@@ -1046,21 +1220,26 @@ begin
   pointer(sqlite3_extended_errcode) := GetProcedureAddress(LibHandle,'sqlite3_extended_errcode');
   pointer(sqlite3_errmsg) := GetProcedureAddress(LibHandle,'sqlite3_errmsg');
   pointer(sqlite3_errmsg16) := GetProcedureAddress(LibHandle,'sqlite3_errmsg16');
+  pointer(sqlite3_errstr) := GetProcedureAddress(LibHandle,'sqlite3_errstr');
   pointer(sqlite3_limit) := GetProcedureAddress(LibHandle,'sqlite3_limit');
   pointer(sqlite3_prepare) := GetProcedureAddress(LibHandle,'sqlite3_prepare');
   pointer(sqlite3_prepare_v2) := GetProcedureAddress(LibHandle,'sqlite3_prepare_v2');
   pointer(sqlite3_prepare16) := GetProcedureAddress(LibHandle,'sqlite3_prepare16');
   pointer(sqlite3_prepare16_v2) := GetProcedureAddress(LibHandle,'sqlite3_prepare16_v2');
   pointer(sqlite3_sql) := GetProcedureAddress(LibHandle,'sqlite3_sql');
+  pointer(sqlite3_expanded_sql) := GetProcedureAddress(LibHandle,'sqlite3_expanded_sql');
   pointer(sqlite3_bind_blob) := GetProcedureAddress(LibHandle,'sqlite3_bind_blob');
+  pointer(sqlite3_bind_blob64) := GetProcedureAddress(LibHandle,'sqlite3_bind_blob64');
   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_text64) := GetProcedureAddress(LibHandle,'sqlite3_bind_text64');
   pointer(sqlite3_bind_text16) := GetProcedureAddress(LibHandle,'sqlite3_bind_text16');
   pointer(sqlite3_bind_value) := GetProcedureAddress(LibHandle,'sqlite3_bind_value');
   pointer(sqlite3_bind_zeroblob) := GetProcedureAddress(LibHandle,'sqlite3_bind_zeroblob');
+  pointer(sqlite3_bind_zeroblob64) := GetProcedureAddress(LibHandle,'sqlite3_bind_zeroblob64');
   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');
@@ -1105,6 +1284,7 @@ begin
   pointer(sqlite3_value_text16be) := GetProcedureAddress(LibHandle,'sqlite3_value_text16be');
   pointer(sqlite3_value_type) := GetProcedureAddress(LibHandle,'sqlite3_value_type');
   pointer(sqlite3_value_numeric_type) := GetProcedureAddress(LibHandle,'sqlite3_value_numeric_type');
+  pointer(sqlite3_value_subtype) := GetProcedureAddress(LibHandle,'sqlite3_value_subtype');
   pointer(sqlite3_aggregate_context) := GetProcedureAddress(LibHandle,'sqlite3_aggregate_context');
   pointer(sqlite3_user_data) := GetProcedureAddress(LibHandle,'sqlite3_user_data');
   pointer(sqlite3_context_db_handle) := GetProcedureAddress(LibHandle,'sqlite3_context_db_handle');
@@ -1115,7 +1295,9 @@ begin
   pointer(sqlite3_collation_needed) := GetProcedureAddress(LibHandle,'sqlite3_collation_needed');
   pointer(sqlite3_collation_needed16) := GetProcedureAddress(LibHandle,'sqlite3_collation_needed16');
   pointer(sqlite3_key) := GetProcedureAddress(LibHandle,'sqlite3_key');
+  pointer(sqlite3_key_v2) := GetProcedureAddress(LibHandle,'sqlite3_key_v2');
   pointer(sqlite3_rekey) := GetProcedureAddress(LibHandle,'sqlite3_rekey');
+  pointer(sqlite3_rekey_v2) := GetProcedureAddress(LibHandle,'sqlite3_rekey_v2');
   pointer(sqlite3_sleep) := GetProcedureAddress(LibHandle,'sqlite3_sleep');
   pointer(sqlite3_get_autocommit) := GetProcedureAddress(LibHandle,'sqlite3_get_autocommit');
   pointer(sqlite3_db_handle) := GetProcedureAddress(LibHandle,'sqlite3_db_handle');
@@ -1149,6 +1331,7 @@ begin
   pointer(sqlite3_file_control) := GetProcedureAddress(LibHandle,'sqlite3_file_control');
   pointer(sqlite3_test_control) := GetProcedureAddress(LibHandle,'sqlite3_test_control');
   pointer(sqlite3_status) := GetProcedureAddress(LibHandle,'sqlite3_status');
+  pointer(sqlite3_status64) := GetProcedureAddress(LibHandle,'sqlite3_status64');
   pointer(sqlite3_db_status) := GetProcedureAddress(LibHandle,'sqlite3_db_status');
   pointer(sqlite3_stmt_status) := GetProcedureAddress(LibHandle,'sqlite3_stmt_status');
   pointer(sqlite3_interrupt) := GetProcedureAddress(LibHandle,'sqlite3_interrupt');
@@ -1158,6 +1341,7 @@ begin
   pointer(sqlite3_progress_handler) := GetProcedureAddress(LibHandle,'sqlite3_progress_handler');
   pointer(sqlite3_set_auxdata) := GetProcedureAddress(LibHandle,'sqlite3_set_auxdata');
   pointer(sqlite3_result_blob) := GetProcedureAddress(LibHandle,'sqlite3_result_blob');
+  pointer(sqlite3_result_blob64) := GetProcedureAddress(LibHandle,'sqlite3_result_blob64');
   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');
@@ -1168,11 +1352,13 @@ begin
   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_text64) := GetProcedureAddress(LibHandle,'sqlite3_result_text64');
   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_result_zeroblob) := GetProcedureAddress(LibHandle,'sqlite3_result_zeroblob');
+  pointer(sqlite3_result_zeroblob64) := GetProcedureAddress(LibHandle,'sqlite3_result_zeroblob64');
   pointer(sqlite3_soft_heap_limit) := GetProcedureAddress(LibHandle,'sqlite3_soft_heap_limit');
   pointer(sqlite3_soft_heap_limit64) := GetProcedureAddress(LibHandle,'sqlite3_soft_heap_limit64');
   pointer(sqlite3_reset_auto_extension) := GetProcedureAddress(LibHandle,'sqlite3_reset_auto_extension');
@@ -1190,7 +1376,7 @@ begin
   pointer(sqlite3_wal_autocheckpoint) := GetProcedureAddress(LibHandle,'sqlite3_wal_autocheckpoint');
   pointer(sqlite3_wal_checkpoint) := GetProcedureAddress(LibHandle,'sqlite3_wal_checkpoint');
   pointer(sqlite3_wal_checkpoint_v2) := GetProcedureAddress(LibHandle,'sqlite3_wal_checkpoint_v2');
-  
+  pointer(sqlite3_strlike) := GetProcedureAddress(LibHandle,'sqlite3_strlike');
    
   pointer(sqlite3_initialize) := GetProcedureAddress(LibHandle,'sqlite3_initialize');
   pointer(sqlite3_shutdown) := GetProcedureAddress(LibHandle,'sqlite3_shutdown');