├── Include
    └── SQLite3
    │   ├── Backup.mqh
    │   ├── Blob.mqh
    │   ├── Common.mqh
    │   ├── Defines.mqh
    │   ├── Imports.mqh
    │   ├── SQLite3.mqh
    │   ├── Statement.mqh
    │   └── Vfs.mqh
├── LICENSE
├── Library
    ├── MT4
    │   └── sqlite3.dll
    └── MT5
    │   └── sqlite3.dll
├── README.md
└── Scripts
    └── Test
        └── TestSQLite3.mq4


/Include/SQLite3/Backup.mqh:
--------------------------------------------------------------------------------
 1 | //+------------------------------------------------------------------+
 2 | //|                                                       Backup.mqh |
 3 | //|                                          Copyright 2017, Li Ding |
 4 | //|                                                dingmaotu@126.com |
 5 | //+------------------------------------------------------------------+
 6 | #property strict
 7 | 
 8 | #include "SQLite3.mqh"
 9 | //+------------------------------------------------------------------+
10 | //| Backup operation                                                 |
11 | //+------------------------------------------------------------------+
12 | class Backup
13 |   {
14 | private:
15 |    intptr_t          m_ref;
16 | public:
17 |                      Backup(const SQLite3 &dest,string destDbName,const SQLite3 &src,string srcDbName)
18 |      {
19 |       uchar destDbNameBuf[];
20 |       uchar srcDbNameBuf[];
21 |       StringToUtf8(destDbName,destDbNameBuf);
22 |       StringToUtf8(srcDbName,srcDbNameBuf);
23 |       m_ref=sqlite3_backup_init(dest.ref(),destDbNameBuf,src.ref(),srcDbNameBuf);
24 |      }
25 | 
26 |                     ~Backup() {sqlite3_backup_finish(m_ref);}
27 |    bool              isValid() const {return m_ref!=NULL;}
28 |    intptr_t          ref() const {return m_ref;}
29 | 
30 |    // SQLITE_OK | SQLITE_DONE for success completion
31 |    // SQLITE_READONLY | SQLITE_IOERR_* | SQLITE_NOMEM is condidered fatal
32 |    // SQLITE_BUSY if timeout waiting resource lock
33 |    int               step(int pages) {return sqlite3_backup_step(m_ref,pages);}
34 |    int               getPageCount() const {return sqlite3_backup_pagecount(m_ref);}
35 |    int               getRemaining() const {return sqlite3_backup_remaining(m_ref);}
36 |   };
37 | //+------------------------------------------------------------------+
38 | 


--------------------------------------------------------------------------------
/Include/SQLite3/Blob.mqh:
--------------------------------------------------------------------------------
 1 | //+------------------------------------------------------------------+
 2 | //|                                                         Blob.mqh |
 3 | //|                                          Copyright 2017, Li Ding |
 4 | //|                                                dingmaotu@126.com |
 5 | //+------------------------------------------------------------------+
 6 | #property strict
 7 | 
 8 | #include "SQLite3.mqh"
 9 | //+------------------------------------------------------------------+
10 | //| Blob for streaming IO                                            |
11 | //+------------------------------------------------------------------+
12 | class Blob
13 |   {
14 | private:
15 |    bool              m_valid;
16 |    intptr_t          m_ref;
17 | public:
18 |                      Blob(const SQLite3 &conn,string db,string table,string column,long row,bool readonly=true)
19 |      {
20 |       char zDb[];
21 |       char zTable[];
22 |       char zColumn[];
23 |       StringToUtf8(db,zDb);
24 |       StringToUtf8(table,zTable);
25 |       StringToUtf8(column,zColumn);
26 | 
27 |       int res=sqlite3_blob_open(conn.ref(),zDb,zTable,zColumn,row,readonly?0:1,m_ref);
28 |       m_valid=(res==SQLITE_OK);
29 |      }
30 |                     ~Blob() {if(m_valid) sqlite3_blob_close(m_ref);}
31 | 
32 |    bool              isValid() const {return m_valid;}
33 |    intptr_t          ref() const {return m_ref;}
34 | 
35 |    int               size() const {return sqlite3_blob_bytes(m_ref); }
36 | 
37 |    int               moveTo(long rowId) {return sqlite3_blob_reopen(m_ref,rowId);}
38 |    int               read(uchar &buf[],int size,int offset) {return sqlite3_blob_read(m_ref,buf,size,offset);}
39 |    int               write(const uchar &buf[],int size,int offset) {return sqlite3_blob_write(m_ref,buf,size,offset);}
40 |   };
41 | //+------------------------------------------------------------------+
42 | 


--------------------------------------------------------------------------------
/Include/SQLite3/Common.mqh:
--------------------------------------------------------------------------------
  1 | //+------------------------------------------------------------------+
  2 | //|                                                       Common.mqh |
  3 | //|                                     Copyright 2016-2017, Li Ding |
  4 | //|                                                dingmaotu@126.com |
  5 | //+------------------------------------------------------------------+
  6 | #property strict
  7 | 
  8 | // Assume MT5 is 64bit, which is the default.
  9 | // Even though MT5 can be 32bit, there is no way to detect this
 10 | // by using preprocessor macros. Instead, MetaQuotes provides a
 11 | // function called IsX64 to detect this dynamically
 12 | 
 13 | // This is just absurd. Why do you want to know the bitness of
 14 | // the runtime? To define pointer related entities at compile time!
 15 | // All integer types in MQL is uniform on both 32bit or 64bit
 16 | // architectures, so it is almost useless to have a runtime function IsX64.
 17 | 
 18 | // Why not a __X64__?
 19 | #ifdef __MQL5__
 20 | #define __X64__
 21 | #endif
 22 | 
 23 | #ifdef __X64__
 24 | #define intptr_t long
 25 | #define uintptr_t ulong
 26 | #define size_t long
 27 | #else
 28 | #define intptr_t int
 29 | #define uintptr_t uint
 30 | #define size_t int
 31 | #endif
 32 | 
 33 | #import "kernel32.dll"
 34 | void RtlMoveMemory(intptr_t dest,const uchar &array[],size_t length);
 35 | void RtlMoveMemory(uchar &array[],intptr_t src,size_t length);
 36 | int lstrlen(intptr_t psz);
 37 | int MultiByteToWideChar(uint   codePage,
 38 |                         uint   flags,
 39 |                         const  intptr_t multiByteString,
 40 |                         int    lengthMultiByte,
 41 |                         string &str,
 42 |                         int    length
 43 |                         );
 44 | #import
 45 | //+------------------------------------------------------------------+
 46 | //| Copy the memory contents pointed by src to array                 |
 47 | //| array parameter should be initialized to the desired size        |
 48 | //+------------------------------------------------------------------+
 49 | void ArrayFromPointer(uchar &array[],intptr_t src,int count=WHOLE_ARRAY)
 50 |   {
 51 |    int size=(count==WHOLE_ARRAY)?ArraySize(array):count;
 52 |    RtlMoveMemory(array,src,(size_t)size);
 53 |   }
 54 | //+------------------------------------------------------------------+
 55 | //| Copy array to the memory pointed by dest                         |
 56 | //+------------------------------------------------------------------+
 57 | void ArrayToPointer(const uchar &array[],intptr_t dest,int count=WHOLE_ARRAY)
 58 |   {
 59 |    int size=(count==WHOLE_ARRAY)?ArraySize(array):count;
 60 |    RtlMoveMemory(dest,array,(size_t)size);
 61 |   }
 62 | //+------------------------------------------------------------------+
 63 | //| Read a valid utf-8 string to the MQL environment                 |
 64 | //| With this function, there is no need to copy the string to char  |
 65 | //| array, and convert with CharArrayToString                        |
 66 | //+------------------------------------------------------------------+
 67 | string StringFromUtf8Pointer(intptr_t psz,int len)
 68 |   {
 69 |    if(len < 0) return NULL;
 70 |    string res;
 71 |    int required=MultiByteToWideChar(CP_UTF8,0,psz,len,res,0);
 72 |    StringInit(res,required);
 73 |    int resLength = MultiByteToWideChar(CP_UTF8,0,psz,len,res,required);
 74 |    if(resLength != required)
 75 |      {
 76 |       return NULL;
 77 |      }
 78 |    else
 79 |      {
 80 |       return res;
 81 |      }
 82 |   }
 83 | //+------------------------------------------------------------------+
 84 | //| for null-terminated string                                       |
 85 | //+------------------------------------------------------------------+
 86 | string StringFromUtf8Pointer(intptr_t psz)
 87 |   {
 88 |    if(psz==0) return NULL;
 89 |    int len=lstrlen(psz);
 90 |    if(len==0) return NULL;
 91 |    return StringFromUtf8Pointer(psz, len);
 92 |   }
 93 | //+------------------------------------------------------------------+
 94 | //| Convert a utf-8 byte array to a string                           |
 95 | //+------------------------------------------------------------------+
 96 | string StringFromUtf8(const uchar &utf8[])
 97 |   {
 98 |    return CharArrayToString(utf8, 0, -1, CP_UTF8);
 99 |   }
100 | //+------------------------------------------------------------------+
101 | //| Convert a string to a utf-8 byte array                           |
102 | //+------------------------------------------------------------------+
103 | void StringToUtf8(const string str,uchar &utf8[],bool ending=true)
104 |   {
105 |    if(!ending && str=="") return;
106 |    int count=ending ? -1 : StringLen(str);
107 |    StringToCharArray(str,utf8,0,count,CP_UTF8);
108 |   }
109 | //+------------------------------------------------------------------+
110 | 


