You did great work with prepared statement. Ive tried to optimizing a bit on the usability.
Code: Select all
; ======================================================================================================================
; Function: Class definitions as wrappers for SQLite3.dll to work with SQLite DBs.
; AHK version: 1.1.33.09
; Tested on: Win 10 Pro (x64), SQLite 3.11.1
; Version: 0.0.01.00/2011-08-10/just me
; 0.0.02.00/2012-08-10/just me - Added basic BLOB support
; 0.0.03.00/2012-08-11/just me - Added more advanced BLOB support
; 0.0.04.00/2013-06-29/just me - Added new methods AttachDB and DetachDB
; 0.0.05.00/2013-08-03/just me - Changed base class assignment
; 0.0.06.00/2016-01-28/just me - Fixed version check, revised parameter initialization.
; 0.0.07.00/2016-03-28/just me - Added support for PRAGMA statements.
; 0.0.08.00/2019-03-09/just me - Added basic support for application-defined functions
; 0.0.09.00/2019-07-09/just me - Added basic support for prepared statements, minor bug fixes
; 0.0.10.00/2019-12-12/just me - Fixed bug in EscapeStr method
; 0.0.11.00/2021-10-10/just me - Removed statement checks in GetTable, Prepare, and Query
; 0.0.12.00/2022-09-18/just me - Fixed bug for Bind - type text
; 0.0.13.00/2022-10-03/just me - Fixed bug in Prepare
; 0.0.14.00/2022-10-04/just me - Changed DllCall parameter type PtrP to UPtrP
; Remarks: Names of "private" properties / methods are prefixed with an underscore,
; they must not be set / called by the script!
;
; SQLite3.dll file is assumed to be in the script's folder, otherwise you have to
; provide an INI-File SQLiteDB.ini in the script's folder containing the path:
; [Main]
; DllPath=Path to SQLite3.dll
;
; Encoding of SQLite DBs is assumed to be UTF-8
; Minimum supported SQLite3.dll version is 3.6
; Download the current version of SQLite3.dll (and also SQlite3.exe) from www.sqlite.org
; ======================================================================================================================
; This software is provided 'as-is', without any express or implied warranty.
; In no event will the authors be held liable for any damages arising from the
; use of this software.
; ======================================================================================================================
; CLASS SQliteDB - SQLiteDB main class
; ======================================================================================================================
Class SQLiteDB {
; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; PRIVATE Properties and Methods ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Static Version := ""
Static _SQLiteDLL := "C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll"
Static _RefCount := 0
Static _MinVersion := "3.6"
; ===================================================================================================================
; CLASS _Table
; Object returned from method GetTable()
; _Table is an independent object and does not need SQLite after creation at all.
; ===================================================================================================================
Class _Table {
; ----------------------------------------------------------------------------------------------------------------
; CONSTRUCTOR Create instance variables
; ----------------------------------------------------------------------------------------------------------------
__New() {
This.ColumnCount := 0 ; Number of columns in the result table (Integer)
This.RowCount := 0 ; Number of rows in the result table (Integer)
This.ColumnNames := [] ; Names of columns in the result table (Array)
This.Rows := [] ; Rows of the result table (Array of Arrays)
This.HasNames := False ; Does var ColumnNames contain names? (Bool)
This.HasRows := False ; Does var Rows contain rows? (Bool)
This._CurrentRow := 0 ; Row index of last returned row (Integer)
}
; ----------------------------------------------------------------------------------------------------------------
; METHOD GetRow Get row for RowIndex
; Parameters: RowIndex - Index of the row to retrieve, the index of the first row is 1
; ByRef Row - Variable to pass out the row array
; Return values: On failure - False
; On success - True, Row contains a valid array
; Remarks: _CurrentRow is set to RowIndex, so a subsequent call of NextRow() will return the
; following row.
; ----------------------------------------------------------------------------------------------------------------
GetRow(RowIndex, ByRef Row) {
Row := ""
If (RowIndex < 1 || RowIndex > This.RowCount)
Return False
If !This.Rows.HasKey(RowIndex)
Return False
Row := This.Rows[RowIndex]
This._CurrentRow := RowIndex
Return True
}
; ----------------------------------------------------------------------------------------------------------------
; METHOD Next Get next row depending on _CurrentRow
; Parameters: ByRef Row - Variable to pass out the row array
; Return values: On failure - False, -1 for EOR (end of rows)
; On success - True, Row contains a valid array
; ----------------------------------------------------------------------------------------------------------------
Next(ByRef Row) {
Row := ""
If (This._CurrentRow >= This.RowCount)
Return -1
This._CurrentRow += 1
If !This.Rows.HasKey(This._CurrentRow)
Return False
Row := This.Rows[This._CurrentRow]
Return True
}
; ----------------------------------------------------------------------------------------------------------------
; METHOD Reset Reset _CurrentRow to zero
; Parameters: None
; Return value: True
; ----------------------------------------------------------------------------------------------------------------
Reset() {
This._CurrentRow := 0
Return True
}
}
; ===================================================================================================================
; CLASS _RecordSet
; Object returned from method Query()
; The records (rows) of a recordset can be accessed sequentially per call of Next() starting with the first record.
; After a call of Reset() calls of Next() will start with the first record again.
; When the recordset isn't needed any more, call Free() to free the resources.
; The lifetime of a recordset depends on the lifetime of the related SQLiteDB object.
; ===================================================================================================================
Class _RecordSet {
; ----------------------------------------------------------------------------------------------------------------
; CONSTRUCTOR Create instance variables
; ----------------------------------------------------------------------------------------------------------------
__New() {
This.ColumnCount := 0 ; Number of columns (Integer)
This.ColumnNames := [] ; Names of columns in the result table (Array)
This.HasNames := False ; Does var ColumnNames contain names? (Bool)
This.HasRows := False ; Does _RecordSet contain rows? (Bool)
This.CurrentRow := 0 ; Index of current row (Integer)
This.ErrorMsg := "" ; Last error message (String)
This.ErrorCode := 0 ; Last SQLite error code / ErrorLevel (Variant)
This._Handle := 0 ; Query handle (Pointer)
This._DB := {} ; SQLiteDB object (Object)
}
; ----------------------------------------------------------------------------------------------------------------
; DESTRUCTOR Clear instance variables
; ----------------------------------------------------------------------------------------------------------------
__Delete() {
If (This._Handle)
This.Free()
}
; ----------------------------------------------------------------------------------------------------------------
; METHOD Next Get next row of query result
; Parameters: ByRef Row - Variable to store the row array
; Return values: On success - True, Row contains the row array
; On failure - False, ErrorMsg / ErrorCode contain additional information
; -1 for EOR (end of records)
; ----------------------------------------------------------------------------------------------------------------
Next(ByRef Row) {
Static SQLITE_NULL := 5
Static SQLITE_BLOB := 4
Static EOR := -1
Row := ""
This.ErrorMsg := ""
This.ErrorCode := 0
If !(This._Handle) {
This.ErrorMsg := "Invalid query handle!"
Return False
}
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_step", "Ptr", This._Handle, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_step failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC <> This._DB._ReturnCode("SQLITE_ROW")) {
If (RC = This._DB._ReturnCode("SQLITE_DONE")) {
This.ErrorMsg := "EOR"
This.ErrorCode := RC
Return EOR
}
This.ErrorMsg := This._DB.ErrMsg()
This.ErrorCode := RC
Return False
}
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_data_count", "Ptr", This._Handle, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_data_count failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC < 1) {
This.ErrorMsg := "Recordset is empty!"
This.ErrorCode := This._DB._ReturnCode("SQLITE_EMPTY")
Return False
}
Row := []
Loop, %RC% {
Column := A_Index - 1
ColumnType := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_column_type", "Ptr", This._Handle, "Int", Column, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_column_type failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (ColumnType = SQLITE_NULL) {
Row[A_Index] := ""
} Else If (ColumnType = SQLITE_BLOB) {
BlobPtr := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_column_blob", "Ptr", This._Handle, "Int", Column, "Cdecl UPtr")
BlobSize := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_column_bytes", "Ptr", This._Handle, "Int", Column, "Cdecl Int")
If (BlobPtr = 0) || (BlobSize = 0) {
Row[A_Index] := ""
} Else {
Row[A_Index] := {}
Row[A_Index].Size := BlobSize
Row[A_Index].Blob := ""
Row[A_Index].SetCapacity("Blob", BlobSize)
Addr := Row[A_Index].GetAddress("Blob")
DllCall("Kernel32.dll\RtlMoveMemory", "Ptr", Addr, "Ptr", BlobPtr, "Ptr", BlobSize)
}
} Else {
StrPtr := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_column_text", "Ptr", This._Handle, "Int", Column, "Cdecl UPtr")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_column_text failed!"
This.ErrorCode := ErrorLevel
Return False
}
Row[A_Index] := StrGet(StrPtr, "UTF-8")
}
}
This.CurrentRow += 1
Return True
}
; ----------------------------------------------------------------------------------------------------------------
; METHOD Reset Reset the result pointer
; Parameters: None
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; Remarks: After a call of this method you can access the query result via Next() again.
; ----------------------------------------------------------------------------------------------------------------
Reset() {
This.ErrorMsg := ""
This.ErrorCode := 0
If !(This._Handle) {
This.ErrorMsg := "Invalid query handle!"
Return False
}
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_reset", "Ptr", This._Handle, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_reset failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := This._DB._ErrMsg()
This.ErrorCode := RC
Return False
}
This.CurrentRow := 0
Return True
}
; ----------------------------------------------------------------------------------------------------------------
; METHOD Free Free query result
; Parameters: None
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; Remarks: After the call of this method further access on the query result is impossible.
; ----------------------------------------------------------------------------------------------------------------
Free() {
This.ErrorMsg := ""
This.ErrorCode := 0
If !(This._Handle)
Return True
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_finalize", "Ptr", This._Handle, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_finalize failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := This._DB._ErrMsg()
This.ErrorCode := RC
Return False
}
This._DB._Queries.Delete(This._Handle)
This._Handle := 0
This._DB := 0
Return True
}
}
; ===================================================================================================================
; CLASS _Statement
; Object returned from method Prepare()
; The life-cycle of a prepared statement object usually goes like this:
; 1. Create the prepared statement object (PST) by calling DB.Prepare().
; 2. Bind values to parameters using the PST.Bind_*() methods of the statement object.
; 3. Run the SQL by calling PST.Step() one or more times.
; 4. Reset the prepared statement using PTS.Reset() then go back to step 2. Do this zero or more times.
; 5. Destroy the object using PST.Finalize().
; The lifetime of a prepared statement depends on the lifetime of the related SQLiteDB object.
; ===================================================================================================================
Class _Statement {
; ----------------------------------------------------------------------------------------------------------------
; CONSTRUCTOR Create instance variables
; ----------------------------------------------------------------------------------------------------------------
__New() {
This.ErrorMsg := "" ; Last error message (String)
This.ErrorCode := 0 ; Last SQLite error code / ErrorLevel (Variant)
This.ParamCount := 0 ; Number of SQL parameters for this statement (Integer)
This._Handle := 0 ; Query handle (Pointer)
This._DB := {} ; SQLiteDB object (Object)
This._TL := [] ; type list array (array)
}
; ----------------------------------------------------------------------------------------------------------------
; DESTRUCTOR Clear instance variables
; ----------------------------------------------------------------------------------------------------------------
__Delete() {
If (This._Handle)
This.Free()
}
; ----------------------------------------------------------------------------------------------------------------
; METHOD Bind Bind values to SQL parameters.
; Parameters: Index - 1-based index of the SQL parameter
; Type - type of the SQL parameter (currently: Blob/Double/Int/Text)
; Param3 - type dependent value
; Param4 - type dependent value
; Param5 - not used
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; ----------------------------------------------------------------------------------------------------------------
Bind(Index, Type, Param3 := "", Param4 := 0, Param5 := 0) {
Static SQLITE_STATIC := 0
Static SQLITE_TRANSIENT := -1
Static Types := {Blob: 1, Double: 1, Int: 1, Text: 1}
This.ErrorMsg := ""
This.ErrorCode := 0
If !(This._Handle) {
This.ErrorMsg := "Invalid statement handle!"
Return False
}
If (Index < 1) || (Index > This.ParamCount) {
This.ErrorMsg := "Invalid parameter index!"
Return False
}
If (Types[Type] = "") {
This.ErrorMsg := "Invalid parameter type!"
Return False
}
If (Type = "Blob") { ; ----------------------------------------------------------------------------------------
; Param3 = BLOB pointer, Param4 = BLOB size in bytes
If Param3 Is Not Integer
{
This.ErrorMsg := "Invalid blob pointer!"
Return False
}
If Param4 Is Not Integer
{
This.ErrorMsg := "Invalid blob size!"
Return False
}
; Let SQLite always create a copy of the BLOB
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_bind_blob", "Ptr", This._Handle, "Int", Index, "Ptr", Param3
, "Int", Param4, "Ptr", -1, "Cdecl Int")
If (ErrorLeveL) {
This.ErrorMsg := "DllCall sqlite3_bind_blob failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := This._ErrMsg()
This.ErrorCode := RC
Return False
}
}
Else If (Type = "Double") { ; ---------------------------------------------------------------------------------
; Param3 = double value
If Param3 Is Not Float
{
This.ErrorMsg := "Invalid value for double!"
Return False
}
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_bind_double", "Ptr", This._Handle, "Int", Index, "Double", Param3
, "Cdecl Int")
If (ErrorLeveL) {
This.ErrorMsg := "DllCall sqlite3_bind_double failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := This._ErrMsg()
This.ErrorCode := RC
Return False
}
}
Else If (Type = "Int") { ; ------------------------------------------------------------------------------------
; Param3 = integer value
If Param3 Is Not Integer
{
This.ErrorMsg := "Invalid value for int!"
Return False
}
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_bind_int", "Ptr", This._Handle, "Int", Index, "Int", Param3
, "Cdecl Int")
If (ErrorLeveL) {
This.ErrorMsg := "DllCall sqlite3_bind_int failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := This._ErrMsg()
This.ErrorCode := RC
Return False
}
}
Else If (Type = "Text") { ; -----------------------------------------------------------------------------------
; Param3 = zero-terminated string
This._DB._StrToUTF8(Param3, UTF8)
; Let SQLite always create a copy of the text
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_bind_text", "Ptr", This._Handle, "Int", Index, "Ptr", &UTF8
, "Int", -1, "Ptr", -1, "Cdecl Int")
If (ErrorLeveL) {
This.ErrorMsg := "DllCall sqlite3_bind_text failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := This._ErrMsg()
This.ErrorCode := RC
Return False
}
}
Return True
}
; ----------------------------------------------------------------------------------------------------------------
; METHOD Step Evaluate the prepared statement.
; Parameters: [ value1, value2, .. valueN]
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; Remarks: You must call ST.Reset() before you can call ST.Step() again.
; ----------------------------------------------------------------------------------------------------------------
Steps( params ) {
for k,v in params
{
This.Step( v)
}
Return True
}
Step( params ) {
for k,v in params
{
This.Bind( k, This._TL[k], v)
}
This.ErrorMsg := ""
This.ErrorCode := 0
If !(This._Handle) {
This.ErrorMsg := "Invalid statement handle!"
Return False
}
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_step", "Ptr", This._Handle, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_step failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC <> This._DB._ReturnCode("SQLITE_DONE"))
&& (RC <> This._DB._ReturnCode("SQLITE_ROW")) {
This.ErrorMsg := This._DB.ErrMsg()
This.ErrorCode := RC
Return False
}
This.Reset()
Return True
}
; ----------------------------------------------------------------------------------------------------------------
; METHOD Reset Reset the prepared statement.
; Parameters: ClearBindings - Clear bound SQL parameter values (True/False)
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; Remarks: After a call of this method you can access the query result via Next() again.
; ----------------------------------------------------------------------------------------------------------------
Reset(ClearBindings := True) {
This.ErrorMsg := ""
This.ErrorCode := 0
If !(This._Handle) {
This.ErrorMsg := "Invalid statement handle!"
Return False
}
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_reset", "Ptr", This._Handle, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_reset failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := This._DB._ErrMsg()
This.ErrorCode := RC
Return False
}
If (ClearBindings) {
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_clear_bindings", "Ptr", This._Handle, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_clear_bindings failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := This._DB._ErrMsg()
This.ErrorCode := RC
Return False
}
}
Return True
}
; ----------------------------------------------------------------------------------------------------------------
; METHOD Free Free the prepared statement object.
; Parameters: None
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; Remarks: After the call of this method further access on the statement object is impossible.
; ----------------------------------------------------------------------------------------------------------------
Free() {
This.ErrorMsg := ""
This.ErrorCode := 0
If !(This._Handle)
Return True
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_finalize", "Ptr", This._Handle, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_finalize failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := This._DB._ErrMsg()
This.ErrorCode := RC
Return False
}
This._DB._Stmts.Delete(This._Handle)
This._Handle := 0
This._DB := 0
Return True
}
}
; ===================================================================================================================
; CONSTRUCTOR __New
; ===================================================================================================================
__New() {
This._Path := "" ; Database path (String)
This._Handle := 0 ; Database handle (Pointer)
This._Queries := {} ; Valid queries (Object)
This._Stmts := {} ; Valid prepared statements (Object)
If (This.Base._RefCount = 0) {
SQLiteDLL := This.Base._SQLiteDLL
If !FileExist(SQLiteDLL)
If FileExist(A_ScriptDir . "\SQLiteDB.ini") {
IniRead, SQLiteDLL, %A_ScriptDir%\SQLiteDB.ini, Main, DllPath, %SQLiteDLL%
This.Base._SQLiteDLL := SQLiteDLL
}
If !(DLL := DllCall("LoadLibrary", "Str", This.Base._SQLiteDLL, "UPtr")) {
MsgBox, 16, SQLiteDB Error, % "DLL " . SQLiteDLL . " does not exist!"
ExitApp
}
This.Base.Version := StrGet(DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_libversion", "Cdecl UPtr"), "UTF-8")
SQLVersion := StrSplit(This.Base.Version, ".")
MinVersion := StrSplit(This.Base._MinVersion, ".")
If (SQLVersion[1] < MinVersion[1]) || ((SQLVersion[1] = MinVersion[1]) && (SQLVersion[2] < MinVersion[2])){
DllCall("FreeLibrary", "Ptr", DLL)
MsgBox, 16, SQLite ERROR, % "Version " . This.Base.Version . " of SQLite3.dll is not supported!`n`n"
. "You can download the current version from www.sqlite.org!"
ExitApp
}
}
This.Base._RefCount += 1
}
; ===================================================================================================================
; DESTRUCTOR __Delete
; ===================================================================================================================
__Delete() {
If (This._Handle)
This.CloseDB()
This.Base._RefCount -= 1
If (This.Base._RefCount = 0) {
If (DLL := DllCall("GetModuleHandle", "Str", This.Base._SQLiteDLL, "UPtr"))
DllCall("FreeLibrary", "Ptr", DLL)
}
}
; ===================================================================================================================
; PRIVATE _StrToUTF8
; ===================================================================================================================
_StrToUTF8(Str, ByRef UTF8) {
VarSetCapacity(UTF8, StrPut(Str, "UTF-8"), 0)
StrPut(Str, &UTF8, "UTF-8")
Return &UTF8
}
; ===================================================================================================================
; PRIVATE _UTF8ToStr
; ===================================================================================================================
_UTF8ToStr(UTF8) {
Return StrGet(UTF8, "UTF-8")
}
; ===================================================================================================================
; PRIVATE _ErrMsg
; ===================================================================================================================
_ErrMsg() {
If (RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_errmsg", "Ptr", This._Handle, "Cdecl UPtr"))
Return StrGet(&RC, "UTF-8")
Return ""
}
; ===================================================================================================================
; PRIVATE _ErrCode
; ===================================================================================================================
_ErrCode() {
Return DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_errcode", "Ptr", This._Handle, "Cdecl Int")
}
; ===================================================================================================================
; PRIVATE _Changes
; ===================================================================================================================
_Changes() {
Return DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_changes", "Ptr", This._Handle, "Cdecl Int")
}
; ===================================================================================================================
; PRIVATE _Returncode
; ===================================================================================================================
_ReturnCode(RC) {
Static RCODE := {SQLITE_OK: 0 ; Successful result
, SQLITE_ERROR: 1 ; SQL error or missing database
, SQLITE_INTERNAL: 2 ; NOT USED. 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 ; NOT USED. 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 ; NOT USED. Database lock protocol error
, SQLITE_EMPTY: 16 ; Database is empty
, SQLITE_SCHEMA: 17 ; The database schema changed
, SQLITE_TOOBIG: 18 ; String or BLOB exceeds size limit
, SQLITE_CONSTRAINT: 19 ; Abort due to constraint 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
Return RCODE.HasKey(RC) ? RCODE[RC] : ""
}
_RC2M( RC ) {
Static RCL := { 0: "The SQLITE_OK result code means that the operation was successful and that there were no errors. Most other result codes indicate an error.`n"
, 1: "The SQLITE_ERROR result code is a generic error code that is used when no other more specific error code is available.`n"
, 2: "The SQLITE_INTERNAL result code indicates an internal malfunction. In a working version of SQLite, an application should never see this result code. If application does encounter this result code, it shows that there is a bug in the database engine.`n"
. "SQLite does not currently generate this result code. However, application-defined SQL functions or virtual tables, or VFSes, or other extensions might cause this result code to be returned.`n"
, 3: "The SQLITE_PERM result code indicates that the requested access mode for a newly created database could not be provided.`n"
, 4: "The SQLITE_ABORT result code indicates that an operation was aborted prior to completion, usually be application request. See also: SQLITE_INTERRUPT.`n"
. "If the callback function to sqlite3_exec() returns non-zero, then sqlite3_exec() will return SQLITE_ABORT.`n"
. "If a ROLLBACK operation occurs on the same database connection as a pending read or write, then the pending read or write may fail with an SQLITE_ABORT or SQLITE_ABORT_ROLLBACK error.`n"
. "In addition to being a result code, the SQLITE_ABORT value is also used as a conflict resolution mode returned from the sqlite3_vtab_on_conflict() interface.`n"
, 5: "The SQLITE_BUSY result code indicates that the database file could not be written (or in some cases read) because of concurrent activity by some other database connection, usually a database connection in a separate process.`n"
. "For example, if process A is in the middle of a large write transaction and at the same time process B attempts to start a new write transaction, process B will get back an SQLITE_BUSY result because SQLite only supports one writer at a time. Process B will need to wait for process A to finish its transaction before starting a new transaction. The sqlite3_busy_timeout() and sqlite3_busy_handler() interfaces and the busy_timeout pragma are available to process B to help it deal with SQLITE_BUSY errors.`n"
. "An SQLITE_BUSY error can occur at any point in a transaction: when the transaction is first started, during any write or update operations, or when the transaction commits. To avoid encountering SQLITE_BUSY errors in the middle of a transaction, the application can use BEGIN IMMEDIATE instead of just BEGIN to start a transaction. The BEGIN IMMEDIATE command might itself return SQLITE_BUSY, but if it succeeds, then SQLite guarantees that no subsequent operations on the same database through the next COMMIT will return SQLITE_BUSY.`n"
. "See also: SQLITE_BUSY_RECOVERY and SQLITE_BUSY_SNAPSHOT.`n"
. "The SQLITE_BUSY result code differs from SQLITE_LOCKED in that SQLITE_BUSY indicates a conflict with a separate database connection, probably in a separate process, whereas SQLITE_LOCKED indicates a conflict within the same database connection (or sometimes a database connection with a shared cache).`n"
, 6: "The SQLITE_LOCKED result code indicates that a write operation could not continue because of a conflict within the same database connection or a conflict with a different database connection that uses a shared cache.`n"
. "For example, a DROP TABLE statement cannot be run while another thread is reading from that table on the same database connection because dropping the table would delete the table out from under the concurrent reader.`n"
. "The SQLITE_LOCKED result code differs from SQLITE_BUSY in that SQLITE_LOCKED indicates a conflict on the same database connection (or on a connection with a shared cache) whereas SQLITE_BUSY indicates a conflict with a different database connection, probably in a different process.`n"
, 7: "The SQLITE_NOMEM result code indicates that SQLite was unable to allocate all the memory it needed to complete the operation. In other words, an internal call to sqlite3_malloc() or sqlite3_realloc() has failed in a case where the memory being allocated was required in order to continue the operation.`n"
, 8: "The SQLITE_READONLY result code is returned when an attempt is made to alter some data for which the current database connection does not have write permission.`n"
, 9: "The SQLITE_INTERRUPT result code indicates that an operation was interrupted by the sqlite3_interrupt() interface. See also: SQLITE_ABORT`n"
, 10: "The SQLITE_IOERR result code says that the operation could not finish because the operating system reported an I/O error.`n"
. "A full disk drive will normally give an SQLITE_FULL error rather than an SQLITE_IOERR error.`n"
. "There are many different extended result codes for I/O errors that identify the specific I/O operation that failed.`n"
, 11: "The SQLITE_CORRUPT result code indicates that the database file has been corrupted. See the How To Corrupt Your Database Files for further discussion on how corruption can occur.`n"
, 12: "The SQLITE_NOTFOUND result code is used in two contexts. SQLITE_NOTFOUND can be returned by the sqlite3_file_control() interface to indicate that the file control opcode passed as the third argument was not recognized by the underlying VFS. SQLITE_NOTFOUND can also be returned by the xSetSystemCall() method of an sqlite3_vfs object.`n"
. "The SQLITE_NOTFOUND result code is also used internally by the SQLite implementation, but those internal uses are not exposed to the application.`n"
, 13: "The SQLITE_FULL result code indicates that a write could not complete because the disk is full. Note that this error can occur when trying to write information into the main database file, or it can also occur when writing into temporary disk files.`n"
. "Sometimes applications encounter this error even though there is an abundance of primary disk space because the error occurs when writing into temporary disk files on a system where temporary files are stored on a separate partition with much less space that the primary disk.`n"
, 14: "The SQLITE_CANTOPEN result code indicates that SQLite was unable to open a file. The file in question might be a primary database file or one of several temporary disk files.`n"
, 15: "The SQLITE_PROTOCOL result code indicates a problem with the file locking protocol used by SQLite. The SQLITE_PROTOCOL error is currently only returned when using WAL mode and attempting to start a new transaction. There is a race condition that can occur when two separate database connections both try to start a transaction at the same time in WAL mode. The loser of the race backs off and tries again, after a brief delay. If the same connection loses the locking race dozens of times over a span of multiple seconds, it will eventually give up and return SQLITE_PROTOCOL. The SQLITE_PROTOCOL error should appear in practice very, very rarely, and only when there are many separate processes all competing intensely to write to the same database.`n"
, 16: "The SQLITE_EMPTY result code is not currently used.`n"
, 17: "The SQLITE_SCHEMA result code indicates that the database schema has changed. This result code can be returned from sqlite3_step() for a prepared statement that was generated using sqlite3_prepare() or sqlite3_prepare16(). If the database schema was changed by some other process in between the time that the statement was prepared and the time the statement was run, this error can result.`n"
. "If a prepared statement is generated from sqlite3_prepare_v2() then the statement is automatically re-prepared if the schema changes, up to SQLITE_MAX_SCHEMA_RETRY times (default: 50). The sqlite3_step() interface will only return SQLITE_SCHEMA back to the application if the failure persists after these many retries.`n"
, 18: "The SQLITE_TOOBIG error code indicates that a string or BLOB was too large. The default maximum length of a string or BLOB in SQLite is 1,000,000,000 bytes. This maximum length can be changed at compile-time using the SQLITE_MAX_LENGTH compile-time option, or at run-time using the sqlite3_limit(db,SQLITE_LIMIT_LENGTH,...) interface. The SQLITE_TOOBIG error results when SQLite encounters a string or BLOB that exceeds the compile-time or run-time limit.`n"
. "The SQLITE_TOOBIG error code can also result when an oversized SQL statement is passed into one of the sqlite3_prepare_v2() interfaces. The maximum length of an SQL statement defaults to a much smaller value of 1,000,000 bytes. The maximum SQL statement length can be set at compile-time using SQLITE_MAX_SQL_LENGTH or at run-time using sqlite3_limit(db,SQLITE_LIMIT_SQL_LENGTH,...).`n"
, 19: "The SQLITE_CONSTRAINT error code means that an SQL constraint violation occurred while trying to process an SQL statement. Additional information about the failed constraint can be found by consulting the accompanying error message (returned via sqlite3_errmsg() or sqlite3_errmsg16()) or by looking at the extended error code.`n"
. "The SQLITE_CONSTRAINT code can also be used as the return value from the xBestIndex() method of a virtual table implementation. When xBestIndex() returns SQLITE_CONSTRAINT, that indicates that the particular combination of inputs submitted to xBestIndex() cannot result in a usable query plan and should not be given further consideration.`n"
, 20: "The SQLITE_MISMATCH error code indicates a datatype mismatch.`n"
. "SQLite is normally very forgiving about mismatches between the type of a value and the declared type of the container in which that value is to be stored. For example, SQLite allows the application to store a large BLOB in a column with a declared type of BOOLEAN. But in a few cases, SQLite is strict about types. The SQLITE_MISMATCH error is returned in those few cases when the types do not match.`n"
. "The rowid of a table must be an integer. Attempt to set the rowid to anything other than an integer (or a NULL which will be automatically converted into the next available integer rowid) results in an SQLITE_MISMATCH error.`n"
, 21: "The SQLITE_MISUSE return code might be returned if the application uses any SQLite interface in a way that is undefined or unsupported. For example, using a prepared statement after that prepared statement has been finalized might result in an SQLITE_MISUSE error.`n"
. "SQLite tries to detect misuse and report the misuse using this result code. However, there is no guarantee that the detection of misuse will be successful. Misuse detection is probabilistic. Applications should never depend on an SQLITE_MISUSE return value.`n"
. "If SQLite ever returns SQLITE_MISUSE from any interface, that means that the application is incorrectly coded and needs to be fixed. Do not ship an application that sometimes returns SQLITE_MISUSE from a standard SQLite interface because that application contains potentially serious bugs.`n"
, 22: "The SQLITE_NOLFS error can be returned on systems that do not support large files when the database grows to be larger than what the filesystem can handle. 'NOLFS' stands for 'NO Large File Support'.`n"
, 23: "The SQLITE_AUTH error is returned when the authorizer callback indicates that an SQL statement being prepared is not authorized.`n"
, 24: "The SQLITE_FORMAT error code is not currently used by SQLite.`n"
, 25: "The SQLITE_RANGE error indices that the parameter number argument to one of the sqlite3_bind routines or the column number in one of the sqlite3_column routines is out of range.`n"
, 26: "When attempting to open a file, the SQLITE_NOTADB error indicates that the file being opened does not appear to be an SQLite database file.`n"
, 27: "The SQLITE_NOTICE result code is not returned by any C/C++ interface. However, SQLITE_NOTICE (or rather one of its extended error codes) is sometimes used as the first argument in an sqlite3_log() callback to indicate that an unusual operation is taking place.`n"
, 28: "The SQLITE_WARNING result code is not returned by any C/C++ interface. However, SQLITE_WARNING (or rather one of its extended error codes) is sometimes used as the first argument in an sqlite3_log() callback to indicate that an unusual and possibly ill-advised operation is taking place.`n"
, 100: "The SQLITE_ROW result code returned by sqlite3_step() indicates that another row of output is available.`n"
, 101: "The SQLITE_DONE result code indicates that an operation has completed. The SQLITE_DONE result code is most commonly seen as a return value from sqlite3_step() indicating that the SQL statement has run to completion. But SQLITE_DONE can also be returned by other multi-step interfaces such as sqlite3_backup_step().`n"
, 256: "The sqlite3_load_extension() interface loads an extension into a single database connection. The default behavior is for that extension to be automatically unloaded when the database connection closes. However, if the extension entry point returns SQLITE_OK_LOAD_PERMANENTLY instead of SQLITE_OK, then the extension remains loaded into the process address space after the database connection closes. In other words, the xDlClose methods of the sqlite3_vfs object is not called for the extension when the database connection closes.`n"
. "The SQLITE_OK_LOAD_PERMANENTLY return code is useful to loadable extensions that register new VFSes, for example.`n"
, 257: "The SQLITE_ERROR_MISSING_COLLSEQ result code means that an SQL statement could not be prepared because a collating sequence named in that SQL statement could not be located.`n"
. "Sometimes when this error code is encountered, the sqlite3_prepare_v2() routine will convert the error into SQLITE_ERROR_RETRY and try again to prepare the SQL statement using a different query plan that does not require the use of the unknown collating sequence.`n"}
/*
, 261: "SQLITE_BUSY_RECOVERY`n"
. "The SQLITE_BUSY_RECOVERY error code is an extended error code for SQLITE_BUSY that indicates that an operation could not continue because another process is busy recovering a WAL mode database file following a crash. The SQLITE_BUSY_RECOVERY error code only occurs on WAL mode databases.`n"
, 262: "SQLITE_LOCKED_SHAREDCACHE`n"
. "The SQLITE_LOCKED_SHAREDCACHE error code is an extended error code for SQLITE_LOCKED indicating that the locking conflict has occurred due to contention with a different database connection that happens to hold a shared cache with the database connection to which the error was returned. For example, if the other database connection is holding an exclusive lock on the database, then the database connection that receives this error will be unable to read or write any part of the database file unless it has the read_uncommitted pragma enabled.`n"
. "The SQLITE_LOCKED_SHARECACHE error code works very much like the SQLITE_BUSY error code except that SQLITE_LOCKED_SHARECACHE is for separate database connections that share a cache whereas SQLITE_BUSY is for the much more common case of separate database connections that do not share the same cache. Also, the sqlite3_busy_handler() and sqlite3_busy_timeout() interfaces do not help in resolving SQLITE_LOCKED_SHAREDCACHE conflicts.`n"
, 264: "SQLITE_READONLY_RECOVERY`n"
. "The SQLITE_READONLY_RECOVERY error code is an extended error code for SQLITE_READONLY. The SQLITE_READONLY_RECOVERY error code indicates that a WAL mode database cannot be opened because the database file needs to be recovered and recovery requires write access but only read access is available.`n"
, 266: "SQLITE_IOERR_READ`n"
. "The SQLITE_IOERR_READ error code is an extended error code for SQLITE_IOERR indicating an I/O error in the VFS layer while trying to read from a file on disk. This error might result from a hardware malfunction or because a filesystem came unmounted while the file was open.`n"
, 267: "SQLITE_CORRUPT_VTAB`n"
. "The SQLITE_CORRUPT_VTAB error code is an extended error code for SQLITE_CORRUPT used by virtual tables. A virtual table might return SQLITE_CORRUPT_VTAB to indicate that content in the virtual table is corrupt.`n"
, 270: "SQLITE_CANTOPEN_NOTEMPDIR`n"
. "The SQLITE_CANTOPEN_NOTEMPDIR error code is no longer used.`n"
, 275: "SQLITE_CONSTRAINT_CHECK`n"
. "The SQLITE_CONSTRAINT_CHECK error code is an extended error code for SQLITE_CONSTRAINT indicating that a CHECK constraint failed.`n"
, 283: "SQLITE_NOTICE_RECOVER_WAL`n"
. "The SQLITE_NOTICE_RECOVER_WAL result code is passed to the callback of sqlite3_log() when a WAL mode database file is recovered.`n"
, 284: "SQLITE_WARNING_AUTOINDEX`n"
. "The SQLITE_WARNING_AUTOINDEX result code is passed to the callback of sqlite3_log() whenever automatic indexing is used. This can serve as a warning to application designers that the database might benefit from additional indexes.`n"
, 513: "SQLITE_ERROR_RETRY`n"
. "The SQLITE_ERROR_RETRY is used internally to provoke sqlite3_prepare_v2() (or one of its sibling routines for creating prepared statements) to try again to prepare a statement that failed with an error on the previous attempt.`n"
, 516: "SQLITE_ABORT_ROLLBACK`n"
. "The SQLITE_ABORT_ROLLBACK error code is an extended error code for SQLITE_ABORT indicating that an SQL statement aborted because the transaction that was active when the SQL statement first started was rolled back. Pending write operations always fail with this error when a rollback occurs. A ROLLBACK will cause a pending read operation to fail only if the schema was changed within the transaction being rolled back.`n"
, 517: "SQLITE_BUSY_SNAPSHOT`n"
. "The SQLITE_BUSY_SNAPSHOT error code is an extended error code for SQLITE_BUSY that occurs on WAL mode databases when a database connection tries to promote a read transaction into a write transaction but finds that another database connection has already written to the database and thus invalidated prior reads.`n"
. "The following scenario illustrates how an SQLITE_BUSY_SNAPSHOT error might arise:`n"
. " Process A starts a read transaction on the database and does one or more SELECT statement. Process A keeps the transaction open.`n"
. " Process B updates the database, changing values previous read by process A.`n"
. " Process A now tries to write to the database. But process A's view of the database content is now obsolete because process B has modified the database file after process A read from it. Hence process A gets an SQLITE_BUSY_SNAPSHOT error. `n"
, 518: "SQLITE_LOCKED_VTAB`n"
. "The SQLITE_LOCKED_VTAB result code is not used by the SQLite core, but it is available for use by extensions. Virtual table implementations can return this result code to indicate that they cannot complete the current operation because of locks held by other threads or processes.`n"
. "The R-Tree extension returns this result code when an attempt is made to update the R-Tree while another prepared statement is actively reading the R-Tree. The update cannot proceed because any change to an R-Tree might involve reshuffling and rebalancing of nodes, which would disrupt read cursors, causing some rows to be repeated and other rows to be omitted.`n"
, 520: "SQLITE_READONLY_CANTLOCK`n"
. "The SQLITE_READONLY_CANTLOCK error code is an extended error code for SQLITE_READONLY. The SQLITE_READONLY_CANTLOCK error code indicates that SQLite is unable to obtain a read lock on a WAL mode database because the shared-memory file associated with that database is read-only.`n"
, 522: "SQLITE_IOERR_SHORT_READ`n"
. "The SQLITE_IOERR_SHORT_READ error code is an extended error code for SQLITE_IOERR indicating that a read attempt in the VFS layer was unable to obtain as many bytes as was requested. This might be due to a truncated file.`n"
, 523: "SQLITE_CORRUPT_SEQUENCE`n"
. "The SQLITE_CORRUPT_SEQUENCE result code means that the schema of the sqlite_sequence table is corrupt. The sqlite_sequence table is used to help implement the AUTOINCREMENT feature. The sqlite_sequence table should have the following format:`n"
. " CREATE TABLE sqlite_sequence(name,seq);`n"
. "If SQLite discovers that the sqlite_sequence table has any other format, it returns the SQLITE_CORRUPT_SEQUENCE error.`n"
, 526: "SQLITE_CANTOPEN_ISDIR`n"
. "The SQLITE_CANTOPEN_ISDIR error code is an extended error code for SQLITE_CANTOPEN indicating that a file open operation failed because the file is really a directory.`n"
, 531: "SQLITE_CONSTRAINT_COMMITHOOK`n"
. "The SQLITE_CONSTRAINT_COMMITHOOK error code is an extended error code for SQLITE_CONSTRAINT indicating that a commit hook callback returned non-zero that thus caused the SQL statement to be rolled back.`n"
, 539: "SQLITE_NOTICE_RECOVER_ROLLBACK`n"
. "The SQLITE_NOTICE_RECOVER_ROLLBACK result code is passed to the callback of sqlite3_log() when a hot journal is rolled back.`n"
, 769: "SQLITE_ERROR_SNAPSHOT`n"
. "The SQLITE_ERROR_SNAPSHOT result code might be returned when attempting to start a read transaction on an historical version of the database by using the sqlite3_snapshot_open() interface. If the historical snapshot is no longer available, then the read transaction will fail with the SQLITE_ERROR_SNAPSHOT. This error code is only possible if SQLite is compiled with -DSQLITE_ENABLE_SNAPSHOT.`n"
, 776: "SQLITE_READONLY_ROLLBACK`n"
. "The SQLITE_READONLY_ROLLBACK error code is an extended error code for SQLITE_READONLY. The SQLITE_READONLY_ROLLBACK error code indicates that a database cannot be opened because it has a hot journal that needs to be rolled back but cannot because the database is readonly.`n"
, 778: "SQLITE_IOERR_WRITE`n"
. "The SQLITE_IOERR_WRITE error code is an extended error code for SQLITE_IOERR indicating an I/O error in the VFS layer while trying to write into a file on disk. This error might result from a hardware malfunction or because a filesystem came unmounted while the file was open. This error should not occur if the filesystem is full as there is a separate error code (SQLITE_FULL) for that purpose.`n"
, 782: "SQLITE_CANTOPEN_FULLPATH`n"
. "The SQLITE_CANTOPEN_FULLPATH error code is an extended error code for SQLITE_CANTOPEN indicating that a file open operation failed because the operating system was unable to convert the filename into a full pathname.`n"
, 787: "SQLITE_CONSTRAINT_FOREIGNKEY`n"
. "The SQLITE_CONSTRAINT_FOREIGNKEY error code is an extended error code for SQLITE_CONSTRAINT indicating that a foreign key constraint failed.`n"
, 1032: "SQLITE_READONLY_DBMOVED`n"
. "The SQLITE_READONLY_DBMOVED error code is an extended error code for SQLITE_READONLY. The SQLITE_READONLY_DBMOVED error code indicates that a database cannot be modified because the database file has been moved since it was opened, and so any attempt to modify the database might result in database corruption if the processes crashes because the rollback journal would not be correctly named.`n"
, 1034: "SQLITE_IOERR_FSYNC`n"
. "The SQLITE_IOERR_FSYNC error code is an extended error code for SQLITE_IOERR indicating an I/O error in the VFS layer while trying to flush previously written content out of OS and/or disk-control buffers and into persistent storage. In other words, this code indicates a problem with the fsync() system call in unix or the FlushFileBuffers() system call in windows.`n"
, 1038: "SQLITE_CANTOPEN_CONVPATH`n"
. "The SQLITE_CANTOPEN_CONVPATH error code is an extended error code for SQLITE_CANTOPEN used only by Cygwin VFS and indicating that the cygwin_conv_path() system call failed while trying to open a file. See also: SQLITE_IOERR_CONVPATH`n"
, 1043: "SQLITE_CONSTRAINT_FUNCTION`n"
. "The SQLITE_CONSTRAINT_FUNCTION error code is not currently used by the SQLite core. However, this error code is available for use by extension functions.`n"
, 1288: "SQLITE_READONLY_CANTINIT`n"
. "The SQLITE_READONLY_CANTINIT result code originates in the xShmMap method of a VFS to indicate that the shared memory region used by WAL mode exists buts its content is unreliable and unusable by the current process since the current process does not have write permission on the shared memory region. (The shared memory region for WAL mode is normally a file with a "-wal" suffix that is mmapped into the process space. If the current process does not have write permission on that file, then it cannot write into shared memory.)`n"
. "Higher level logic within SQLite will normally intercept the error code and create a temporary in-memory shared memory region so that the current process can at least read the content of the database. This result code should not reach the application interface layer.`n"
, 1290: "SQLITE_IOERR_DIR_FSYNC`n"
. "The SQLITE_IOERR_DIR_FSYNC error code is an extended error code for SQLITE_IOERR indicating an I/O error in the VFS layer while trying to invoke fsync() on a directory. The unix VFS attempts to fsync() directories after creating or deleting certain files to ensure that those files will still appear in the filesystem following a power loss or system crash. This error code indicates a problem attempting to perform that fsync().`n"
, 1294: "SQLITE_CANTOPEN_DIRTYWAL`n"
. "The SQLITE_CANTOPEN_DIRTYWAL result code is not used at this time.`n"
, 1299: "SQLITE_CONSTRAINT_NOTNULL`n"
. "The SQLITE_CONSTRAINT_NOTNULL error code is an extended error code for SQLITE_CONSTRAINT indicating that a NOT NULL constraint failed.`n"
, 1544: "SQLITE_READONLY_DIRECTORY`n"
. "The SQLITE_READONLY_DIRECTORY result code indicates that the database is read-only because process does not have permission to create a journal file in the same directory as the database and the creation of a journal file is a prerequisite for writing.`n"
, 1546: "SQLITE_IOERR_TRUNCATE`n"
. "The SQLITE_IOERR_TRUNCATE error code is an extended error code for SQLITE_IOERR indicating an I/O error in the VFS layer while trying to truncate a file to a smaller size.`n"
, 1555: "SQLITE_CONSTRAINT_PRIMARYKEY`n"
. "The SQLITE_CONSTRAINT_PRIMARYKEY error code is an extended error code for SQLITE_CONSTRAINT indicating that a PRIMARY KEY constraint failed.`n"
, 1802: "SQLITE_IOERR_FSTAT`n"
. "The SQLITE_IOERR_FSTAT error code is an extended error code for SQLITE_IOERR indicating an I/O error in the VFS layer while trying to invoke fstat() (or the equivalent) on a file in order to determine information such as the file size or access permissions.`n"
, 1811: "SQLITE_CONSTRAINT_TRIGGER`n"
. "The SQLITE_CONSTRAINT_TRIGGER error code is an extended error code for SQLITE_CONSTRAINT indicating that a RAISE function within a trigger fired, causing the SQL statement to abort.`n"
, 2058: "SQLITE_IOERR_UNLOCK`n"
. "The SQLITE_IOERR_UNLOCK error code is an extended error code for SQLITE_IOERR indicating an I/O error within xUnlock method on the sqlite3_io_methods object.`n"
, 2067: "SQLITE_CONSTRAINT_UNIQUE`n"
. "The SQLITE_CONSTRAINT_UNIQUE error code is an extended error code for SQLITE_CONSTRAINT indicating that a UNIQUE constraint failed.`n"
, 2314: "SQLITE_IOERR_RDLOCK`n"
. "The SQLITE_IOERR_UNLOCK error code is an extended error code for SQLITE_IOERR indicating an I/O error within xLock method on the sqlite3_io_methods object while trying to obtain a read lock.`n"
, 2323: "SQLITE_CONSTRAINT_VTAB`n"
. "The SQLITE_CONSTRAINT_VTAB error code is not currently used by the SQLite core. However, this error code is available for use by application-defined virtual tables.`n"
, 2570: "SQLITE_IOERR_DELETE`n"
. "The SQLITE_IOERR_UNLOCK error code is an extended error code for SQLITE_IOERR indicating an I/O error within xDelete method on the sqlite3_vfs object.`n"
, 2579: "SQLITE_CONSTRAINT_ROWID`n"
. "The SQLITE_CONSTRAINT_ROWID error code is an extended error code for SQLITE_CONSTRAINT indicating that a rowid is not unique.`n"
, 2826: "SQLITE_IOERR_BLOCKED`n"
. "The SQLITE_IOERR_BLOCKED error code is no longer used.`n"
, 3082: "SQLITE_IOERR_NOMEM`n"
. "The SQLITE_IOERR_NOMEM error code is sometimes returned by the VFS layer to indicate that an operation could not be completed due to the inability to allocate sufficient memory. This error code is normally converted into SQLITE_NOMEM by the higher layers of SQLite before being returned to the application.`n"
, 3338: "SQLITE_IOERR_ACCESS`n"
. "The SQLITE_IOERR_ACCESS error code is an extended error code for SQLITE_IOERR indicating an I/O error within the xAccess method on the sqlite3_vfs object.`n"
, 3594: "SQLITE_IOERR_CHECKRESERVEDLOCK`n"
. "The SQLITE_IOERR_CHECKRESERVEDLOCK error code is an extended error code for SQLITE_IOERR indicating an I/O error within the xCheckReservedLock method on the sqlite3_io_methods object.`n"
, 3850: "SQLITE_IOERR_LOCK`n"
. "The SQLITE_IOERR_LOCK error code is an extended error code for SQLITE_IOERR indicating an I/O error in the advisory file locking logic. Usually an SQLITE_IOERR_LOCK error indicates a problem obtaining a PENDING lock. However it can also indicate miscellaneous locking errors on some of the specialized VFSes used on Macs.`n"
, 4106: "SQLITE_IOERR_CLOSE`n"
. "The SQLITE_IOERR_ACCESS error code is an extended error code for SQLITE_IOERR indicating an I/O error within the xClose method on the sqlite3_io_methods object.`n"
, 4362: "The SQLITE_IOERR_DIR_CLOSE error code is no longer used.`n"
, 4618: "The SQLITE_IOERR_SHMOPEN error code is an extended error code for SQLITE_IOERR indicating an I/O error within the xShmMap method on the sqlite3_io_methods object while trying to open a new shared memory segment.`n"
, 4874: "The SQLITE_IOERR_SHMSIZE error code is an extended error code for SQLITE_IOERR indicating an I/O error within the xShmMap method on the sqlite3_io_methods object while trying to enlarge a "shm" file as part of WAL mode transaction processing. This error may indicate that the underlying filesystem volume is out of space.`n"
, 5130: "The SQLITE_IOERR_SHMLOCK error code is no longer used.`n"
, 5386: "The SQLITE_IOERR_SHMMAP error code is an extended error code for SQLITE_IOERR indicating an I/O error within the xShmMap method on the sqlite3_io_methods object while trying to map a shared memory segment into the process address space.`n"
, 5642: "The SQLITE_IOERR_SEEK error code is an extended error code for SQLITE_IOERR indicating an I/O error within the xRead or xWrite methods on the sqlite3_io_methods object while trying to seek a file descriptor to the beginning point of the file where the read or write is to occur.`n"
, 5898: "The SQLITE_IOERR_DELETE_NOENT error code is an extended error code for SQLITE_IOERR indicating that the xDelete method on the sqlite3_vfs object failed because the file being deleted does not exist.`n"
, 6154: "The SQLITE_IOERR_MMAP error code is an extended error code for SQLITE_IOERR indicating an I/O error within the xFetch or xUnfetch methods on the sqlite3_io_methods object while trying to map or unmap part of the database file into the process address space.`n"
, 6410: "The SQLITE_IOERR_GETTEMPPATH error code is an extended error code for SQLITE_IOERR indicating that the VFS is unable to determine a suitable directory in which to place temporary files.`n"
, 6666: "The SQLITE_IOERR_CONVPATH error code is an extended error code for SQLITE_IOERR used only by Cygwin VFS and indicating that the cygwin_conv_path() system call failed. See also: SQLITE_CANTOPEN_CONVPATH `n" }
*/
; return RCL.HasKey(RC) ? RCL[ RC ] : RC
return RCL[ RC ]
}
; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; PUBLIC Interface ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
; ===================================================================================================================
; Properties
; ===================================================================================================================
ErrorMsg := "" ; Error message (String)
ErrorCode := 0 ; SQLite error code / ErrorLevel (Variant)
Changes := 0 ; Changes made by last call of Exec() (Integer)
SQL := "" ; Last executed SQL statement (String)
; ===================================================================================================================
; METHOD OpenDB Open a database
; Parameters: DBPath - Path of the database file
; Access - Wanted access: "R"ead / "W"rite
; Create - Create new database in write mode, if it doesn't exist
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; Remarks: If DBPath is empty in write mode, a database called ":memory:" is created in memory
; and deletet on call of CloseDB.
; ===================================================================================================================
OpenDB(DBPath, Access := "W", Create := True) {
Static SQLITE_OPEN_READONLY := 0x01 ; Database opened as read-only
Static SQLITE_OPEN_READWRITE := 0x02 ; Database opened as read-write
Static SQLITE_OPEN_CREATE := 0x04 ; Database will be created if not exists
Static MEMDB := ":memory:"
This.ErrorMsg := ""
This.ErrorCode := 0
HDB := 0
If (DBPath = "")
DBPath := MEMDB
If (DBPath = This._Path) && (This._Handle)
Return True
If (This._Handle) {
This.ErrorMsg := "You must first close DB " . This._Path . "!"
Return False
}
Flags := 0
Access := SubStr(Access, 1, 1)
If (Access <> "W") && (Access <> "R")
Access := "R"
Flags := SQLITE_OPEN_READONLY
If (Access = "W") {
Flags := SQLITE_OPEN_READWRITE
If (Create)
Flags |= SQLITE_OPEN_CREATE
}
This._Path := DBPath
This._StrToUTF8(DBPath, UTF8)
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_open_v2", "Ptr", &UTF8, "UPtrP", HDB, "Int", Flags, "Ptr", 0, "Cdecl Int")
If (ErrorLevel) {
This._Path := ""
This.ErrorMsg := "DLLCall sqlite3_open_v2 failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This._Path := ""
This.ErrorMsg := This._ErrMsg()
This.ErrorCode := RC
Return False
}
This._Handle := HDB
Return True
}
; ===================================================================================================================
; METHOD CloseDB Close database
; Parameters: None
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; ===================================================================================================================
CloseDB() {
This.ErrorMsg := ""
This.ErrorCode := 0
This.SQL := ""
If !(This._Handle)
Return True
For Each, Query in This._Queries
DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_finalize", "Ptr", Query, "Cdecl Int")
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_close", "Ptr", This._Handle, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DLLCall sqlite3_close failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := This._ErrMsg()
This.ErrorCode := RC
Return False
}
This._Path := ""
This._Handle := ""
This._Queries := []
Return True
}
; ===================================================================================================================
; METHOD AttachDB Add another database file to the current database connection
; http://www.sqlite.org/lang_attach.html
; Parameters: DBPath - Path of the database file
; DBAlias - Database alias name used internally by SQLite
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; ===================================================================================================================
AttachDB(DBPath, DBAlias) {
Return This.Exec("ATTACH DATABASE '" . DBPath . "' As " . DBAlias . ";")
}
; ===================================================================================================================
; METHOD DetachDB Detaches an additional database connection previously attached using AttachDB()
; http://www.sqlite.org/lang_detach.html
; Parameters: DBAlias - Database alias name used with AttachDB()
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; ===================================================================================================================
DetachDB(DBAlias) {
Return This.Exec("DETACH DATABASE " . DBAlias . ";")
}
; ===================================================================================================================
; METHOD Exec Execute SQL statement
; Parameters: SQL - Valid SQL statement
; Callback - Name of a callback function to invoke for each result row coming out
; of the evaluated SQL statements.
; The function must accept 4 parameters:
; 1: SQLiteDB object
; 2: Number of columns
; 3: Pointer to an array of pointers to columns text
; 4: Pointer to an array of pointers to column names
; The address of the current SQL string is passed in A_EventInfo.
; If the callback function returns non-zero, DB.Exec() returns SQLITE_ABORT
; without invoking the callback again and without running any subsequent
; SQL statements.
; Return values: On success - True, the number of changed rows is given in property Changes
; On failure - False, ErrorMsg / ErrorCode contain additional information
; ===================================================================================================================
Exec(SQL, Callback := "") {
This.ErrorMsg := ""
This.ErrorCode := 0
This.SQL := SQL
If !(This._Handle) {
This.ErrorMsg := "Invalid database handle!"
Return False
}
CBPtr := 0
Err := 0
If (FO := Func(Callback)) && (FO.MinParams = 4)
CBPtr := RegisterCallback(Callback, "F C", 4, &SQL)
This._StrToUTF8(SQL, UTF8)
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_exec", "Ptr", This._Handle, "Ptr", &UTF8, "Int", CBPtr, "Ptr", Object(This)
, "UPtrP", Err, "Cdecl Int")
CallError := ErrorLevel
If (CBPtr)
DllCall("Kernel32.dll\GlobalFree", "Ptr", CBPtr)
If (CallError) {
This.ErrorMsg := "DLLCall sqlite3_exec failed!"
This.ErrorCode := CallError
Return False
}
If (RC) {
This.ErrorMsg := StrGet(Err, "UTF-8")
This.ErrorCode := RC
DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_free", "Ptr", Err, "Cdecl")
Return False
}
This.Changes := This._Changes()
Return True
}
; ===================================================================================================================
; METHOD GetTable Get complete result for SELECT query
; Parameters: SQL - SQL SELECT statement
; ByRef TB - Variable to store the result object (TB _Table)
; MaxResult - Number of rows to return:
; 0 Complete result (default)
; -1 Return only RowCount and ColumnCount
; -2 Return counters and array ColumnNames
; n Return counters and ColumnNames and first n rows
; Return values: On success - True, TB contains the result object
; On failure - False, ErrorMsg / ErrorCode contain additional information
; ===================================================================================================================
GetTable(SQL, ByRef TB, MaxResult := 0) {
TB := ""
This.ErrorMsg := ""
This.ErrorCode := 0
This.SQL := SQL
If !(This._Handle) {
This.ErrorMsg := "Invalid database handle!"
Return False
}
Names := ""
Err := 0, RC := 0, GetRows := 0
I := 0, Rows := Cols := 0
Table := 0
If MaxResult Is Not Integer
MaxResult := 0
If (MaxResult < -2)
MaxResult := 0
This._StrToUTF8(SQL, UTF8)
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_get_table", "Ptr", This._Handle, "Ptr", &UTF8, "UPtrP", Table
, "IntP", Rows, "IntP", Cols, "UPtrP", Err, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DLLCall sqlite3_get_table failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := StrGet(Err, "UTF-8")
This.ErrorCode := RC
DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_free", "Ptr", Err, "Cdecl")
Return False
}
TB := new This._Table
TB.ColumnCount := Cols
TB.RowCount := Rows
If (MaxResult = -1) {
DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_free_table", "Ptr", Table, "Cdecl")
If (ErrorLevel) {
This.ErrorMsg := "DLLCall sqlite3_free_table failed!"
This.ErrorCode := ErrorLevel
Return False
}
Return True
}
If (MaxResult = -2)
GetRows := 0
Else If (MaxResult > 0) && (MaxResult <= Rows)
GetRows := MaxResult
Else
GetRows := Rows
Offset := 0
Names := Array()
Loop, %Cols% {
Names[A_Index] := StrGet(NumGet(Table+0, Offset, "UPtr"), "UTF-8")
Offset += A_PtrSize
}
TB.ColumnNames := Names
TB.HasNames := True
Loop, %GetRows% {
I := A_Index
TB.Rows[I] := []
Loop, %Cols% {
TB.Rows[I][A_Index] := StrGet(NumGet(Table+0, Offset, "UPtr"), "UTF-8")
Offset += A_PtrSize
}
}
If (GetRows)
TB.HasRows := True
DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_free_table", "Ptr", Table, "Cdecl")
If (ErrorLevel) {
TB := ""
This.ErrorMsg := "DLLCall sqlite3_free_table failed!"
This.ErrorCode := ErrorLevel
Return False
}
Return True
}
; ===================================================================================================================
; Prepared statement 10:54 2019.07.05. by Dixtroy
; 21:03 2023. 10. 18. Dixtroy again
; DB := new SQLiteDB
; DB.OpenDB(A_Scriptdir "\tst.db")
; DB.Exec("CREATE TABLE 'test' ( 'id' INTEGER, 't' TEXT, 'nu' double, 'i' integer, 'b' blob, PRIMARY KEY('id' AUTOINCREMENT) );")
; DB.Prepare("insert into test (t,nu) values ( ?, ? )", ["Text","Double"], ST1)
; DB.Prepare("insert into test (i) values ( ? )", ["int"], ST2)
; DB.Exec("BEGIN TRANSACTION;")
; ST1.Step(["1",5.3])
; ST2.Step([7])
; ST2.Steps([[5],[6]])
; ST1.Step(["2",6.3])
; ST1.Step(["3",1.1])
; ST1.Steps([["4",4.1],["5",1.5],["6",1.6]])
; DB.Exec("COMMIT TRANSACTION;")
; DB.CloseDB()
; ===================================================================================================================
; ===================================================================================================================
; METHOD Prepare Prepare database table for further actions.
; Parameters: SQL - SQL statement to be compiled
; TL - Types to store the statement object (Class _Statement)
; ByRef ST - Variable to store the statement object (Class _Statement)
; Return values: On success - True, ST contains the statement object
; On failure - False, ErrorMsg / ErrorCode contain additional information
; Remarks: You have to pass one ? for each column you want to assign a value later.
; ===================================================================================================================
Prepare(SQL, TL, ByRef ST) {
This.ErrorMsg := ""
This.ErrorCode := 0
This.SQL := SQL
If !(This._Handle) {
This.ErrorMsg := "Invalid database handle!"
Return False
}
Stmt := 0
This._StrToUTF8(SQL, UTF8)
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_prepare_v2", "Ptr", This._Handle, "Ptr", &UTF8, "Int", -1
, "UPtrP", Stmt, "Ptr", 0, "Cdecl Int")
If (ErrorLeveL) {
This.ErrorMsg := A_ThisFunc . ": DllCall sqlite3_prepare_v2 failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := A_ThisFunc . ": " . This._ErrMsg()
This.ErrorCode := RC
Return False
}
ST := New This._Statement
ST.ParamCount := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_bind_parameter_count", "Ptr", Stmt, "Cdecl Int")
ST._Handle := Stmt
ST._DB := This
; 19:53 2023. 10. 18. TypeList!! Én voltam!!
for k in TL
TL[k]:=Format("{:T}", TL[k])
ST._TL := TL
This._Stmts[Stmt] := Stmt
Return True
}
; ===================================================================================================================
; METHOD Query Get "recordset" object for prepared SELECT query
; Parameters: SQL - SQL SELECT statement
; ByRef RS - Variable to store the result object (Class _RecordSet)
; Return values: On success - True, RS contains the result object
; On failure - False, ErrorMsg / ErrorCode contain additional information
; ===================================================================================================================
Query(SQL, ByRef RS) {
RS := ""
This.ErrorMsg := ""
This.ErrorCode := 0
This.SQL := SQL
ColumnCount := 0
HasRows := False
If !(This._Handle) {
This.ErrorMsg := "Invalid dadabase handle!"
Return False
}
Query := 0
This._StrToUTF8(SQL, UTF8)
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_prepare_v2", "Ptr", This._Handle, "Ptr", &UTF8, "Int", -1
, "UPtrP", Query, "Ptr", 0, "Cdecl Int")
If (ErrorLeveL) {
This.ErrorMsg := "DLLCall sqlite3_prepare_v2 failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := This._ErrMsg()
This.ErrorCode := RC
Return False
}
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_column_count", "Ptr", Query, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DLLCall sqlite3_column_count failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC < 1) {
This.ErrorMsg := "Query result is empty!"
This.ErrorCode := This._ReturnCode("SQLITE_EMPTY")
Return False
}
ColumnCount := RC
Names := []
Loop, %RC% {
StrPtr := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_column_name", "Ptr", Query, "Int", A_Index - 1, "Cdecl UPtr")
If (ErrorLevel) {
This.ErrorMsg := "DLLCall sqlite3_column_name failed!"
This.ErrorCode := ErrorLevel
Return False
}
Names[A_Index] := StrGet(StrPtr, "UTF-8")
}
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_step", "Ptr", Query, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DLLCall sqlite3_step failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC = This._ReturnCode("SQLITE_ROW"))
HasRows := True
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_reset", "Ptr", Query, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DLLCall sqlite3_reset failed!"
This.ErrorCode := ErrorLevel
Return False
}
RS := new This._RecordSet
RS.ColumnCount := ColumnCount
RS.ColumnNames := Names
RS.HasNames := True
RS.HasRows := HasRows
RS._Handle := Query
RS._DB := This
This._Queries[Query] := Query
Return True
}
; ===================================================================================================================
; METHOD CreateScalarFunc Create a scalar application defined function
; Parameters: Name - the name of the function
; Args - the number of arguments that the SQL function takes
; Func - a pointer to AHK functions that implement the SQL function
; Enc - specifies what text encoding this SQL function prefers for its parameters
; Param - an arbitrary pointer accessible within the funtion with sqlite3_user_data()
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; Documentation: www.sqlite.org/c3ref/create_function.html
; ===================================================================================================================
CreateScalarFunc(Name, Args, Func, Enc := 0x0801, Param := 0) {
; SQLITE_DETERMINISTIC = 0x0800 - the function will always return the same result given the same inputs
; within a single SQL statement
; SQLITE_UTF8 = 0x0001
This.ErrorMsg := ""
This.ErrorCode := 0
If !(This._Handle) {
This.ErrorMsg := "Invalid database handle!"
Return False
}
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_create_function", "Ptr", This._Handle, "AStr", Name, "Int", Args, "Int", Enc
, "Ptr", Param, "Ptr", Func, "Ptr", 0, "Ptr", 0, "Cdecl Int")
If (ErrorLeveL) {
This.ErrorMsg := "DllCall sqlite3_create_function failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := This._ErrMsg()
This.ErrorCode := RC
Return False
}
Return True
}
; ===================================================================================================================
; METHOD LastInsertRowID Get the ROWID of the last inserted row
; Parameters: ByRef RowID - Variable to store the ROWID
; Return values: On success - True, RowID contains the ROWID
; On failure - False, ErrorMsg / ErrorCode contain additional information
; ===================================================================================================================
LastInsertRowID(ByRef RowID) {
This.ErrorMsg := ""
This.ErrorCode := 0
This.SQL := ""
If !(This._Handle) {
This.ErrorMsg := "Invalid database handle!"
Return False
}
RowID := 0
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_last_insert_rowid", "Ptr", This._Handle, "Cdecl Int64")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_last_insert_rowid failed!"
This.ErrorCode := ErrorLevel
Return False
}
RowID := RC
Return True
}
; ===================================================================================================================
; METHOD TotalChanges Get the number of changed rows since connecting to the database
; Parameters: ByRef Rows - Variable to store the number of rows
; Return values: On success - True, Rows contains the number of rows
; On failure - False, ErrorMsg / ErrorCode contain additional information
; ===================================================================================================================
TotalChanges(ByRef Rows) {
This.ErrorMsg := ""
This.ErrorCode := 0
This.SQL := ""
If !(This._Handle) {
This.ErrorMsg := "Invalid database handle!"
Return False
}
Rows := 0
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_total_changes", "Ptr", This._Handle, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_total_changes failed!"
This.ErrorCode := ErrorLevel
Return False
}
Rows := RC
Return True
}
; ===================================================================================================================
; METHOD SetTimeout Set the timeout to wait before SQLITE_BUSY or SQLITE_IOERR_BLOCKED is returned,
; when a table is locked.
; Parameters: TimeOut - Time to wait in milliseconds
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; ===================================================================================================================
SetTimeout(Timeout := 1000) {
This.ErrorMsg := ""
This.ErrorCode := 0
This.SQL := ""
If !(This._Handle) {
This.ErrorMsg := "Invalid database handle!"
Return False
}
If Timeout Is Not Integer
Timeout := 1000
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_busy_timeout", "Ptr", This._Handle, "Int", Timeout, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_busy_timeout failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := This._ErrMsg()
This.ErrorCode := RC
Return False
}
Return True
}
; ===================================================================================================================
; METHOD EscapeStr Escapes special characters in a string to be used as field content
; Parameters: Str - String to be escaped
; Quote - Add single quotes around the outside of the total string (True / False)
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; ===================================================================================================================
EscapeStr(ByRef Str, Quote := True) {
This.ErrorMsg := ""
This.ErrorCode := 0
This.SQL := ""
If !(This._Handle) {
This.ErrorMsg := "Invalid database handle!"
Return False
}
If Str Is Number
Return True
VarSetCapacity(OP, 16, 0)
StrPut(Quote ? "%Q" : "%q", &OP, "UTF-8")
This._StrToUTF8(Str, UTF8)
Ptr := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_mprintf", "Ptr", &OP, "Ptr", &UTF8, "Cdecl UPtr")
If (ErrorLevel) {
This.ErrorMsg := "DllCall sqlite3_mprintf failed!"
This.ErrorCode := ErrorLevel
Return False
}
Str := This._UTF8ToStr(Ptr)
DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_free", "Ptr", Ptr, "Cdecl")
Return True
}
; ===================================================================================================================
; METHOD StoreBLOB Use BLOBs as parameters of an INSERT/UPDATE/REPLACE statement.
; Parameters: SQL - SQL statement to be compiled
; BlobArray - Array of objects containing two keys/value pairs:
; Addr : Address of the (variable containing the) BLOB.
; Size : Size of the BLOB in bytes.
; Return values: On success - True
; On failure - False, ErrorMsg / ErrorCode contain additional information
; Remarks: For each BLOB in the row you have to specify a ? parameter within the statement. The
; parameters are numbered automatically from left to right starting with 1.
; For each parameter you have to pass an object within BlobArray containing the address
; and the size of the BLOB.
; ===================================================================================================================
StoreBLOB(SQL, BlobArray) {
Static SQLITE_STATIC := 0
Static SQLITE_TRANSIENT := -1
This.ErrorMsg := ""
This.ErrorCode := 0
If !(This._Handle) {
This.ErrorMsg := "Invalid database handle!"
Return False
}
If !RegExMatch(SQL, "i)^\s*(INSERT|UPDATE|REPLACE)\s") {
This.ErrorMsg := A_ThisFunc . " requires an INSERT/UPDATE/REPLACE statement!"
Return False
}
Query := 0
This._StrToUTF8(SQL, UTF8)
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_prepare_v2", "Ptr", This._Handle, "Ptr", &UTF8, "Int", -1
, "UPtrP", Query, "Ptr", 0, "Cdecl Int")
If (ErrorLeveL) {
This.ErrorMsg := A_ThisFunc . ": DllCall sqlite3_prepare_v2 failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := A_ThisFunc . ": " . This._ErrMsg()
This.ErrorCode := RC
Return False
}
For BlobNum, Blob In BlobArray {
If !(Blob.Addr) || !(Blob.Size) {
This.ErrorMsg := A_ThisFunc . ": Invalid parameter BlobArray!"
This.ErrorCode := ErrorLevel
Return False
}
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_bind_blob", "Ptr", Query, "Int", BlobNum, "Ptr", Blob.Addr
, "Int", Blob.Size, "Ptr", SQLITE_STATIC, "Cdecl Int")
If (ErrorLeveL) {
This.ErrorMsg := A_ThisFunc . ": DllCall sqlite3_bind_blob failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := A_ThisFunc . ": " . This._ErrMsg()
This.ErrorCode := RC
Return False
}
}
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_step", "Ptr", Query, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := A_ThisFunc . ": DllCall sqlite3_step failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) && (RC <> This._ReturnCode("SQLITE_DONE")) {
This.ErrorMsg := A_ThisFunc . ": " . This._ErrMsg()
This.ErrorCode := RC
Return False
}
RC := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_finalize", "Ptr", Query, "Cdecl Int")
If (ErrorLevel) {
This.ErrorMsg := A_ThisFunc . ": DllCall sqlite3_finalize failed!"
This.ErrorCode := ErrorLevel
Return False
}
If (RC) {
This.ErrorMsg := A_ThisFunc . ": " . This._ErrMsg()
This.ErrorCode := RC
Return False
}
Return True
}
}
; ======================================================================================================================
; Exemplary custom callback function regexp()
; Parameters: Context - handle to a sqlite3_context object
; ArgC - number of elements passed in Values (must be 2 for this function)
; Values - pointer to an array of pointers which can be passed to sqlite3_value_text():
; 1. Needle
; 2. Haystack
; Return values: Call sqlite3_result_int() passing 1 (True) for a match, otherwise pass 0 (False).
; ======================================================================================================================
SQLiteDB_RegExp(Context, ArgC, Values) {
Result := 0
If (ArgC = 2) {
AddrN := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_value_text", "Ptr", NumGet(Values + 0, "UPtr"), "Cdecl UPtr")
AddrH := DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_value_text", "Ptr", NumGet(Values + A_PtrSize, "UPtr"), "Cdecl UPtr")
Result := RegExMatch(StrGet(AddrH, "UTF-8"), StrGet(AddrN, "UTF-8"))
}
DllCall("C:\Program Files\AutoHotkey\Extras\DLL\SQLite3.dll\sqlite3_result_int", "Ptr", Context, "Int", !!Result, "Cdecl") ; 0 = false, 1 = trus
}