--------------------------------------------------------------------------------
/Include/SQLite3/Defines.mqh:
--------------------------------------------------------------------------------
  1 | //+------------------------------------------------------------------+
  2 | //|                                                      Defines.mqh |
  3 | //|                                          Copyright 2017, Li Ding |
  4 | //|                                                dingmaotu@126.com |
  5 | //+------------------------------------------------------------------+
  6 | #property strict
  7 | 
  8 | // The defines come from sqlite3.h
  9 | 
 10 | #define SQLITE_VERSION        "3.18.0"
 11 | #define SQLITE_VERSION_NUMBER 3018000
 12 | #define SQLITE_SOURCE_ID      "2017-03-28 18:48:43 424a0d380332858ee55bdebc4af3789f74e70a2b3ba1cf29d84b9b4bcf3e2e37"
 13 | 
 14 | /*
 15 | ** CAPI3REF: Fundamental Datatypes
 16 | ** KEYWORDS: SQLITE_TEXT
 17 | **
 18 | ** (Every value in SQLite has one of five fundamental datatypes:
 19 | **
 20 | ** 1. 64-bit signed integer
 21 | ** 2. 64-bit IEEE floating point number
 22 | ** 3. string
 23 | ** 4. BLOB
 24 | ** 5. NULL
 25 | */
 26 | #define SQLITE_INTEGER  1
 27 | #define SQLITE_FLOAT    2
 28 | #define SQLITE_BLOB     4
 29 | #define SQLITE_NULL     5
 30 | #define SQLITE_TEXT     3
 31 | #define SQLITE3_TEXT    3 // use only if link with both sqlite2 and sqlite3
 32 | 
 33 | /*
 34 | ** CAPI3REF: Text Encodings
 35 | **
 36 | ** These constant define integer codes that represent the various
 37 | ** text encodings supported by SQLite.
 38 | */
 39 | #define SQLITE_UTF8           1    /* IMP: R-37514-35566 */
 40 | #define SQLITE_UTF16LE        2    /* IMP: R-03371-37637 */
 41 | #define SQLITE_UTF16BE        3    /* IMP: R-51971-34154 */
 42 | #define SQLITE_UTF16          4    /* Use native byte order */
 43 | #define SQLITE_ANY            5    /* Deprecated */
 44 | #define SQLITE_UTF16_ALIGNED  8    /* sqlite3_create_collation only */
 45 | 
 46 | /*
 47 | ** CAPI3REF: Result Codes
 48 | ** KEYWORDS: {result code definitions}
 49 | **
 50 | ** Many SQLite functions return an integer result code from the set shown
 51 | ** here in order to indicate success or failure.
 52 | **
 53 | ** New error codes may be added in future versions of SQLite.
 54 | **
 55 | ** See also: [extended result code definitions]
 56 | */
 57 | #define SQLITE_OK           0   /* Successful result */
 58 | /* beginning-of-error-codes */
 59 | #define SQLITE_ERROR        1   /* SQL error or missing database */
 60 | #define SQLITE_INTERNAL     2   /* Internal logic error in SQLite */
 61 | #define SQLITE_PERM         3   /* Access permission denied */
 62 | #define SQLITE_ABORT        4   /* Callback routine requested an abort */
 63 | #define SQLITE_BUSY         5   /* The database file is locked */
 64 | #define SQLITE_LOCKED       6   /* A table in the database is locked */
 65 | #define SQLITE_NOMEM        7   /* A malloc() failed */
 66 | #define SQLITE_READONLY     8   /* Attempt to write a readonly database */
 67 | #define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite3_interrupt()*/
 68 | #define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */
 69 | #define SQLITE_CORRUPT     11   /* The database disk image is malformed */
 70 | #define SQLITE_NOTFOUND    12   /* Unknown opcode in sqlite3_file_control() */
 71 | #define SQLITE_FULL        13   /* Insertion failed because database is full */
 72 | #define SQLITE_CANTOPEN    14   /* Unable to open the database file */
 73 | #define SQLITE_PROTOCOL    15   /* Database lock protocol error */
 74 | #define SQLITE_EMPTY       16   /* Database is empty */
 75 | #define SQLITE_SCHEMA      17   /* The database schema changed */
 76 | #define SQLITE_TOOBIG      18   /* String or BLOB exceeds size limit */
 77 | #define SQLITE_CONSTRAINT  19   /* Abort due to constraint violation */
 78 | #define SQLITE_MISMATCH    20   /* Data type mismatch */
 79 | #define SQLITE_MISUSE      21   /* Library used incorrectly */
 80 | #define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
 81 | #define SQLITE_AUTH        23   /* Authorization denied */
 82 | #define SQLITE_FORMAT      24   /* Auxiliary database format error */
 83 | #define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */
 84 | #define SQLITE_NOTADB      26   /* File opened that is not a database file */
 85 | #define SQLITE_NOTICE      27   /* Notifications from sqlite3_log() */
 86 | #define SQLITE_WARNING     28   /* Warnings from sqlite3_log() */
 87 | #define SQLITE_ROW         100  /* sqlite3_step() has another row ready */
 88 | #define SQLITE_DONE        101  /* sqlite3_step() has finished executing */
 89 | /* end-of-error-codes */
 90 | 
 91 | /*
 92 | ** CAPI3REF: Extended Result Codes
 93 | ** KEYWORDS: {extended result code definitions}
 94 | **
 95 | ** In its default configuration, SQLite API routines return one of 30 integer
 96 | ** [result codes].  However, experience has shown that many of
 97 | ** these result codes are too coarse-grained.  They do not provide as
 98 | ** much information about problems as programmers might like.  In an effort to
 99 | ** address this, newer versions of SQLite (version 3.3.8 [dateof:3.3.8]
100 | ** and later) include
101 | ** support for additional result codes that provide more detailed information
102 | ** about errors. These [extended result codes] are enabled or disabled
103 | ** on a per database connection basis using the
104 | ** [sqlite3_extended_result_codes()] API.  Or, the extended code for
105 | ** the most recent error can be obtained using
106 | ** [sqlite3_extended_errcode()].
107 | */
108 | #define SQLITE_IOERR_READ              (SQLITE_IOERR | (1<<8))
109 | #define SQLITE_IOERR_SHORT_READ        (SQLITE_IOERR | (2<<8))
110 | #define SQLITE_IOERR_WRITE             (SQLITE_IOERR | (3<<8))
111 | #define SQLITE_IOERR_FSYNC             (SQLITE_IOERR | (4<<8))
112 | #define SQLITE_IOERR_DIR_FSYNC         (SQLITE_IOERR | (5<<8))
113 | #define SQLITE_IOERR_TRUNCATE          (SQLITE_IOERR | (6<<8))
114 | #define SQLITE_IOERR_FSTAT             (SQLITE_IOERR | (7<<8))
115 | #define SQLITE_IOERR_UNLOCK            (SQLITE_IOERR | (8<<8))
116 | #define SQLITE_IOERR_RDLOCK            (SQLITE_IOERR | (9<<8))
117 | #define SQLITE_IOERR_DELETE            (SQLITE_IOERR | (10<<8))
118 | #define SQLITE_IOERR_BLOCKED           (SQLITE_IOERR | (11<<8))
119 | #define SQLITE_IOERR_NOMEM             (SQLITE_IOERR | (12<<8))
120 | #define SQLITE_IOERR_ACCESS            (SQLITE_IOERR | (13<<8))
121 | #define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))
122 | #define SQLITE_IOERR_LOCK              (SQLITE_IOERR | (15<<8))
123 | #define SQLITE_IOERR_CLOSE             (SQLITE_IOERR | (16<<8))
124 | #define SQLITE_IOERR_DIR_CLOSE         (SQLITE_IOERR | (17<<8))
125 | #define SQLITE_IOERR_SHMOPEN           (SQLITE_IOERR | (18<<8))
126 | #define SQLITE_IOERR_SHMSIZE           (SQLITE_IOERR | (19<<8))
127 | #define SQLITE_IOERR_SHMLOCK           (SQLITE_IOERR | (20<<8))
128 | #define SQLITE_IOERR_SHMMAP            (SQLITE_IOERR | (21<<8))
129 | #define SQLITE_IOERR_SEEK              (SQLITE_IOERR | (22<<8))
130 | #define SQLITE_IOERR_DELETE_NOENT      (SQLITE_IOERR | (23<<8))
131 | #define SQLITE_IOERR_MMAP              (SQLITE_IOERR | (24<<8))
132 | #define SQLITE_IOERR_GETTEMPPATH       (SQLITE_IOERR | (25<<8))
133 | #define SQLITE_IOERR_CONVPATH          (SQLITE_IOERR | (26<<8))
134 | #define SQLITE_IOERR_VNODE             (SQLITE_IOERR | (27<<8))
135 | #define SQLITE_IOERR_AUTH              (SQLITE_IOERR | (28<<8))
136 | #define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))
137 | #define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))
138 | #define SQLITE_BUSY_SNAPSHOT           (SQLITE_BUSY   |  (2<<8))
139 | #define SQLITE_CANTOPEN_NOTEMPDIR      (SQLITE_CANTOPEN | (1<<8))
140 | #define SQLITE_CANTOPEN_ISDIR          (SQLITE_CANTOPEN | (2<<8))
141 | #define SQLITE_CANTOPEN_FULLPATH       (SQLITE_CANTOPEN | (3<<8))
142 | #define SQLITE_CANTOPEN_CONVPATH       (SQLITE_CANTOPEN | (4<<8))
143 | #define SQLITE_CORRUPT_VTAB            (SQLITE_CORRUPT | (1<<8))
144 | #define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))
145 | #define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))
146 | #define SQLITE_READONLY_ROLLBACK       (SQLITE_READONLY | (3<<8))
147 | #define SQLITE_READONLY_DBMOVED        (SQLITE_READONLY | (4<<8))
148 | #define SQLITE_ABORT_ROLLBACK          (SQLITE_ABORT | (2<<8))
149 | #define SQLITE_CONSTRAINT_CHECK        (SQLITE_CONSTRAINT | (1<<8))
150 | #define SQLITE_CONSTRAINT_COMMITHOOK   (SQLITE_CONSTRAINT | (2<<8))
151 | #define SQLITE_CONSTRAINT_FOREIGNKEY   (SQLITE_CONSTRAINT | (3<<8))
152 | #define SQLITE_CONSTRAINT_FUNCTION     (SQLITE_CONSTRAINT | (4<<8))
153 | #define SQLITE_CONSTRAINT_NOTNULL      (SQLITE_CONSTRAINT | (5<<8))
154 | #define SQLITE_CONSTRAINT_PRIMARYKEY   (SQLITE_CONSTRAINT | (6<<8))
155 | #define SQLITE_CONSTRAINT_TRIGGER      (SQLITE_CONSTRAINT | (7<<8))
156 | #define SQLITE_CONSTRAINT_UNIQUE       (SQLITE_CONSTRAINT | (8<<8))
157 | #define SQLITE_CONSTRAINT_VTAB         (SQLITE_CONSTRAINT | (9<<8))
158 | #define SQLITE_CONSTRAINT_ROWID        (SQLITE_CONSTRAINT |(10<<8))
159 | #define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))
160 | #define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
161 | #define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))
162 | #define SQLITE_AUTH_USER               (SQLITE_AUTH | (1<<8))
163 | #define SQLITE_OK_LOAD_PERMANENTLY     (SQLITE_OK | (1<<8))
164 | 
165 | /*
166 | ** CAPI3REF: Flags For File Open Operations
167 | **
168 | ** These bit values are intended for use in the
169 | ** 3rd parameter to the [sqlite3_open_v2()] interface and
170 | ** in the 4th parameter to the [sqlite3_vfs.xOpen] method.
171 | */
172 | #define SQLITE_OPEN_READONLY         0x00000001  /* Ok for sqlite3_open_v2() */
173 | #define SQLITE_OPEN_READWRITE        0x00000002  /* Ok for sqlite3_open_v2() */
174 | #define SQLITE_OPEN_CREATE           0x00000004  /* Ok for sqlite3_open_v2() */
175 | #define SQLITE_OPEN_DELETEONCLOSE    0x00000008  /* VFS only */
176 | #define SQLITE_OPEN_EXCLUSIVE        0x00000010  /* VFS only */
177 | #define SQLITE_OPEN_AUTOPROXY        0x00000020  /* VFS only */
178 | #define SQLITE_OPEN_URI              0x00000040  /* Ok for sqlite3_open_v2() */
179 | #define SQLITE_OPEN_MEMORY           0x00000080  /* Ok for sqlite3_open_v2() */
180 | #define SQLITE_OPEN_MAIN_DB          0x00000100  /* VFS only */
181 | #define SQLITE_OPEN_TEMP_DB          0x00000200  /* VFS only */
182 | #define SQLITE_OPEN_TRANSIENT_DB     0x00000400  /* VFS only */
183 | #define SQLITE_OPEN_MAIN_JOURNAL     0x00000800  /* VFS only */
184 | #define SQLITE_OPEN_TEMP_JOURNAL     0x00001000  /* VFS only */
185 | #define SQLITE_OPEN_SUBJOURNAL       0x00002000  /* VFS only */
186 | #define SQLITE_OPEN_MASTER_JOURNAL   0x00004000  /* VFS only */
187 | #define SQLITE_OPEN_NOMUTEX          0x00008000  /* Ok for sqlite3_open_v2() */
188 | #define SQLITE_OPEN_FULLMUTEX        0x00010000  /* Ok for sqlite3_open_v2() */
189 | #define SQLITE_OPEN_SHAREDCACHE      0x00020000  /* Ok for sqlite3_open_v2() */
190 | #define SQLITE_OPEN_PRIVATECACHE     0x00040000  /* Ok for sqlite3_open_v2() */
191 | #define SQLITE_OPEN_WAL              0x00080000  /* VFS only */
192 | 
193 | /* Reserved:                         0x00F00000 */
194 | 
195 | /*
196 | ** CAPI3REF: Configuration Options
197 | ** KEYWORDS: {configuration option}
198 | **
199 | ** These constants are the available integer configuration options that
200 | ** can be passed as the first argument to the [sqlite3_config()] interface.
201 | **
202 | ** New configuration options may be added in future releases of SQLite.
203 | ** Existing configuration options might be discontinued.  Applications
204 | ** should check the return code from [sqlite3_config()] to make sure that
205 | ** the call worked.  The [sqlite3_config()] interface will return a
206 | ** non-zero [error code] if a discontinued or unsupported configuration option
207 | ** is invoked.
208 | **
209 | */
210 | #define SQLITE_CONFIG_SINGLETHREAD  1  /* nil */
211 | #define SQLITE_CONFIG_MULTITHREAD   2  /* nil */
212 | #define SQLITE_CONFIG_SERIALIZED    3  /* nil */
213 | #define SQLITE_CONFIG_MALLOC        4  /* sqlite3_mem_methods* */
214 | #define SQLITE_CONFIG_GETMALLOC     5  /* sqlite3_mem_methods* */
215 | #define SQLITE_CONFIG_SCRATCH       6  /* void*, int sz, int N */
216 | #define SQLITE_CONFIG_PAGECACHE     7  /* void*, int sz, int N */
217 | #define SQLITE_CONFIG_HEAP          8  /* void*, int nByte, int min */
218 | #define SQLITE_CONFIG_MEMSTATUS     9  /* boolean */
219 | #define SQLITE_CONFIG_MUTEX        10  /* sqlite3_mutex_methods* */
220 | #define SQLITE_CONFIG_GETMUTEX     11  /* sqlite3_mutex_methods* */
221 | /* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */
222 | #define SQLITE_CONFIG_LOOKASIDE    13  /* int int */
223 | #define SQLITE_CONFIG_PCACHE       14  /* no-op */
224 | #define SQLITE_CONFIG_GETPCACHE    15  /* no-op */
225 | #define SQLITE_CONFIG_LOG          16  /* xFunc, void* */
226 | #define SQLITE_CONFIG_URI          17  /* int */
227 | #define SQLITE_CONFIG_PCACHE2      18  /* sqlite3_pcache_methods2* */
228 | #define SQLITE_CONFIG_GETPCACHE2   19  /* sqlite3_pcache_methods2* */
229 | #define SQLITE_CONFIG_COVERING_INDEX_SCAN 20  /* int */
230 | #define SQLITE_CONFIG_SQLLOG       21  /* xSqllog, void* */
231 | #define SQLITE_CONFIG_MMAP_SIZE    22  /* sqlite3_int64, sqlite3_int64 */
232 | #define SQLITE_CONFIG_WIN32_HEAPSIZE      23  /* int nByte */
233 | #define SQLITE_CONFIG_PCACHE_HDRSZ        24  /* int *psz */
234 | #define SQLITE_CONFIG_PMASZ               25  /* unsigned int szPma */
235 | #define SQLITE_CONFIG_STMTJRNL_SPILL      26  /* int nByte */
236 | /*
237 | ** CAPI3REF: Database Connection Configuration Options
238 | **
239 | ** These constants are the available integer configuration options that
240 | ** can be passed as the second argument to the [sqlite3_db_config()] interface.
241 | **
242 | ** New configuration options may be added in future releases of SQLite.
243 | ** Existing configuration options might be discontinued.  Applications
244 | ** should check the return code from [sqlite3_db_config()] to make sure that
245 | ** the call worked.  ^The [sqlite3_db_config()] interface will return a
246 | ** non-zero [error code] if a discontinued or unsupported configuration option
247 | ** is invoked.
248 | */
249 | #define SQLITE_DBCONFIG_MAINDBNAME            1000 /* const char* */
250 | #define SQLITE_DBCONFIG_LOOKASIDE             1001 /* void* int int */
251 | #define SQLITE_DBCONFIG_ENABLE_FKEY           1002 /* int int* */
252 | #define SQLITE_DBCONFIG_ENABLE_TRIGGER        1003 /* int int* */
253 | #define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 /* int int* */
254 | #define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 /* int int* */
255 | #define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE      1006 /* int int* */
256 | 
257 | /*
258 | ** CAPI3REF: Run-Time Limit Categories
259 | ** KEYWORDS: {limit category} {*limit categories}
260 | **
261 | ** These constants define various performance limits
262 | ** that can be lowered at run-time using [sqlite3_limit()].
263 | ** The synopsis of the meanings of the various limits is shown below.
264 | ** Additional information is available at [limits | Limits in SQLite].
265 | */
266 | #define SQLITE_LIMIT_LENGTH                    0
267 | #define SQLITE_LIMIT_SQL_LENGTH                1
268 | #define SQLITE_LIMIT_COLUMN                    2
269 | #define SQLITE_LIMIT_EXPR_DEPTH                3
270 | #define SQLITE_LIMIT_COMPOUND_SELECT           4
271 | #define SQLITE_LIMIT_VDBE_OP                   5
272 | #define SQLITE_LIMIT_FUNCTION_ARG              6
273 | #define SQLITE_LIMIT_ATTACHED                  7
274 | #define SQLITE_LIMIT_LIKE_PATTERN_LENGTH       8
275 | #define SQLITE_LIMIT_VARIABLE_NUMBER           9
276 | #define SQLITE_LIMIT_TRIGGER_DEPTH            10
277 | #define SQLITE_LIMIT_WORKER_THREADS           11
278 | 
279 | // Constants Defining Special Destructor Behavior
280 | #define SQLITE_STATIC       0
281 | #define SQLITE_TRANSIENT   -1
282 | 
283 | // Statment status counters
284 | #define SQLITE_STMTSTATUS_FULLSCAN_STEP     1
285 | #define SQLITE_STMTSTATUS_SORT              2
286 | #define SQLITE_STMTSTATUS_AUTOINDEX         3
287 | #define SQLITE_STMTSTATUS_VM_STEP           4
288 | 
289 | // Checkpoint mode
290 | #define SQLITE_CHECKPOINT_PASSIVE  0  /* Do as much as possible w/o blocking */
291 | #define SQLITE_CHECKPOINT_FULL     1  /* Wait for writers, then checkpoint */
292 | #define SQLITE_CHECKPOINT_RESTART  2  /* Like FULL but wait for for readers */
293 | #define SQLITE_CHECKPOINT_TRUNCATE 3  /* Like RESTART but also truncate WAL */
294 | //+------------------------------------------------------------------+
295 | 


--------------------------------------------------------------------------------
/Include/SQLite3/Imports.mqh:
--------------------------------------------------------------------------------
  1 | //+------------------------------------------------------------------+
  2 | //|                                                      Imports.mqh |
  3 | //|                                          Copyright 2017, Li Ding |
  4 | //|                                                dingmaotu@126.com |
  5 | //+------------------------------------------------------------------+
  6 | #property strict
  7 | 
  8 | // always use UTF-8 for all character strings
  9 | // always use v2 for advanced features
 10 | // only import essential APIs and implement others in MQL
 11 | #include "Common.mqh"
 12 | #include "Defines.mqh"
 13 | 
 14 | #import "sqlite3.dll"
 15 | 
 16 | intptr_t sqlite3_libversion(void);
 17 | intptr_t sqlite3_sourceid(void);
 18 | int sqlite3_libversion_number(void);
 19 | 
 20 | int sqlite3_config(int);
 21 | int sqlite3_config(int,int);
 22 | int sqlite3_config(int,long);
 23 | int sqlite3_config(int,int,int);
 24 | 
 25 | int sqlite3_threadsafe(void);
 26 | int sqlite3_enable_shared_cache(bool);
 27 | 
 28 | int sqlite3_extended_result_codes(intptr_t,bool onoff);
 29 | int sqlite3_enable_load_extension(intptr_t,bool onoff);
 30 | int sqlite3_load_extension(
 31 |                            intptr_t,/* Load the extension into this database connection */
 32 |                            const char &zFile[],/* Name of the shared library containing extension */
 33 |                            const char &zProc[],/* Entry point.  Derived from zFile if 0 */
 34 |                            intptr_t &pzErrMsg  /* Put error message here if not 0 */
 35 |                            );
 36 | int sqlite3_load_extension(
 37 |                            intptr_t,/* Load the extension into this database connection */
 38 |                            const char &zFile[],/* Name of the shared library containing extension */
 39 |                            intptr_t zProc,/* Entry point. Derived from zFile if 0 */
 40 |                            intptr_t &pzErrMsg  /* Put error message here if not 0 */
 41 |                            );
 42 | 
 43 | int sqlite3_get_autocommit(intptr_t);
 44 | 
 45 | int sqlite3_initialize(void);
 46 | int sqlite3_shutdown(void);
 47 | 
 48 | int sqlite3_release_memory(int);
 49 | long sqlite3_soft_heap_limit64(long);
 50 | 
 51 | long sqlite3_memory_used(void);
 52 | long sqlite3_memory_highwater(bool resetFlag);
 53 | 
 54 | void sqlite3_free(intptr_t);
 55 | 
 56 | // sqlite3 connection management
 57 | int sqlite3_open_v2(
 58 |                     const char &filename[],/* Database filename (UTF-8) */
 59 |                     intptr_t &pDb,/* OUT: SQLite db handle (sqlite3**) */
 60 |                     int flags,/* Flags */
 61 |                     intptr_t zVfs/* Name of VFS module to use */
 62 |                     );
 63 | int sqlite3_open_v2(
 64 |                     const char &filename[],/* Database filename (UTF-8) */
 65 |                     intptr_t &pDb,/* OUT: SQLite db handle (sqlite3**) */
 66 |                     int flags,/* Flags */
 67 |                     const char &zVfs[]/* Name of VFS module to use */
 68 |                     );
 69 | int sqlite3_limit(intptr_t,int id,int newVal);
 70 | int sqlite3_busy_timeout(intptr_t,int ms);
 71 | 
 72 | intptr_t sqlite3_db_filename(intptr_t,const char &zDbName[]);
 73 | int sqlite3_db_readonly(intptr_t,const char &zDbName[]);
 74 | int sqlite3_table_column_metadata(
 75 |                                   intptr_t,/* Connection handle */
 76 |                                   const char &zDbName[],/* Database name or NULL */
 77 |                                   const char &zTableName[],/* Table name */
 78 |                                   const char &zColumnName[],/* Column name */
 79 |                                   intptr_t   &pzDataType,/* OUTPUT: Declared data type */
 80 |                                   intptr_t   &pzCollSeq,/* OUTPUT: Collation sequence name */
 81 |                                   bool &isNotNull,/* OUTPUT: True if NOT NULL constraint exists */
 82 |                                   bool &isPrimaryKey,/* OUTPUT: True if column part of PK */
 83 |                                   bool &isAutoinc/* OUTPUT: True if column is auto-increment */
 84 |                                   );
 85 | 
 86 | int sqlite3_status(int op,int &pCurrent,int &pHighwater,bool reset=false);
 87 | int sqlite3_status64(int op,long &pCurrent,long &pHighwater,bool reset=false);
 88 | int sqlite3_complete(const char &sql[]);
 89 | 
 90 | void sqlite3_interrupt(intptr_t);
 91 | int sqlite3_db_cacheflush(intptr_t);
 92 | int sqlite3_db_release_memory(intptr_t);
 93 | 
 94 | int sqlite3_db_status(intptr_t,int op,int &pCurrent,int &pHighwater,bool reset=false);
 95 | int sqlite3_db_config(intptr_t,int op,int,intptr_t&);
 96 | int sqlite3_db_config(intptr_t,int op,bool,intptr_t);
 97 | int sqlite3_db_config(intptr_t,int op,const uchar &dbName[]);
 98 | int sqlite3_db_config(intptr_t,int op,intptr_t,int,int);
 99 | 
100 | long sqlite3_last_insert_rowid(intptr_t);
101 | void sqlite3_set_last_insert_rowid(intptr_t,long);
102 | int sqlite3_changes(intptr_t);
103 | int sqlite3_total_changes(intptr_t);
104 | 
105 | int sqlite3_errcode(intptr_t);
106 | int sqlite3_extended_errcode(intptr_t);
107 | intptr_t sqlite3_errmsg(intptr_t);
108 | intptr_t sqlite3_errstr(int);
109 | 
110 | int sqlite3_wal_autocheckpoint(intptr_t,int);
111 | int sqlite3_wal_checkpoint_v2(
112 |                               intptr_t,/* Database handle */
113 |                               const char &zDb[],/* Name of attached database (or NULL) */
114 |                               int eMode,/* SQLITE_CHECKPOINT_* value */
115 |                               int &pnLog,/* OUT: Size of WAL log in frames */
116 |                               int &pnCkpt/* OUT: Total number of frames checkpointed */
117 |                               );
118 | int sqlite3_wal_checkpoint_v2(
119 |                               intptr_t,/* Database handle */
120 |                               intptr_t,/* Name of attached database (or NULL) */
121 |                               int eMode,/* SQLITE_CHECKPOINT_* value */
122 |                               int &pnLog,/* OUT: Size of WAL log in frames */
123 |                               int &pnCkpt/* OUT: Total number of frames checkpointed */
124 |                               );
125 | 
126 | int sqlite3_close(intptr_t); /* sqlite* */
127 | 
128 | // sqlite3 statement management
129 | int sqlite3_prepare_v2(
130 |                        intptr_t handle,/* Database handle */
131 |                        const char &sql[],/* SQL statement, UTF-8 encoded */
132 |                        int bytes,/* Maximum length of sql in bytes. */
133 |                        intptr_t &pStmt,/* OUT: Statement handle (sqlite3_stmt **) */
134 |                        intptr_t pzTail/* OUT: Pointer to unused portion of zSql (not used and always NULL) */
135 |                        );
136 | int sqlite3_reset(intptr_t pStmt); /* reset a prepared statement */
137 | int sqlite3_clear_bindings(intptr_t pStmt); /* clear bindings of a prepared statement */
138 | intptr_t sqlite3_db_handle(intptr_t pStmt);
139 | intptr_t sqlite3_sql(intptr_t pStmt);
140 | intptr_t sqlite3_expanded_sql(intptr_t pStmt);
141 | 
142 | int sqlite3_bind_parameter_count(intptr_t pStmt);
143 | intptr_t sqlite3_bind_parameter_name(intptr_t pStmt,int);
144 | int sqlite3_bind_parameter_index(intptr_t pStmt,const char &name[]);
145 | 
146 | int sqlite3_bind_blob(intptr_t,int,const uchar &value[],int,intptr_t);
147 | int sqlite3_bind_blob64(intptr_t,int,const uchar &value[],ulong,intptr_t);
148 | int sqlite3_bind_text(intptr_t,int,const char &value[],int,intptr_t);
149 | int sqlite3_bind_text64(intptr_t,int,const char &value[],ulong,intptr_t,uchar encoding);
150 | 
151 | int sqlite3_bind_double(intptr_t,int,double);
152 | int sqlite3_bind_int(intptr_t,int,int);
153 | int sqlite3_bind_int64(intptr_t,int,long);
154 | int sqlite3_bind_null(intptr_t,int);
155 | int sqlite3_bind_zeroblob(intptr_t,int,int);
156 | int sqlite3_bind_zeroblob64(intptr_t,int,ulong);
157 | 
158 | bool sqlite3_stmt_busy(intptr_t pStmt);
159 | bool sqlite3_stmt_readonly(intptr_t pStmt);
160 | int sqlite3_step(intptr_t pStmt); /* execute a prepared statement */
161 | int sqlite3_stmt_status(intptr_t,int op,bool resetFlg);
162 | 
163 | int sqlite3_data_count(intptr_t pStmt);
164 | int sqlite3_column_count(intptr_t pStmt);
165 | intptr_t sqlite3_column_name(intptr_t pStmt,int);
166 | int sqlite3_column_type(intptr_t pStmt,int i);
167 | int sqlite3_column_bytes(intptr_t pStmt,int i);
168 | 
169 | double sqlite3_column_double(intptr_t pStmt,int i);
170 | int sqlite3_column_int(intptr_t pStmt,int i);
171 | long sqlite3_column_int64(intptr_t pStmt,int i);
172 | intptr_t sqlite3_column_text(intptr_t pStmt,int i);
173 | intptr_t sqlite3_column_blob(intptr_t pStmt,int i);
174 | 
175 | intptr_t sqlite3_column_decltype(intptr_t pStmt,int);
176 | intptr_t sqlite3_column_database_name(intptr_t,int);
177 | intptr_t sqlite3_column_table_name(intptr_t,int);
178 | intptr_t sqlite3_column_origin_name(intptr_t,int);
179 | 
180 | int sqlite3_finalize(intptr_t pStmt); /* destruct sqlite3_stmt */
181 | 
182 | // blob io streaming api
183 | int sqlite3_blob_open(
184 |                       intptr_t,/* pointer to sqlite3 connection */
185 |                       const char &zDb[],
186 |                       const char &zTable[],
187 |                       const char &zColumn[],
188 |                       long row,
189 |                       int flags,
190 |                       intptr_t &pBlob
191 |                       );
192 | int sqlite3_blob_reopen(intptr_t,long row);
193 | int sqlite3_blob_bytes(intptr_t);
194 | int sqlite3_blob_read(intptr_t,uchar &buf[],int n,int offset);
195 | int sqlite3_blob_write(intptr_t,const uchar &buf[],int n,int offset);
196 | int sqlite3_blob_close(intptr_t);
197 | 
198 | // online backup api
199 | intptr_t sqlite3_backup_init(
200 |                              intptr_t pDest,/* Destination database handle */
201 |                              const char &zDestName[],/* Destination database name */
202 |                              intptr_t pSource,/* Source database handle */
203 |                              const char &zSourceName[]/* Source database name */
204 |                              );
205 | int sqlite3_backup_step(intptr_t,int page);
206 | int sqlite3_backup_finish(intptr_t);
207 | int sqlite3_backup_remaining(intptr_t);
208 | int sqlite3_backup_pagecount(intptr_t);
209 | 
210 | intptr_t sqlite3_vfs_find(const char &zVfsName[]);
211 | intptr_t sqlite3_vfs_find(intptr_t);
212 | int sqlite3_vfs_register(intptr_t,bool);
213 | int sqlite3_vfs_unregister(intptr_t);
214 | #import
215 | //+------------------------------------------------------------------+
216 | //| Basic wrapper for sqlite3_open_v2                                |
217 | //+------------------------------------------------------------------+
218 | int sqlite3_open(const string &filename,intptr_t &handle,int flags,string vfs="")
219 |   {
220 |    uchar u8filename[];
221 |    StringToUtf8(filename,u8filename);
222 |    int res=0;
223 |    if(vfs=="")
224 |       res=sqlite3_open_v2(u8filename,handle,flags,0);
225 |    else
226 |      {
227 |       uchar u8vfs[];
228 |       StringToUtf8(vfs,u8vfs);
229 |       res=sqlite3_open_v2(u8filename,handle,flags,u8vfs);
230 |      }
231 |    return res;
232 |   }
233 | //+------------------------------------------------------------------+
234 | //| Basic wrapper for sqlite3_prepare_v2                             |
235 | //+------------------------------------------------------------------+
236 | int sqlite3_prepare(const intptr_t handle,const string &sql,intptr_t &stmt)
237 |   {
238 |    uchar u8sql[];
239 |    StringToUtf8(sql,u8sql);
240 |    int res=sqlite3_prepare_v2(handle,u8sql,ArraySize(u8sql),stmt,0);
241 |    return res;
242 |   }
243 | //+------------------------------------------------------------------+
244 | 


--------------------------------------------------------------------------------
/Include/SQLite3/SQLite3.mqh:
--------------------------------------------------------------------------------
  1 | //+------------------------------------------------------------------+
  2 | //|                                                      SQLite3.mqh |
  3 | //|                                          Copyright 2017, Li Ding |
  4 | //|                                                dingmaotu@126.com |
  5 | //+------------------------------------------------------------------+
  6 | #property strict
  7 | 
  8 | #include "Imports.mqh"
  9 | //+------------------------------------------------------------------+
 10 | //| Represents column metadata                                       |
 11 | //+------------------------------------------------------------------+
 12 | struct ColumnInfo
 13 |   {
 14 | public:
 15 |    string            DataType;
 16 |    string            CollationSequence;
 17 |    bool              NotNull;
 18 |    bool              PrimaryKey;
 19 |    bool              AutoIncrement;
 20 |   };
 21 | //+------------------------------------------------------------------+
 22 | //| sqlite3 object representing a connection to a db                 |
 23 | //+------------------------------------------------------------------+
 24 | class SQLite3
 25 |   {
 26 | private:
 27 |    int               m_valid;
 28 |    intptr_t          m_ref;
 29 |    uchar             m_dbName[];
 30 | public:
 31 |    // version numbers
 32 |    static int        getVersionNumber() {return sqlite3_libversion_number();}
 33 |    static string     getVersion() {return StringFromUtf8Pointer(sqlite3_libversion());}
 34 |    static string     getSourceId() {return StringFromUtf8Pointer(sqlite3_sourceid());}
 35 | 
 36 |    // compile time thread safety setting
 37 |    static bool       isThreadSafe() {return sqlite3_threadsafe()!=0;}
 38 | 
 39 |    // global configuration before initialize
 40 |    static int        setSingleThreaded() {return sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);}
 41 |    static int        setMultiThreaded() {return sqlite3_config(SQLITE_CONFIG_MULTITHREAD);}
 42 |    static int        setSerialized() {return sqlite3_config(SQLITE_CONFIG_SERIALIZED);}
 43 | 
 44 |    static int        setMemStatus(bool enabled) {return sqlite3_config(SQLITE_CONFIG_MEMSTATUS,int(enabled));}
 45 |    static int        setUriHandling(bool enabled) {return sqlite3_config(SQLITE_CONFIG_URI,int(enabled));}
 46 |    static int        setLookAside(int before,int after) {return sqlite3_config(SQLITE_CONFIG_LOOKASIDE,before,after);}
 47 | 
 48 |    static int        setMmapSize(long size) {return sqlite3_config(SQLITE_CONFIG_MMAP_SIZE,size);}
 49 |    static int        setWin32HeapSize(int size) {return sqlite3_config(SQLITE_CONFIG_WIN32_HEAPSIZE,size);}
 50 |    static int        setStatementJournalThreshold(int size) {return sqlite3_config(SQLITE_CONFIG_STMTJRNL_SPILL,size);}
 51 | 
 52 |    static int        initialize() {return sqlite3_initialize();}
 53 |    static int        shutdown() {return sqlite3_shutdown();}
 54 | 
 55 |    static string     errorCode2Msg(int code) {return StringFromUtf8Pointer(sqlite3_errstr(code));}
 56 |    static int        status(int op,long &current,long &highwater,bool reset=false) {return sqlite3_status64(op,current,highwater,reset);}
 57 | 
 58 |    static int        releaseMemoryInBytes(int bytes) {return sqlite3_release_memory(bytes);}
 59 |    static long       setSoftHeapLimit(long bytes) {return sqlite3_soft_heap_limit64(bytes);}
 60 | 
 61 |    static long       getMemoryUsed() {return sqlite3_memory_used(); }
 62 |    static long       getMemoryHighwater() {return sqlite3_memory_highwater(false);}
 63 |    static long       resetMemoryHighwater() {return sqlite3_memory_highwater(true);}
 64 | 
 65 |                      SQLite3(string filename,int flags,string vfs="")
 66 |      {
 67 |       m_valid=sqlite3_open(filename,m_ref,flags,vfs);
 68 |       if(m_valid!=SQLITE_OK)
 69 |         {
 70 |          Print(">>> Error opening database [",filename,"]: ",SQLite3::errorCode2Msg(m_valid));
 71 |         }
 72 |      }
 73 |                     ~SQLite3()
 74 |      {
 75 |       if(isValid())
 76 |         {
 77 |          int ret=sqlite3_close(m_ref);
 78 |          if(ret!=SQLITE_OK)
 79 |            {
 80 |             Print(">>> Error close connection: ",getErrorMsg());
 81 |            }
 82 |         }
 83 |      }
 84 | 
 85 |    bool              isValid() const {return m_valid==SQLITE_OK;}
 86 | 
 87 |    bool              isAutoCommit() const { return sqlite3_get_autocommit(m_ref)!=0;}
 88 | 
 89 |    bool              isReadonly(string db) const
 90 |      {
 91 |       char buf[];
 92 |       StringToUtf8(db,buf);
 93 |       return 1==sqlite3_db_readonly(m_ref,buf);
 94 |      }
 95 |    bool              hasDb(string db) const
 96 |      {
 97 |       char buf[];
 98 |       StringToUtf8(db,buf);
 99 |       return -1==sqlite3_db_readonly(m_ref,buf);
100 |      }
101 |    string            getDbFilename(string db) const
102 |      {
103 |       char buf[];
104 |       StringToUtf8(db,buf);
105 |       return StringFromUtf8Pointer(sqlite3_db_filename(m_ref,buf));
106 |      }
107 |    int               getDbColumnMetadata(string db,string table,string column,ColumnInfo &info)
108 |      {
109 |       char zDbName[];
110 |       char zTableName[];
111 |       char zColumnName[];
112 |       StringToUtf8(db,zDbName);
113 |       StringToUtf8(table,zTableName);
114 |       StringToUtf8(column,zColumnName);
115 |       intptr_t pDataType;
116 |       intptr_t pCollSeq;
117 |       int res=sqlite3_table_column_metadata(m_ref,zDbName,zTableName,zColumnName,pDataType,pCollSeq,info.NotNull,info.PrimaryKey,info.AutoIncrement);
118 |       if(res==SQLITE_OK)
119 |         {
120 |          info.DataType=StringFromUtf8Pointer(pDataType);
121 |          info.CollationSequence=StringFromUtf8Pointer(pCollSeq);
122 |         }
123 |       return res;
124 |      }
125 | 
126 |    int               setLimit(int id,int value) {return sqlite3_limit(m_ref,id,value);}
127 |    int               setBusyTimeout(int millis) {return sqlite3_busy_timeout(m_ref, millis);}
128 | 
129 |    int               flush() {return sqlite3_db_cacheflush(m_ref);}
130 |    int               releaseMemory() {return sqlite3_db_release_memory(m_ref);}
131 | 
132 |    void              interrupt() {sqlite3_interrupt(m_ref);}
133 | 
134 |    long              getLastInsertRowId() {return sqlite3_last_insert_rowid(m_ref);}
135 |    void              setLastInsertRowId(long id) {sqlite3_set_last_insert_rowid(m_ref,id);}
136 |    int               getChanges() const {return sqlite3_changes(m_ref);}
137 |    int               getTotalChanges() const {return sqlite3_total_changes(m_ref);}
138 | 
139 |    int               getErrorCode() const {return sqlite3_errcode(m_ref);}
140 |    int               getExtendedErrorCode() const {return sqlite3_extended_errcode(m_ref);}
141 |    string            getErrorMsg() const {return StringFromUtf8Pointer(sqlite3_errmsg(m_ref));}
142 | 
143 |    int               getStatus(int op,int &current,int &highwater,bool reset=false) {return sqlite3_db_status(m_ref,op,current,highwater,reset);}
144 | 
145 |    int               setSharedCache(bool value) {return sqlite3_enable_shared_cache(value);}
146 |    int               setLoadExtension(bool value) {return sqlite3_enable_load_extension(m_ref,value);}
147 | 
148 |    int               setExtendedResultCodes(bool value) {return sqlite3_extended_result_codes(m_ref,value);}
149 | 
150 |    bool              loadExtension(string name,string entry)
151 |      {
152 |       char u8name[],u8entry[];
153 |       StringToUtf8(name,u8name);
154 |       StringToUtf8(name,u8entry);
155 |       intptr_t errMsg;
156 |       int res= sqlite3_load_extension(m_ref,u8name,u8entry,errMsg);
157 |       if(res == SQLITE_OK) return true;
158 |       else
159 |         {
160 |          PrintFormat(">>> Error loading extension module %s: %s",name,StringFromUtf8Pointer(errMsg));
161 |          sqlite3_free(errMsg);
162 |          return false;
163 |         }
164 |      }
165 | 
166 |    int               setAutoCheckpoint(int frameThreshold) {return sqlite3_wal_autocheckpoint(m_ref,frameThreshold);}
167 |    int               checkpoint(string db,int mode,int &pnLog,int &pnCkpt)
168 |      {
169 |       if(db==NULL)
170 |          return sqlite3_wal_checkpoint_v2(m_ref, 0, mode, pnLog, pnCkpt);
171 |       else
172 |         {
173 |          uchar u8db[];
174 |          StringToUtf8(db,u8db);
175 |          return sqlite3_wal_checkpoint_v2(m_ref, u8db, mode, pnLog, pnCkpt);
176 |         }
177 |      }
178 | 
179 |    // db config
180 |    #define DB_CONFIG(Name,MACRO) \
181 |    bool              is##Name##Enabled() const {int res;sqlite3_db_config(m_ref,MACRO,-1,res);return res!=0;}\
182 |    void              set##Name##Enabled(bool value) {sqlite3_db_config(m_ref,MACRO,value,0);}
183 | 
184 |    DB_CONFIG(Trigger,SQLITE_DBCONFIG_ENABLE_TRIGGER)
185 |    DB_CONFIG(ForeignKey,SQLITE_DBCONFIG_ENABLE_FKEY)
186 |    DB_CONFIG(FTS3Tokenizer,SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER)
187 |    DB_CONFIG(LoadExtension,SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION)
188 |    DB_CONFIG(CheckpointsOnClose,SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE)
189 | 
190 |    bool              setMainDbName(string name)
191 |      {
192 |       if(ArraySize(m_dbName) > 0) return false;
193 |       StringToUtf8(name,m_dbName);
194 |       sqlite3_db_config(m_ref,SQLITE_DBCONFIG_MAINDBNAME,m_dbName);
195 |       return true;
196 |      }
197 | 
198 |    int               setDbLookAside(int slotSize,int nSlots) {return sqlite3_db_config(m_ref,SQLITE_DBCONFIG_LOOKASIDE,0,slotSize,nSlots);}
199 |    // end db config
200 | 
201 |    //--- intended for internal use
202 |    intptr_t          ref() const {return m_ref;}
203 |   };
204 | //+------------------------------------------------------------------+
205 | 


--------------------------------------------------------------------------------
/Include/SQLite3/Statement.mqh:
--------------------------------------------------------------------------------
  1 | //+------------------------------------------------------------------+
  2 | //|                                                    Statement.mqh |
  3 | //|                                          Copyright 2017, Li Ding |
  4 | //|                                                dingmaotu@126.com |
  5 | //+------------------------------------------------------------------+
  6 | #property strict
  7 | 
  8 | #include "SQLite3.mqh"
  9 | //+------------------------------------------------------------------+
 10 | //| Wraps sqlite3_stmt object                                        |
 11 | //+------------------------------------------------------------------+
 12 | class Statement
 13 |   {
 14 | private:
 15 |    int               m_valid;
 16 |    intptr_t          m_ref;
 17 | public:
 18 | 
 19 |    static bool       isComplete(string sql)
 20 |      {
 21 |       uchar buf[];
 22 |       StringToUtf8(sql,buf);
 23 |       return 1==sqlite3_complete(buf);
 24 |      }
 25 | 
 26 |                      Statement(const SQLite3 &conn,string sql)
 27 |      {
 28 |       m_valid=sqlite3_prepare(conn.ref(),sql,m_ref);
 29 |      }
 30 |                     ~Statement() {if(isValid())sqlite3_finalize(m_ref);}
 31 | 
 32 |    bool              setSql(string sql)
 33 |      {
 34 |       if(isValid())
 35 |         {
 36 |          intptr_t h=getConnectionHandle();
 37 |          sqlite3_finalize(m_ref);
 38 |          m_valid=sqlite3_prepare(h,sql,m_ref);
 39 |          return m_valid==SQLITE_OK;
 40 |         }
 41 |       return false;
 42 |      }
 43 |    string            getSql() const {return StringFromUtf8Pointer(sqlite3_sql(m_ref));}
 44 |    string            getExpandedSql() const {return StringFromUtf8Pointer(sqlite3_expanded_sql(m_ref));}
 45 |    intptr_t          getConnectionHandle() const {return sqlite3_db_handle(m_ref);}
 46 | 
 47 |    bool              isValid() const {return m_valid==SQLITE_OK;}
 48 | 
 49 |    bool              isBusy() const {return sqlite3_stmt_busy(m_ref);}
 50 |    bool              isReadonly() const {return sqlite3_stmt_readonly(m_ref);}
 51 | 
 52 |    int               getCounter(int op) const {return sqlite3_stmt_status(m_ref,op,false);}
 53 |    void              resetCounter(int op) { sqlite3_stmt_status(m_ref,op,true);}
 54 | 
 55 |    int               step() { return sqlite3_step(m_ref);}
 56 | 
 57 |    int               reset() {return sqlite3_reset(m_ref);}
 58 |    int               clearBindings() {return sqlite3_clear_bindings(m_ref);}
 59 | 
 60 |    int               getParameterCount() const {return sqlite3_bind_parameter_count(m_ref);}
 61 |    string            getParameterName(int i) const {return StringFromUtf8Pointer(sqlite3_bind_parameter_name(m_ref,i));}
 62 |    int               getParameterIndex(string name) const
 63 |      {
 64 |       uchar u8name[];
 65 |       StringToUtf8(name,u8name);
 66 |       return sqlite3_bind_parameter_index(m_ref,u8name);
 67 |      }
 68 | 
 69 |    int               bind(int i,const uchar &value[],bool copy=true)
 70 |      {
 71 |       return sqlite3_bind_blob(m_ref,i,value,ArraySize(value),copy?SQLITE_TRANSIENT:SQLITE_STATIC);
 72 |      }
 73 |    int               bind(int i,string text)
 74 |      {
 75 |       uchar u8text[];
 76 |       StringToUtf8(text,u8text);
 77 |       return sqlite3_bind_text(m_ref,i,u8text,ArraySize(u8text),SQLITE_TRANSIENT);
 78 |      }
 79 | 
 80 |    int               bind(int i,double value) {return sqlite3_bind_double(m_ref,i,value);}
 81 |    int               bind(int i,int value) {return sqlite3_bind_int(m_ref,i,value);}
 82 |    int               bind(int i,long value) {return sqlite3_bind_int64(m_ref,i,value);}
 83 |    int               bind(int i) {return sqlite3_bind_null(m_ref,i);}
 84 | 
 85 |    int               zero(int i,int bytes) {return sqlite3_bind_zeroblob(m_ref,i,bytes);}
 86 |    int               zero(int i,ulong bytes) {return sqlite3_bind_zeroblob64(m_ref,i,bytes);}
 87 | 
 88 |    int               getDataCount() const {return sqlite3_data_count(m_ref);}
 89 | 
 90 |    int               getColumnCount() const {return sqlite3_column_count(m_ref);}
 91 |    string            getColumnName(int i) const {return StringFromUtf8Pointer(sqlite3_column_name(m_ref,i));}
 92 |    int               getColumnType(int i) const {return sqlite3_column_type(m_ref,i);}
 93 |    string            getColumnDeclareType(int i) const {return StringFromUtf8Pointer(sqlite3_column_decltype(m_ref,i));}
 94 |    int               getColumnBytes(int i) const {return sqlite3_column_bytes(m_ref,i);}
 95 | 
 96 |    string            getColumnDatabaseName(int i) const {return StringFromUtf8Pointer(sqlite3_column_database_name(m_ref,i));}
 97 |    string            getColumnTableName(int i) const {return StringFromUtf8Pointer(sqlite3_column_table_name(m_ref,i));}
 98 |    string            getColumnOriginName(int i) const {return StringFromUtf8Pointer(sqlite3_column_origin_name(m_ref,i));}
 99 | 
100 |    void              getColumn(int i,double &value) const {value=sqlite3_column_double(m_ref,i);}
101 |    void              getColumn(int i,int &value) const {value=sqlite3_column_int(m_ref,i);}
102 |    void              getColumn(int i,long &value) const {value=sqlite3_column_int64(m_ref,i);}
103 |    void              getColumn(int i,string &value) const
104 |      {
105 |       intptr_t u8p=0;
106 |       u8p=sqlite3_column_text(m_ref,i);
107 |       if(u8p>0) value=StringFromUtf8Pointer(u8p);
108 |       else value=NULL;
109 |      }
110 |    void              getColumn(int i,uchar &blob[]) const
111 |      {
112 |       int len=sqlite3_column_bytes(m_ref,i);
113 |       if(len==0)
114 |         {ArrayFree(blob);return;}
115 |       intptr_t blobp=sqlite3_column_blob(m_ref,i);
116 |       ArrayResize(blob,len);
117 |       ArrayFromPointer(blob,blobp,len);
118 |      }
119 |   };
120 | //+------------------------------------------------------------------+
121 | 


--------------------------------------------------------------------------------
/Include/SQLite3/Vfs.mqh:
--------------------------------------------------------------------------------
 1 | //+------------------------------------------------------------------+
 2 | //|                                                          Vfs.mqh |
 3 | //|                                          Copyright 2017, Li Ding |
 4 | //|                                                dingmaotu@126.com |
 5 | //+------------------------------------------------------------------+
 6 | #property strict
 7 | 
 8 | #include "Imports.mqh"
 9 | //+------------------------------------------------------------------+
10 | //| Virtual file system operations                                   |
11 | //+------------------------------------------------------------------+
12 | struct Vfs
13 |   {
14 | public:
15 |    intptr_t          handle;
16 | 
17 |    static Vfs        getDefault() {Vfs vfs(sqlite3_vfs_find(0)); return vfs;}
18 |    static bool       find(string name,Vfs &vfs) {char u8[];StringToUtf8(name,u8);vfs.handle=sqlite3_vfs_find(u8);return vfs.handle!=0;}
19 | 
20 |                      Vfs(intptr_t ptr):handle(ptr){}
21 |                      Vfs(const Vfs&rhs):handle(rhs.handle) {}
22 |    void              operator=(const Vfs&rhs) {handle=rhs.handle;}
23 | 
24 |    int               register() {return sqlite3_vfs_register(handle,false);}
25 |    int               registerDefault() {return sqlite3_vfs_register(handle,true);}
26 |    int               unregister() {return sqlite3_vfs_unregister(handle);}
27 |   };
28 | //+------------------------------------------------------------------+
29 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Ding Li
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Library/MT4/sqlite3.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dingmaotu/mql-sqlite3/1b5186f7c3c3d4cd27cc648f5273d76eaa8dc593/Library/MT4/sqlite3.dll


--------------------------------------------------------------------------------
/Library/MT5/sqlite3.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dingmaotu/mql-sqlite3/1b5186f7c3c3d4cd27cc648f5273d76eaa8dc593/Library/MT5/sqlite3.dll


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
   1 | # mql-sqlite3
   2 | 
   3 | SQLite3 binding for the MQL language (both 32bit MT4 and 64bit MT5)
   4 | 
   5 | ## Introduction
   6 | 
   7 | This is a complete binding of the [SQLite3](http://sqlite.org/) library (version
   8 | 3180000) for the MQL4/5 language used by MetaTrader4/5.
   9 | 
  10 | SQLite is an fast embeded SQL engine written in C
  11 | and [widely used](http://sqlite.org/mostdeployed.html) by a lot of projects. We
  12 | always have the need to persistent states of Expert Advisors and SQLite seems to
  13 | be the best solution.
  14 | 
  15 | This binding tries to remain compatible between MQL4/5. Users of both versions
  16 | can use this binding, with a single set of headers. MQL4 and MQL5 are basically
  17 | the same in that they are merged in recent versions. The difference is in the
  18 | runtime environment (MetaTrader5 is 64bit by default, while MetaTrader4 is
  19 | 32bit). The trading system is also different, but it is no concern of this
  20 | binding.
  21 | 
  22 | ## Files
  23 | 
  24 | This binding contains three sets of files:
  25 | 
  26 | 1. The binding itself is in the `Include/SQLite3` directory.
  27 | 
  28 | 2. There is a simple testing script called `TestSQLite3.mq4` in `Scripts/Test`
  29 |    directory. The script files are mq4 by default, but you can change the
  30 |    extension to mq5 to use them in MetaTrader5. Currently there is only one
  31 |    script. I am going to add more in the future.
  32 | 
  33 | 3. Precompiled DLLs of both 64bit (`Library/MT5`) and 32bit (`Library/MT4`) are
  34 |    provided. Copy the corresponding DLLs to the `Library` folder of your
  35 |    MetaTrader terminal. If you are using MetaTrader5 32bit, use the 32bit
  36 |    version from `Library/MT4`. The DLLs have no special dependencies and should
  37 |    work in any Windows version after NT. *Note* that these DLLs are copied from
  38 |    official binary release, without any modification. You can download/compile
  39 |    your own if you don't trust these binaries.
  40 | 
  41 | ## API comparison
  42 |    
  43 | Below is a detailed comparison table of MQL and C/C++ APIs. If you are reading
  44 | the official documentation, and you want to find the corresponding MQL API for
  45 | the C API, use this table. This table also has comments about why a particular
  46 | API is not included in this binding. This table might change if new APIs get added.
  47 | 
  48 | <table border=0 cellpadding=0 cellspacing=0>
  49 |  <thead>
  50 |   <tr>
  51 |    <th>SQLite3 C API</th>
  52 |    <th>mql-sqlite3</th>
  53 |    <th>Comment</th>
  54 |   </tr>
  55 |  </thead>
  56 |  <tbody>
  57 |  <tr>
  58 |   <td>sqlite3_aggregate_context</td>
  59 |   <td>N/A</td>
  60 |   <td>for extension</td>
  61 |  </tr>
  62 |  <tr>
  63 |   <td>sqlite3_aggregate_count</td>
  64 |   <td>N/A</td>
  65 |   <td>deprecated</td>
  66 |  </tr>
  67 |  <tr>
  68 |   <td>sqlite3_auto_extension</td>
  69 |   <td>N/A</td>
  70 |   <td>for extension</td>
  71 |  </tr>
  72 |  <tr>
  73 |   <td>sqlite3_backup_finish</td>
  74 |   <td>Backup::~Backup</td>
  75 |   <td>　</td>
  76 |  </tr>
  77 |  <tr>
  78 |   <td>sqlite3_backup_init</td>
  79 |   <td>Backup::Backup</td>
  80 |   <td>　</td>
  81 |  </tr>
  82 |  <tr>
  83 |   <td>sqlite3_backup_pagecount</td>
  84 |   <td>Backup::getPageCount</td>
  85 |   <td>　</td>
  86 |  </tr>
  87 |  <tr>
  88 |   <td>sqlite3_backup_remaining</td>
  89 |   <td>Backup::getRemaining</td>
  90 |   <td>　</td>
  91 |  </tr>
  92 |  <tr>
  93 |   <td>sqlite3_backup_step</td>
  94 |   <td>Backup::step</td>
  95 |   <td>　</td>
  96 |  </tr>
  97 |  <tr>
  98 |   <td>sqlite3_bind_blob</td>
  99 |   <td>Statement::bind</td>
 100 |   <td>　</td>
 101 |  </tr>
 102 |  <tr>
 103 |   <td>sqlite3_bind_blob64</td>
 104 |   <td>N/A</td>
 105 |   <td>too large for ordinary use</td>
 106 |  </tr>
 107 |  <tr>
 108 |   <td>sqlite3_bind_double</td>
 109 |   <td>Statement::bind</td>
 110 |   <td>　</td>
 111 |  </tr>
 112 |  <tr>
 113 |   <td>sqlite3_bind_int</td>
 114 |   <td>Statement::bind</td>
 115 |   <td>　</td>
 116 |  </tr>
 117 |  <tr>
 118 |   <td>sqlite3_bind_int64</td>
 119 |   <td>Statement::bind</td>
 120 |   <td>　</td>
 121 |  </tr>
 122 |  <tr>
 123 |   <td>sqlite3_bind_null</td>
 124 |   <td>Statement::bind</td>
 125 |   <td>　</td>
 126 |  </tr>
 127 |  <tr>
 128 |   <td>sqlite3_bind_parameter_count</td>
 129 |   <td>Statement::getParameterCount</td>
 130 |   <td>　</td>
 131 |  </tr>
 132 |  <tr>
 133 |   <td>sqlite3_bind_parameter_index</td>
 134 |   <td>Statement::getParameterIndex</td>
 135 |   <td>　</td>
 136 |  </tr>
 137 |  <tr>
 138 |   <td>sqlite3_bind_parameter_name</td>
 139 |   <td>Statement::getParameterName</td>
 140 |   <td>　</td>
 141 |  </tr>
 142 |  <tr>
 143 |   <td>sqlite3_bind_text</td>
 144 |   <td>Statement::bind</td>
 145 |   <td>　</td>
 146 |  </tr>
 147 |  <tr>
 148 |   <td>sqlite3_bind_text16</td>
 149 |   <td>N/A</td>
 150 |   <td>always UTF-8</td>
 151 |  </tr>
 152 |  <tr>
 153 |   <td>sqlite3_bind_text64</td>
 154 |   <td>N/A</td>
 155 |   <td>too large for ordinary use</td>
 156 |  </tr>
 157 |  <tr>
 158 |   <td>sqlite3_bind_value</td>
 159 |   <td>N/A</td>
 160 |   <td>for extension</td>
 161 |  </tr>
 162 |  <tr>
 163 |   <td>sqlite3_bind_zeroblob</td>
 164 |   <td>Statement::zero</td>
 165 |   <td>　</td>
 166 |  </tr>
 167 |  <tr>
 168 |   <td>sqlite3_bind_zeroblob64</td>
 169 |   <td>Statement::zero</td>
 170 |   <td>　</td>
 171 |  </tr>
 172 |  <tr>
 173 |   <td>sqlite3_blob_bytes</td>
 174 |   <td>Blob::size</td>
 175 |   <td>　</td>
 176 |  </tr>
 177 |  <tr>
 178 |   <td>sqlite3_blob_close</td>
 179 |   <td>Blob::~Blob</td>
 180 |   <td>　</td>
 181 |  </tr>
 182 |  <tr>
 183 |   <td>sqlite3_blob_open</td>
 184 |   <td>Blob::Blob</td>
 185 |   <td>　</td>
 186 |  </tr>
 187 |  <tr>
 188 |   <td>sqlite3_blob_read</td>
 189 |   <td>Blob::read</td>
 190 |   <td>　</td>
 191 |  </tr>
 192 |  <tr>
 193 |   <td>sqlite3_blob_reopen</td>
 194 |   <td>Blob::moveTo</td>
 195 |   <td>　</td>
 196 |  </tr>
 197 |  <tr>
 198 |   <td>sqlite3_blob_write</td>
 199 |   <td>Blob::write</td>
 200 |   <td>　</td>
 201 |  </tr>
 202 |  <tr>
 203 |   <td>sqlite3_busy_handler</td>
 204 |   <td>N/A</td>
 205 |   <td>Need callback</td>
 206 |  </tr>
 207 |  <tr>
 208 |   <td>sqlite3_busy_timeout</td>
 209 |   <td>SQLite3::setBusyTimeout</td>
 210 |   <td>　</td>
 211 |  </tr>
 212 |  <tr>
 213 |   <td>sqlite3_cancel_auto_extension</td>
 214 |   <td>N/A</td>
 215 |   <td>for extension</td>
 216 |  </tr>
 217 |  <tr>
 218 |   <td>sqlite3_changes</td>
 219 |   <td>SQLite3::getChanges</td>
 220 |   <td>　</td>
 221 |  </tr>
 222 |  <tr>
 223 |   <td>sqlite3_clear_bindings</td>
 224 |   <td>Statement::clearBindings</td>
 225 |   <td>　</td>
 226 |  </tr>
 227 |  <tr>
 228 |   <td>sqlite3_close</td>
 229 |   <td>N/A</td>
 230 |   <td>use v2</td>
 231 |  </tr>
 232 |  <tr>
 233 |   <td>sqlite3_close_v2</td>
 234 |   <td>SQLite3::~SQLite3</td>
 235 |   <td>　</td>
 236 |  </tr>
 237 |  <tr>
 238 |   <td>sqlite3_collation_needed</td>
 239 |   <td>N/A</td>
 240 |   <td>for extension</td>
 241 |  </tr>
 242 |  <tr>
 243 |   <td>sqlite3_collation_needed16</td>
 244 |   <td>N/A</td>
 245 |   <td>for extension</td>
 246 |  </tr>
 247 |  <tr>
 248 |   <td>sqlite3_column_blob</td>
 249 |   <td>Statement::getColumn</td>
 250 |   <td>　</td>
 251 |  </tr>
 252 |  <tr>
 253 |   <td>sqlite3_column_bytes</td>
 254 |   <td>Statement::getColumnBytes</td>
 255 |   <td>　</td>
 256 |  </tr>
 257 |  <tr>
 258 |   <td>sqlite3_column_bytes16</td>
 259 |   <td>N/A</td>
 260 |   <td>always UTF-8</td>
 261 |  </tr>
 262 |  <tr>
 263 |   <td>sqlite3_column_count</td>
 264 |   <td>Statement::getColumnCount</td>
 265 |   <td>　</td>
 266 |  </tr>
 267 |  <tr>
 268 |   <td>sqlite3_column_database_name</td>
 269 |   <td>Statement::getColumnDatabaseName</td>
 270 |   <td>　</td>
 271 |  </tr>
 272 |  <tr>
 273 |   <td>sqlite3_column_database_name16</td>
 274 |   <td>N/A</td>
 275 |   <td>always UTF-8</td>
 276 |  </tr>
 277 |  <tr>
 278 |   <td>sqlite3_column_decltype</td>
 279 |   <td>Statement::getColumnDeclareType</td>
 280 |   <td>　</td>
 281 |  </tr>
 282 |  <tr>
 283 |   <td>sqlite3_column_decltype16</td>
 284 |   <td>N/A</td>
 285 |   <td>always UTF-8</td>
 286 |  </tr>
 287 |  <tr>
 288 |   <td>sqlite3_column_double</td>
 289 |   <td>Statement::getColumn</td>
 290 |   <td>　</td>
 291 |  </tr>
 292 |  <tr>
 293 |   <td>sqlite3_column_int</td>
 294 |   <td>Statement::getColumn</td>
 295 |   <td>　</td>
 296 |  </tr>
 297 |  <tr>
 298 |   <td>sqlite3_column_int64</td>
 299 |   <td>Statement::getColumn</td>
 300 |   <td>　</td>
 301 |  </tr>
 302 |  <tr>
 303 |   <td>sqlite3_column_name</td>
 304 |   <td>Statement::getColumnName</td>
 305 |   <td>　</td>
 306 |  </tr>
 307 |  <tr>
 308 |   <td>sqlite3_column_name16</td>
 309 |   <td>N/A</td>
 310 |   <td>always UTF-8</td>
 311 |  </tr>
 312 |  <tr>
 313 |   <td>sqlite3_column_origin_name</td>
 314 |   <td>Statement::getColumnOriginName</td>
 315 |   <td>　</td>
 316 |  </tr>
 317 |  <tr>
 318 |   <td>sqlite3_column_origin_name16</td>
 319 |   <td>N/A</td>
 320 |   <td>always UTF-8</td>
 321 |  </tr>
 322 |  <tr>
 323 |   <td>sqlite3_column_table_name</td>
 324 |   <td>Statement::getColumnTableName</td>
 325 |   <td>　</td>
 326 |  </tr>
 327 |  <tr>
 328 |   <td>sqlite3_column_table_name16</td>
 329 |   <td>N/A</td>
 330 |   <td>always UTF-8</td>
 331 |  </tr>
 332 |  <tr>
 333 |   <td>sqlite3_column_text</td>
 334 |   <td>Statement::getColumn</td>
 335 |   <td>　</td>
 336 |  </tr>
 337 |  <tr>
 338 |   <td>sqlite3_column_text16</td>
 339 |   <td>N/A</td>
 340 |   <td>always UTF-8</td>
 341 |  </tr>
 342 |  <tr>
 343 |   <td>sqlite3_column_type</td>
 344 |   <td>Statement::getColumnType</td>
 345 |   <td>　</td>
 346 |  </tr>
 347 |  <tr>
 348 |   <td>sqlite3_column_value</td>
 349 |   <td>N/A</td>
 350 |   <td>for extension</td>
 351 |  </tr>
 352 |  <tr>
 353 |   <td>sqlite3_commit_hook</td>
 354 |   <td>N/A</td>
 355 |   <td>need callback</td>
 356 |  </tr>
 357 |  <tr>
 358 |   <td>sqlite3_compileoption_get</td>
 359 |   <td>N/A</td>
 360 |   <td>diagnostic/optional</td>
 361 |  </tr>
 362 |  <tr>
 363 |   <td>sqlite3_compileoption_used</td>
 364 |   <td>N/A</td>
 365 |   <td>diagnostic/optional</td>
 366 |  </tr>
 367 |  <tr>
 368 |   <td>sqlite3_complete</td>
 369 |   <td>Statement::isComplete</td>
 370 |   <td>　</td>
 371 |  </tr>
 372 |  <tr>
 373 |   <td>sqlite3_complete16</td>
 374 |   <td>N/A</td>
 375 |   <td>always UTF-8</td>
 376 |  </tr>
 377 |  <tr>
 378 |   <td>sqlite3_config</td>
 379 |   <td>SQLite3::set* static methods</td>
 380 |   <td>partial</td>
 381 |  </tr>
 382 |  <tr>
 383 |   <td>sqlite3_context_db_handle</td>
 384 |   <td>N/A</td>
 385 |   <td>for extension</td>
 386 |  </tr>
 387 |  <tr>
 388 |   <td>sqlite3_create_collation</td>
 389 |   <td>N/A</td>
 390 |   <td>for extension</td>
 391 |  </tr>
 392 |  <tr>
 393 |   <td>sqlite3_create_collation16</td>
 394 |   <td>N/A</td>
 395 |   <td>for extension</td>
 396 |  </tr>
 397 |  <tr>
 398 |   <td>sqlite3_create_collation_v2</td>
 399 |   <td>N/A</td>
 400 |   <td>for extension</td>
 401 |  </tr>
 402 |  <tr>
 403 |   <td>sqlite3_create_function</td>
 404 |   <td>N/A</td>
 405 |   <td>for extension</td>
 406 |  </tr>
 407 |  <tr>
 408 |   <td>sqlite3_create_function16</td>
 409 |   <td>N/A</td>
 410 |   <td>for extension</td>
 411 |  </tr>
 412 |  <tr>
 413 |   <td>sqlite3_create_function_v2</td>
 414 |   <td>N/A</td>
 415 |   <td>for extension</td>
 416 |  </tr>
 417 |  <tr>
 418 |   <td>sqlite3_create_module</td>
 419 |   <td>N/A</td>
 420 |   <td>for extension</td>
 421 |  </tr>
 422 |  <tr>
 423 |   <td>sqlite3_create_module_v2</td>
 424 |   <td>N/A</td>
 425 |   <td>for extension</td>
 426 |  </tr>
 427 |  <tr>
 428 |   <td>sqlite3_data_count</td>
 429 |   <td>Statement::getDataCount</td>
 430 |   <td>　</td>
 431 |  </tr>
 432 |  <tr>
 433 |   <td>sqlite3_db_cacheflush</td>
 434 |   <td>SQLite3::flush</td>
 435 |   <td>　</td>
 436 |  </tr>
 437 |  <tr>
 438 |   <td>sqlite3_db_config</td>
 439 |   <td>SQLite3::setDbLookAside<br>
 440 |     SQLite3::setMainDbName<br>
 441 |     SQLite3::isTriggerEnabled<br>
 442 |     SQLite3::setTriggerEnabled<br>
 443 |     SQLite3::isForeignKeyEnabled<br>
 444 |     SQLite3::setForeignKeyEnabled<br>
 445 |     SQLite3::isFTS3TokenizerEnabled<br>
 446 |     SQLite3::setFTS3TokenizerEnabled<br>
 447 |     SQLite3::isLoadExtensionEnabled<br>
 448 |     SQLite3::setLoadExtensionEnabled<br>
 449 |     SQLite3::isCheckpointsOnCloseEnabled<br>
 450 |     SQLite3::setCheckpointsOnCloseEnabled</td>
 451 |   <td>　</td>
 452 |  </tr>
 453 |  <tr>
 454 |   <td>sqlite3_db_filename</td>
 455 |   <td>SQLite3::getDbFilename</td>
 456 |   <td>　</td>
 457 |  </tr>
 458 |  <tr>
 459 |   <td>sqlite3_db_handle</td>
 460 |   <td>Statement::getConnectionHandle</td>
 461 |   <td>　</td>
 462 |  </tr>
 463 |  <tr>
 464 |   <td>sqlite3_db_mutex</td>
 465 |   <td>N/A</td>
 466 |   <td>internal use only</td>
 467 |  </tr>
 468 |  <tr>
 469 |   <td>sqlite3_db_readonly</td>
 470 |   <td>SQLite3::isReadonly</td>
 471 |   <td>SQLite3::hasDb check if
 472 |   contains db</td>
 473 |  </tr>
 474 |  <tr>
 475 |   <td>sqlite3_db_release_memory</td>
 476 |   <td>SQLite3::releaseMemory</td>
 477 |   <td>　</td>
 478 |  </tr>
 479 |  <tr>
 480 |   <td>sqlite3_db_status</td>
 481 |   <td>SQLite3::getStatus</td>
 482 |   <td>　</td>
 483 |  </tr>
 484 |  <tr>
 485 |   <td>sqlite3_declare_vtab</td>
 486 |   <td>N/A</td>
 487 |   <td>for extension</td>
 488 |  </tr>
 489 |  <tr>
 490 |   <td>sqlite3_enable_load_extension</td>
 491 |   <td>SQLite3::setLoadExtension</td>
 492 |   <td>　</td>
 493 |  </tr>
 494 |  <tr>
 495 |   <td>sqlite3_enable_shared_cache</td>
 496 |   <td>SQLite3::setSharedCache</td>
 497 |   <td>　</td>
 498 |  </tr>
 499 |  <tr>
 500 |   <td>sqlite3_errcode</td>
 501 |   <td>SQLite3::getErrorCode</td>
 502 |   <td>　</td>
 503 |  </tr>
 504 |  <tr>
 505 |   <td>sqlite3_errmsg</td>
 506 |   <td>SQLite3::getErrorMsg</td>
 507 |   <td>　</td>
 508 |  </tr>
 509 |  <tr>
 510 |   <td>sqlite3_errmsg16</td>
 511 |   <td>N/A</td>
 512 |   <td>always UTF-8</td>
 513 |  </tr>
 514 |  <tr>
 515 |   <td>sqlite3_errstr</td>
 516 |   <td>SQLite3::errorCode2Msg</td>
 517 |   <td>　</td>
 518 |  </tr>
 519 |  <tr>
 520 |   <td>sqlite3_exec</td>
 521 |   <td>N/A</td>
 522 |   <td>convenience wrapper only</td>
 523 |  </tr>
 524 |  <tr>
 525 |   <td>sqlite3_expanded_sql</td>
 526 |   <td>SQLite3::getExpandedSql</td>
 527 |   <td>　</td>
 528 |  </tr>
 529 |  <tr>
 530 |   <td>sqlite3_expired</td>
 531 |   <td>N/A</td>
 532 |   <td>deprecated</td>
 533 |  </tr>
 534 |  <tr>
 535 |   <td>sqlite3_extended_errcode</td>
 536 |   <td>SQLite3::getExtendedErrorCode</td>
 537 |   <td>　</td>
 538 |  </tr>
 539 |  <tr>
 540 |   <td>sqlite3_extended_result_codes</td>
 541 |   <td>SQLite3::setResultCodes</td>
 542 |   <td>　</td>
 543 |  </tr>
 544 |  <tr>
 545 |   <td>sqlite3_file_control</td>
 546 |   <td>N/A</td>
 547 |   <td>too low level</td>
 548 |  </tr>
 549 |  <tr>
 550 |   <td>sqlite3_finalize</td>
 551 |   <td>SQLite3::~SQLite3</td>
 552 |   <td>　</td>
 553 |  </tr>
 554 |  <tr>
 555 |   <td>sqlite3_free</td>
 556 |   <td>N/A</td>
 557 |   <td>internal use only</td>
 558 |  </tr>
 559 |  <tr>
 560 |   <td>sqlite3_free_table</td>
 561 |   <td>N/A</td>
 562 |   <td>convenience wrapper only</td>
 563 |  </tr>
 564 |  <tr>
 565 |   <td>sqlite3_get_autocommit</td>
 566 |   <td>SQLite3::isAutoCommit</td>
 567 |   <td>　</td>
 568 |  </tr>
 569 |  <tr>
 570 |   <td>sqlite3_get_auxdata</td>
 571 |   <td>N/A</td>
 572 |   <td>for extension</td>
 573 |  </tr>
 574 |  <tr>
 575 |   <td>sqlite3_get_table</td>
 576 |   <td>N/A</td>
 577 |   <td>convenience wrapper only</td>
 578 |  </tr>
 579 |  <tr>
 580 |   <td>sqlite3_global_recover</td>
 581 |   <td>N/A</td>
 582 |   <td>deprecated</td>
 583 |  </tr>
 584 |  <tr>
 585 |   <td>sqlite3_initialize</td>
 586 |   <td>SQLite3::initialize</td>
 587 |   <td>static</td>
 588 |  </tr>
 589 |  <tr>
 590 |   <td>sqlite3_interrupt</td>
 591 |   <td>SQLite3::interrupt</td>
 592 |   <td>　</td>
 593 |  </tr>
 594 |  <tr>
 595 |   <td>sqlite3_last_insert_rowid</td>
 596 |   <td>SQLite3::getLastInsertRowId</td>
 597 |   <td>　</td>
 598 |  </tr>
 599 |  <tr>
 600 |   <td>sqlite3_libversion</td>
 601 |   <td>SQLite3::getVersion</td>
 602 |   <td>static</td>
 603 |  </tr>
 604 |  <tr>
 605 |   <td>sqlite3_libversion_number</td>
 606 |   <td>SQLite3::getVersionNumber</td>
 607 |   <td>static</td>
 608 |  </tr>
 609 |  <tr>
 610 |   <td>sqlite3_limit</td>
 611 |   <td>SQLite3::setLimit</td>
 612 |   <td>　</td>
 613 |  </tr>
 614 |  <tr>
 615 |   <td>sqlite3_load_extension</td>
 616 |   <td>SQLite3::loadExtension</td>
 617 |   <td>　</td>
 618 |  </tr>
 619 |  <tr>
 620 |   <td>sqlite3_log</td>
 621 |   <td>N/A</td>
 622 |   <td>for extension</td>
 623 |  </tr>
 624 |  <tr>
 625 |   <td>sqlite3_malloc</td>
 626 |   <td>N/A</td>
 627 |   <td>internal use only</td>
 628 |  </tr>
 629 |  <tr>
 630 |   <td>sqlite3_malloc64</td>
 631 |   <td>N/A</td>
 632 |   <td>internal use only</td>
 633 |  </tr>
 634 |  <tr>
 635 |   <td>sqlite3_memory_alarm</td>
 636 |   <td>N/A</td>
 637 |   <td>deprecated</td>
 638 |  </tr>
 639 |  <tr>
 640 |   <td>sqlite3_memory_highwater</td>
 641 |   <td>SQLite3::getMemoryHighwater,
 642 |   SQLite3::resetMemoryHighwater</td>
 643 |  </tr>
 644 |  <tr>
 645 |   <td>sqlite3_memory_used</td>
 646 |   <td>SQLite3::getMemoryUsed</td>
 647 |   <td>　</td>
 648 |  </tr>
 649 |  <tr>
 650 |   <td>sqlite3_mprintf</td>
 651 |   <td>N/A</td>
 652 |   <td>internal use only</td>
 653 |  </tr>
 654 |  <tr>
 655 |   <td>sqlite3_msize</td>
 656 |   <td>N/A</td>
 657 |   <td>internal use only</td>
 658 |  </tr>
 659 |  <tr>
 660 |   <td>sqlite3_mutex_alloc</td>
 661 |   <td>N/A</td>
 662 |   <td>internal use only</td>
 663 |  </tr>
 664 |  <tr>
 665 |   <td>sqlite3_mutex_enter</td>
 666 |   <td>N/A</td>
 667 |   <td>internal use only</td>
 668 |  </tr>
 669 |  <tr>
 670 |   <td>sqlite3_mutex_free</td>
 671 |   <td>N/A</td>
 672 |   <td>internal use only</td>
 673 |  </tr>
 674 |  <tr>
 675 |   <td>sqlite3_mutex_held</td>
 676 |   <td>N/A</td>
 677 |   <td>internal use only</td>
 678 |  </tr>
 679 |  <tr>
 680 |   <td>sqlite3_mutex_leave</td>
 681 |   <td>N/A</td>
 682 |   <td>internal use only</td>
 683 |  </tr>
 684 |  <tr>
 685 |   <td>sqlite3_mutex_notheld</td>
 686 |   <td>N/A</td>
 687 |   <td>internal use only</td>
 688 |  </tr>
 689 |  <tr>
 690 |   <td>sqlite3_mutex_try</td>
 691 |   <td>N/A</td>
 692 |   <td>internal use only</td>
 693 |  </tr>
 694 |  <tr>
 695 |   <td>sqlite3_next_stmt</td>
 696 |   <td>N/A</td>
 697 |   <td>no use</td>
 698 |  </tr>
 699 |  <tr>
 700 |   <td>sqlite3_open</td>
 701 |   <td>N/A</td>
 702 |   <td>use v2</td>
 703 |  </tr>
 704 |  <tr>
 705 |   <td>sqlite3_open16</td>
 706 |   <td>N/A</td>
 707 |   <td>always UTF-8</td>
 708 |  </tr>
 709 |  <tr>
 710 |   <td>sqlite3_open_v2</td>
 711 |   <td>SQLite3::SQLite3</td>
 712 |   <td>　</td>
 713 |  </tr>
 714 |  <tr>
 715 |   <td>sqlite3_os_end</td>
 716 |   <td>N/A</td>
 717 |   <td>internal use only</td>
 718 |  </tr>
 719 |  <tr>
 720 |   <td>sqlite3_os_init</td>
 721 |   <td>N/A</td>
 722 |   <td>internal use only</td>
 723 |  </tr>
 724 |  <tr>
 725 |   <td>sqlite3_overload_function</td>
 726 |   <td>N/A</td>
 727 |   <td>for extension</td>
 728 |  </tr>
 729 |  <tr>
 730 |   <td>sqlite3_prepare</td>
 731 |   <td>N/A</td>
 732 |   <td>use v2</td>
 733 |  </tr>
 734 |  <tr>
 735 |   <td>sqlite3_prepare16</td>
 736 |   <td>N/A</td>
 737 |   <td>always UTF-8</td>
 738 |  </tr>
 739 |  <tr>
 740 |   <td>sqlite3_prepare16_v2</td>
 741 |   <td>N/A</td>
 742 |   <td>always UTF-8</td>
 743 |  </tr>
 744 |  <tr>
 745 |   <td>sqlite3_prepare_v2</td>
 746 |   <td>Statement::Statement</td>
 747 |   <td>　</td>
 748 |  </tr>
 749 |  <tr>
 750 |   <td>sqlite3_preupdate_count</td>
 751 |   <td>N/A</td>
 752 |   <td>for extension</td>
 753 |  </tr>
 754 |  <tr>
 755 |   <td>sqlite3_preupdate_depth</td>
 756 |   <td>N/A</td>
 757 |   <td>for extension</td>
 758 |  </tr>
 759 |  <tr>
 760 |   <td>sqlite3_preupdate_hook</td>
 761 |   <td>N/A</td>
 762 |   <td>for extension</td>
 763 |  </tr>
 764 |  <tr>
 765 |   <td>sqlite3_preupdate_new</td>
 766 |   <td>N/A</td>
 767 |   <td>for extension</td>
 768 |  </tr>
 769 |  <tr>
 770 |   <td>sqlite3_preupdate_old</td>
 771 |   <td>N/A</td>
 772 |   <td>for extension</td>
 773 |  </tr>
 774 |  <tr>
 775 |   <td>sqlite3_profile</td>
 776 |   <td>N/A</td>
 777 |   <td>deprecated</td>
 778 |  </tr>
 779 |  <tr>
 780 |   <td>sqlite3_progress_handler</td>
 781 |   <td>N/A</td>
 782 |   <td>need callback</td>
 783 |  </tr>
 784 |  <tr>
 785 |   <td>sqlite3_randomness</td>
 786 |   <td>N/A</td>
 787 |   <td>use MQL Random</td>
 788 |  </tr>
 789 |  <tr>
 790 |   <td>sqlite3_realloc</td>
 791 |   <td>N/A</td>
 792 |   <td>internal use only</td>
 793 |  </tr>
 794 |  <tr>
 795 |   <td>sqlite3_realloc64</td>
 796 |   <td>N/A</td>
 797 |   <td>internal use only</td>
 798 |  </tr>
 799 |  <tr>
 800 |   <td>sqlite3_release_memory</td>
 801 |   <td>SQLite3::releaseMemoryInBytes</td>
 802 |   <td>static</td>
 803 |  </tr>
 804 |  <tr>
 805 |   <td>sqlite3_reset</td>
 806 |   <td>Statement::reset</td>
 807 |   <td>　</td>
 808 |  </tr>
 809 |  <tr>
 810 |   <td>sqlite3_reset_auto_extension</td>
 811 |   <td>N/A</td>
 812 |   <td>for extension</td>
 813 |  </tr>
 814 |  <tr>
 815 |   <td>sqlite3_result_blob</td>
 816 |   <td>N/A</td>
 817 |   <td>for extension</td>
 818 |  </tr>
 819 |  <tr>
 820 |   <td>sqlite3_result_blob64</td>
 821 |   <td>N/A</td>
 822 |   <td>for extension</td>
 823 |  </tr>
 824 |  <tr>
 825 |   <td>sqlite3_result_double</td>
 826 |   <td>N/A</td>
 827 |   <td>for extension</td>
 828 |  </tr>
 829 |  <tr>
 830 |   <td>sqlite3_result_error</td>
 831 |   <td>N/A</td>
 832 |   <td>for extension</td>
 833 |  </tr>
 834 |  <tr>
 835 |   <td>sqlite3_result_error16</td>
 836 |   <td>N/A</td>
 837 |   <td>for extension</td>
 838 |  </tr>
 839 |  <tr>
 840 |   <td>sqlite3_result_error_code</td>
 841 |   <td>N/A</td>
 842 |   <td>for extension</td>
 843 |  </tr>
 844 |  <tr>
 845 |   <td>sqlite3_result_error_nomem</td>
 846 |   <td>N/A</td>
 847 |   <td>for extension</td>
 848 |  </tr>
 849 |  <tr>
 850 |   <td>sqlite3_result_error_toobig</td>
 851 |   <td>N/A</td>
 852 |   <td>for extension</td>
 853 |  </tr>
 854 |  <tr>
 855 |   <td>sqlite3_result_int</td>
 856 |   <td>N/A</td>
 857 |   <td>for extension</td>
 858 |  </tr>
 859 |  <tr>
 860 |   <td>sqlite3_result_int64</td>
 861 |   <td>N/A</td>
 862 |   <td>for extension</td>
 863 |  </tr>
 864 |  <tr>
 865 |   <td>sqlite3_result_null</td>
 866 |   <td>N/A</td>
 867 |   <td>for extension</td>
 868 |  </tr>
 869 |  <tr>
 870 |   <td>sqlite3_result_subtype</td>
 871 |   <td>N/A</td>
 872 |   <td>for extension</td>
 873 |  </tr>
 874 |  <tr>
 875 |   <td>sqlite3_result_text</td>
 876 |   <td>N/A</td>
 877 |   <td>for extension</td>
 878 |  </tr>
 879 |  <tr>
 880 |   <td>sqlite3_result_text16</td>
 881 |   <td>N/A</td>
 882 |   <td>for extension</td>
 883 |  </tr>
 884 |  <tr>
 885 |   <td>sqlite3_result_text16be</td>
 886 |   <td>N/A</td>
 887 |   <td>for extension</td>
 888 |  </tr>
 889 |  <tr>
 890 |   <td>sqlite3_result_text16le</td>
 891 |   <td>N/A</td>
 892 |   <td>for extension</td>
 893 |  </tr>
 894 |  <tr>
 895 |   <td>sqlite3_result_text64</td>
 896 |   <td>N/A</td>
 897 |   <td>for extension</td>
 898 |  </tr>
 899 |  <tr>
 900 |   <td>sqlite3_result_value</td>
 901 |   <td>N/A</td>
 902 |   <td>for extension</td>
 903 |  </tr>
 904 |  <tr>
 905 |   <td>sqlite3_result_zeroblob</td>
 906 |   <td>N/A</td>
 907 |   <td>for extension</td>
 908 |  </tr>
 909 |  <tr>
 910 |   <td>sqlite3_result_zeroblob64</td>
 911 |   <td>N/A</td>
 912 |   <td>for extension</td>
 913 |  </tr>
 914 |  <tr>
 915 |   <td>sqlite3_rollback_hook</td>
 916 |   <td>N/A</td>
 917 |   <td>need callback</td>
 918 |  </tr>
 919 |  <tr>
 920 |   <td>sqlite3_set_authorizer</td>
 921 |   <td>N/A</td>
 922 |   <td>need callback</td>
 923 |  </tr>
 924 |  <tr>
 925 |   <td>sqlite3_set_auxdata</td>
 926 |   <td>N/A</td>
 927 |   <td>for extension</td>
 928 |  </tr>
 929 |  <tr>
 930 |   <td>sqlite3_set_last_insert_rowid</td>
 931 |   <td>SQLite3::setLastInsertRowId</td>
 932 |   <td>　</td>
 933 |  </tr>
 934 |  <tr>
 935 |   <td>sqlite3_shutdown</td>
 936 |   <td>SQLite3::shutdown</td>
 937 |   <td>　</td>
 938 |  </tr>
 939 |  <tr>
 940 |   <td>sqlite3_sleep</td>
 941 |   <td>N/A</td>
 942 |   <td>use MQL Sleep</td>
 943 |  </tr>
 944 |  <tr>
 945 |   <td>sqlite3_snapshot_cmp(exp)</td>
 946 |   <td>N/A</td>
 947 |   <td>experimental</td>
 948 |  </tr>
 949 |  <tr>
 950 |   <td>sqlite3_snapshot_free(exp)</td>
 951 |   <td>N/A</td>
 952 |   <td>experimental</td>
 953 |  </tr>
 954 |  <tr>
 955 |   <td>sqlite3_snapshot_get(exp)</td>
 956 |   <td>N/A</td>
 957 |   <td>experimental</td>
 958 |  </tr>
 959 |  <tr>
 960 |   <td>sqlite3_snapshot_open(exp)</td>
 961 |   <td>N/A</td>
 962 |   <td>experimental</td>
 963 |  </tr>
 964 |  <tr>
 965 |   <td>sqlite3_snapshot_recover(exp)</td>
 966 |   <td>N/A</td>
 967 |   <td>experimental</td>
 968 |  </tr>
 969 |  <tr>
 970 |   <td>sqlite3_snprintf</td>
 971 |   <td>N/A</td>
 972 |   <td>internal use only</td>
 973 |  </tr>
 974 |  <tr>
 975 |   <td>sqlite3_soft_heap_limit</td>
 976 |   <td>N/A</td>
 977 |   <td>deprecated</td>
 978 |  </tr>
 979 |  <tr>
 980 |   <td>sqlite3_soft_heap_limit64</td>
 981 |   <td>SQLite3::setSoftHeapLimit</td>
 982 |   <td>static</td>
 983 |  </tr>
 984 |  <tr>
 985 |   <td>sqlite3_sourceid</td>
 986 |   <td>SQLite3::getSourceId</td>
 987 |   <td>static</td>
 988 |  </tr>
 989 |  <tr>
 990 |   <td>sqlite3_sql</td>
 991 |   <td>Statement::getSql</td>
 992 |   <td>　</td>
 993 |  </tr>
 994 |  <tr>
 995 |   <td>sqlite3_status</td>
 996 |   <td>N/A</td>
 997 |   <td>use sqlite3_status64</td>
 998 |  </tr>
 999 |  <tr>
1000 |   <td>sqlite3_status64</td>
1001 |   <td>SQLite3::status</td>
1002 |   <td>　</td>
1003 |  </tr>
1004 |  <tr>
1005 |   <td>sqlite3_step</td>
1006 |   <td>Statement::step</td>
1007 |   <td>　</td>
1008 |  </tr>
1009 |  <tr>
1010 |   <td>sqlite3_stmt_busy</td>
1011 |   <td>Statement::isBusy</td>
1012 |   <td>　</td>
1013 |  </tr>
1014 |  <tr>
1015 |   <td>sqlite3_stmt_readonly</td>
1016 |   <td>Statement::isReadonly</td>
1017 |   <td>　</td>
1018 |  </tr>
1019 |  <tr>
1020 |   <td>sqlite3_stmt_scanstatus</td>
1021 |   <td>N/A</td>
1022 |   <td>advanced/optional</td>
1023 |  </tr>
1024 |  <tr>
1025 |   <td>sqlite3_stmt_scanstatus_reset</td>
1026 |   <td>N/A</td>
1027 |   <td>advanced/optional</td>
1028 |  </tr>
1029 |  <tr>
1030 |   <td>sqlite3_stmt_status</td>
1031 |   <td>Statement::getCounter,
1032 |   Statement::resetCounter</td>
1033 |   <td>　</td>
1034 |  </tr>
1035 |  <tr>
1036 |   <td>sqlite3_strglob</td>
1037 |   <td>N/A</td>
1038 |   <td>internal use only</td>
1039 |  </tr>
1040 |  <tr>
1041 |   <td>sqlite3_stricmp</td>
1042 |   <td>N/A</td>
1043 |   <td>internal use only</td>
1044 |  </tr>
1045 |  <tr>
1046 |   <td>sqlite3_strlike</td>
1047 |   <td>N/A</td>
1048 |   <td>internal use only</td>
1049 |  </tr>
1050 |  <tr>
1051 |   <td>sqlite3_strnicmp</td>
1052 |   <td>N/A</td>
1053 |   <td>internal use only</td>
1054 |  </tr>
1055 |  <tr>
1056 |   <td>sqlite3_system_errno</td>
1057 |   <td>N/A</td>
1058 |   <td>internal use only</td>
1059 |  </tr>
1060 |  <tr>
1061 |   <td>sqlite3_table_column_metadata</td>
1062 |   <td>SQLite3::getDbColumnMetadata</td>
1063 |   <td>　</td>
1064 |  </tr>
1065 |  <tr>
1066 |   <td>sqlite3_test_control</td>
1067 |   <td>N/A</td>
1068 |   <td>internal use only</td>
1069 |  </tr>
1070 |  <tr>
1071 |   <td>sqlite3_thread_cleanup</td>
1072 |   <td>N/A</td>
1073 |   <td>deprecated</td>
1074 |  </tr>
1075 |  <tr>
1076 |   <td>sqlite3_threadsafe</td>
1077 |   <td>SQLite3::isThreadSafe</td>
1078 |   <td>　</td>
1079 |  </tr>
1080 |  <tr>
1081 |   <td>sqlite3_total_changes</td>
1082 |   <td>SQLite3::getTotalChanges</td>
1083 |   <td>　</td>
1084 |  </tr>
1085 |  <tr>
1086 |   <td>sqlite3_trace</td>
1087 |   <td>N/A</td>
1088 |   <td>deprecated</td>
1089 |  </tr>
1090 |  <tr>
1091 |   <td>sqlite3_trace_v2</td>
1092 |   <td>N/A</td>
1093 |   <td>need callback</td>
1094 |  </tr>
1095 |  <tr>
1096 |   <td>sqlite3_transfer_bindings</td>
1097 |   <td>N/A</td>
1098 |   <td>deprecated</td>
1099 |  </tr>
1100 |  <tr>
1101 |   <td>sqlite3_unlock_notify</td>
1102 |   <td>N/A</td>
1103 |   <td>need callback</td>
1104 |  </tr>
1105 |  <tr>
1106 |   <td>sqlite3_update_hook</td>
1107 |   <td>N/A</td>
1108 |   <td>need callback</td>
1109 |  </tr>
1110 |  <tr>
1111 |   <td>sqlite3_uri_boolean</td>
1112 |   <td>N/A</td>
1113 |   <td>for extension</td>
1114 |  </tr>
1115 |  <tr>
1116 |   <td>sqlite3_uri_int64</td>
1117 |   <td>N/A</td>
1118 |   <td>for extension</td>
1119 |  </tr>
1120 |  <tr>
1121 |   <td>sqlite3_uri_parameter</td>
1122 |   <td>N/A</td>
1123 |   <td>for extension</td>
1124 |  </tr>
1125 |  <tr>
1126 |   <td>sqlite3_user_data</td>
1127 |   <td>N/A</td>
1128 |   <td>for extension</td>
1129 |  </tr>
1130 |  <tr>
1131 |   <td>sqlite3_value_blob</td>
1132 |   <td>N/A</td>
1133 |   <td>for extension</td>
1134 |  </tr>
1135 |  <tr>
1136 |   <td>sqlite3_value_bytes</td>
1137 |   <td>N/A</td>
1138 |   <td>for extension</td>
1139 |  </tr>
1140 |  <tr>
1141 |   <td>sqlite3_value_bytes16</td>
1142 |   <td>N/A</td>
1143 |   <td>for extension</td>
1144 |  </tr>
1145 |  <tr>
1146 |   <td>sqlite3_value_double</td>
1147 |   <td>N/A</td>
1148 |   <td>for extension</td>
1149 |  </tr>
1150 |  <tr>
1151 |   <td>sqlite3_value_dup</td>
1152 |   <td>N/A</td>
1153 |   <td>for extension</td>
1154 |  </tr>
1155 |  <tr>
1156 |   <td>sqlite3_value_free</td>
1157 |   <td>N/A</td>
1158 |   <td>for extension</td>
1159 |  </tr>
1160 |  <tr>
1161 |   <td>sqlite3_value_int</td>
1162 |   <td>N/A</td>
1163 |   <td>for extension</td>
1164 |  </tr>
1165 |  <tr>
1166 |   <td>sqlite3_value_int64</td>
1167 |   <td>N/A</td>
1168 |   <td>for extension</td>
1169 |  </tr>
1170 |  <tr>
1171 |   <td>sqlite3_value_numeric_type</td>
1172 |   <td>N/A</td>
1173 |   <td>for extension</td>
1174 |  </tr>
1175 |  <tr>
1176 |   <td>sqlite3_value_subtype</td>
1177 |   <td>N/A</td>
1178 |   <td>for extension</td>
1179 |  </tr>
1180 |  <tr>
1181 |   <td>sqlite3_value_text</td>
1182 |   <td>N/A</td>
1183 |   <td>for extension</td>
1184 |  </tr>
1185 |  <tr>
1186 |   <td>sqlite3_value_text16</td>
1187 |   <td>N/A</td>
1188 |   <td>for extension</td>
1189 |  </tr>
1190 |  <tr>
1191 |   <td>sqlite3_value_text16be</td>
1192 |   <td>N/A</td>
1193 |   <td>for extension</td>
1194 |  </tr>
1195 |  <tr>
1196 |   <td>sqlite3_value_text16le</td>
1197 |   <td>N/A</td>
1198 |   <td>for extension</td>
1199 |  </tr>
1200 |  <tr>
1201 |   <td>sqlite3_value_type</td>
1202 |   <td>N/A</td>
1203 |   <td>for extension</td>
1204 |  </tr>
1205 |  <tr>
1206 |   <td>sqlite3_version</td>
1207 |   <td>N/A</td>
1208 |   <td>not a function</td>
1209 |  </tr>
1210 |  <tr>
1211 |   <td>sqlite3_vfs_find</td>
1212 |   <td>Vfs::find, Vfs::getDefault</td>
1213 |   <td>　</td>
1214 |  </tr>
1215 |  <tr>
1216 |   <td>sqlite3_vfs_register</td>
1217 |   <td>Vfs::register,
1218 |   Vfs::registerDefault</td>
1219 |   <td>　</td>
1220 |  </tr>
1221 |  <tr>
1222 |   <td>sqlite3_vfs_unregister</td>
1223 |   <td>Vfs::unregister</td>
1224 |   <td>　</td>
1225 |  </tr>
1226 |  <tr>
1227 |   <td>sqlite3_vmprintf</td>
1228 |   <td>N/A</td>
1229 |   <td>internal use only</td>
1230 |  </tr>
1231 |  <tr>
1232 |   <td>sqlite3_vsnprintf</td>
1233 |   <td>N/A</td>
1234 |   <td>internal use only</td>
1235 |  </tr>
1236 |  <tr>
1237 |   <td>sqlite3_vtab_config</td>
1238 |   <td>N/A</td>
1239 |   <td>for extension</td>
1240 |  </tr>
1241 |  <tr>
1242 |   <td>sqlite3_vtab_on_conflict</td>
1243 |   <td>N/A</td>
1244 |   <td>for extension</td>
1245 |  </tr>
1246 |  <tr>
1247 |   <td>sqlite3_wal_autocheckpoint</td>
1248 |   <td>SQLite3::setAutoCheckpoint</td>
1249 |   <td>　</td>
1250 |  </tr>
1251 |  <tr>
1252 |   <td>sqlite3_wal_checkpoint</td>
1253 |   <td>N/A</td>
1254 |   <td>use v2</td>
1255 |  </tr>
1256 |  <tr>
1257 |   <td>sqlite3_wal_checkpoint_v2</td>
1258 |   <td>SQLite3::checkpoint</td>
1259 |   <td>　</td>
1260 |  </tr>
1261 |  <tr>
1262 |   <td>sqlite3_wal_hook</td>
1263 |   <td>N/A</td>
1264 |   <td>need callback</td>
1265 |  </tr>
1266 |  </tbody>
1267 | </table>
1268 | 
1269 | ## About string encoding and API choices
1270 | 
1271 | MQL strings are Win32 UNICODE strings (basically 2-byte UTF-16). While for
1272 | several APIs, SQLite3 provides both UTF-8 and UTF-16 versions, only UTF-8
1273 | strings are accepted in other APIs. For unification and maximum
1274 | interoperabibility, we only use the UTF-8 version of the APIs. In this binding
1275 | all strings are converted to utf-8 strings before sending to the dll layer. And
1276 | strings in the database are also UTF-8 encoded.
1277 | 
1278 | ## About callbacks, internal APIs, and convenience wrappers
1279 | 
1280 | A lot of SQLite3 APIs are for internal use only, or for extension development,
1281 | or need a C function as callback. These are not included in this binding. This
1282 | will not affect the general applicability of this binding for most application
1283 | level usage.
1284 | 
1285 | APIs like `sqlite3_exec`, `sqlite3_get_table`, etc. are convenience wrappers,
1286 | which are not included. Maybe I will implement them in MQL.
1287 | 
1288 | ## Usage
1289 | 
1290 | You'd better read the official documentation or some books about SQLite before
1291 | using this library. Documentation about this binding will be added when I have
1292 | the time to finish them. You can find a simple test script in `Scripts/Test`.
1293 | Here is a sample from `TestSQLite3.mq4`:
1294 | 
1295 | ```MQL5
1296 | //+------------------------------------------------------------------+
1297 | //|                                                  TestSQLite3.mq4 |
1298 | //|                                          Copyright 2017, Li Ding |
1299 | //|                                            dingmaotu@hotmail.com |
1300 | //+------------------------------------------------------------------+
1301 | #property copyright "Copyright 2017, Li Ding"
1302 | #property link      "dingmaotu@hotmail.com"
1303 | #property version   "1.00"
1304 | #property strict
1305 | 
1306 | #include <SQLite3/Statement.mqh>
1307 | //+------------------------------------------------------------------+
1308 | //| Script program start function                                    |
1309 | //+------------------------------------------------------------------+
1310 | void OnStart()
1311 |   {
1312 | //--- optional but recommended
1313 |    SQLite3::initialize();
1314 | 
1315 | //--- ensure the dll and the lib is of the same version
1316 |    Print(SQLite3::getVersionNumber(), " = ", SQLITE_VERSION_NUMBER);
1317 |    Print(SQLite3::getVersion(), " = ", SQLITE_VERSION);
1318 |    Print(SQLite3::getSourceId(), " = ", SQLITE_SOURCE_ID);
1319 | 
1320 | //--- create an empty db
1321 | #ifdef __MQL5__
1322 |    string filesPath=TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL5\\Files";
1323 | #else
1324 |    string filesPath=TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL4\\Files";
1325 | #endif
1326 |    string dbPath=filesPath+"\\test.db";
1327 |    Print(dbPath);
1328 | 
1329 |    SQLite3 db(dbPath,SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
1330 |    if(!db.isValid()) return;
1331 | 
1332 |    Print("DB created.");
1333 |    string sql="create table buy_orders"
1334 |               "(a int, b text);";
1335 |    if(Statement::isComplete(sql))
1336 |       Print(">>> SQL is complete");
1337 |    else
1338 |       Print(">>> SQL not complete");
1339 | 
1340 |    Statement s(db,sql);
1341 | 
1342 |    if(!s.isValid())
1343 |      {
1344 |       Print(db.getErrorMsg());
1345 |       return;
1346 |      }
1347 | 
1348 |    int r=s.step();
1349 |    if(r == SQLITE_OK)
1350 |       Print(">>> Step finished.");
1351 |    else if(r==SQLITE_DONE)
1352 |       Print(">>> Successfully created table.");
1353 |    else
1354 |       Print(">>> Error executing statement: ",db.getErrorMsg());
1355 | 
1356 | //--- optional but recommended
1357 |    SQLite3::shutdown();
1358 |   }
1359 | ```
1360 | 
1361 | Here is a sample for select:
1362 | 
1363 | ```MQL5
1364 | //+------------------------------------------------------------------+
1365 | //|                                            TestSQLite3Select.mq4 |
1366 | //|                                          Copyright 2018, Li Ding |
1367 | //|                                            dingmaotu@hotmail.com |
1368 | //+------------------------------------------------------------------+
1369 | #property copyright "Copyright 2018, Li Ding"
1370 | #property link      "dingmaotu@hotmail.com"
1371 | #property version   "1.00"
1372 | #property strict
1373 | 
1374 | #include <SQLite3/Statement.mqh>
1375 | //+------------------------------------------------------------------+
1376 | //| Script program start function                                    |
1377 | //+------------------------------------------------------------------+
1378 | void OnStart()
1379 |   {
1380 | //--- optional but recommended
1381 |    SQLite3::initialize();
1382 | 
1383 | //--- open database
1384 | #ifdef __MQL5__
1385 |    string filesPath=TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL5\\Files";
1386 | #else
1387 |    string filesPath=TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL4\\Files";
1388 | #endif
1389 |    string dbPath=filesPath+"\\test.db";
1390 |    Print(dbPath);
1391 | 
1392 |    SQLite3 db(dbPath,SQLITE_OPEN_READWRITE);
1393 |    if(!db.isValid()) return;
1394 | 
1395 |    string sql="select a, b from buy_orders;";
1396 | 
1397 |    Statement s(db,sql);
1398 | 
1399 |    if(!s.isValid())
1400 |      {
1401 |       Print(db.getErrorMsg());
1402 |       return;
1403 |      }
1404 | 
1405 |    int r=s.step();
1406 |    do
1407 |      {
1408 |       if(r==SQLITE_ROW)
1409 |         {
1410 |          Print(">>> New row!");
1411 |          int c=s.getColumnCount();
1412 |          for(int i=0; i<c; i++)
1413 |            {
1414 |             if(i==0)
1415 |               {
1416 |                int value;
1417 |                s.getColumn(i,value);
1418 |                Print(s.getColumnName(i),": ",value);
1419 |               }
1420 |             else if(i==1)
1421 |               {
1422 |                string value;
1423 |                s.getColumn(i,value);
1424 |                Print(s.getColumnName(i),": ",value);
1425 |               }
1426 |            }
1427 |         }
1428 |       else
1429 |          break;
1430 | 
1431 |       r=s.step();
1432 |      }
1433 |    while(r!=SQLITE_DONE);
1434 | 
1435 | //--- optional but recommended
1436 |    SQLite3::shutdown();
1437 |   }
1438 | //+------------------------------------------------------------------+
1439 | ```
1440 | 
1441 | 
1442 | ## TODO
1443 | 
1444 | 1. Write more tests.
1445 | 2. Documentation.
1446 | 
1447 | ## Changes
1448 | 
1449 | * 2017-06-21: Initial version. Alpha quality, needs more tests.
1450 | 


--------------------------------------------------------------------------------
/Scripts/Test/TestSQLite3.mq4:
--------------------------------------------------------------------------------
 1 | //+------------------------------------------------------------------+
 2 | //|                                                  TestSQLite3.mq4 |
 3 | //|                                          Copyright 2017, Li Ding |
 4 | //|                                                dingmaotu@126.com |
 5 | //+------------------------------------------------------------------+
 6 | #property copyright "Copyright 2017, Li Ding"
 7 | #property link      "dingmaotu@126.com"
 8 | #property version   "1.00"
 9 | #property strict
10 | 
11 | #include <SQLite3/Statement.mqh>
12 | //+------------------------------------------------------------------+
13 | //| Script program start function                                    |
14 | //+------------------------------------------------------------------+
15 | void OnStart()
16 |   {
17 | //--- optional but recommended
18 |    SQLite3::initialize();
19 | 
20 | //--- ensure the dll and the lib is of the same version
21 |    Print(SQLite3::getVersionNumber(), " = ", SQLITE_VERSION_NUMBER);
22 |    Print(SQLite3::getVersion(), " = ", SQLITE_VERSION);
23 |    Print(SQLite3::getSourceId(), " = ", SQLITE_SOURCE_ID);
24 | 
25 | //--- create an empty db
26 | #ifdef __MQL5__
27 |    string filesPath=TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL5\\Files";
28 | #else
29 |    string filesPath=TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL4\\Files";
30 | #endif
31 |    string dbPath=filesPath+"\\test.db";
32 |    Print(dbPath);
33 | 
34 |    SQLite3 db(dbPath,SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE);
35 |    if(!db.isValid()) return;
36 | 
37 |    Print("DB created.");
38 |    string sql="create table buy_orders"
39 |               "(a int, b text);";
40 |    if(Statement::isComplete(sql))
41 |       Print(">>> SQL is complete");
42 |    else
43 |       Print(">>> SQL not complete");
44 | 
45 |    Statement s(db,sql);
46 | 
47 |    if(!s.isValid())
48 |      {
49 |       Print(db.getErrorMsg());
50 |       return;
51 |      }
52 | 
53 |    int r=s.step();
54 |    if(r == SQLITE_OK)
55 |       Print(">>> Step finished.");
56 |    else if(r==SQLITE_DONE)
57 |       Print(">>> Successfully created table.");
58 |    else
59 |       Print(">>> Error executing statement: ",db.getErrorMsg());
60 | 
61 | //--- optional but recommended
62 |    SQLite3::shutdown();
63 |   }
64 | //+------------------------------------------------------------------+
65 | 


--------------------------------------------------------------------------------