1#![allow(non_snake_case)]
4#![allow(dead_code)]
5#![allow(non_camel_case_types)]
6
7pub const SQLITE_VERSION: &[u8; 7usize] = b"3.38.5\0";
8pub const SQLITE_VERSION_NUMBER: i32 = 3038005;
9pub const SQLITE_SOURCE_ID: &[u8; 85usize] =
10 b"2022-05-06 15:25:27 78d9c993d404cdfaa7fdd2973fa1052e3da9f66215cff9c5540ebe55c407d9fe\0";
11pub const SQLITE_OK: i32 = 0;
12pub const SQLITE_ERROR: i32 = 1;
13pub const SQLITE_INTERNAL: i32 = 2;
14pub const SQLITE_PERM: i32 = 3;
15pub const SQLITE_ABORT: i32 = 4;
16pub const SQLITE_BUSY: i32 = 5;
17pub const SQLITE_LOCKED: i32 = 6;
18pub const SQLITE_NOMEM: i32 = 7;
19pub const SQLITE_READONLY: i32 = 8;
20pub const SQLITE_INTERRUPT: i32 = 9;
21pub const SQLITE_IOERR: i32 = 10;
22pub const SQLITE_CORRUPT: i32 = 11;
23pub const SQLITE_NOTFOUND: i32 = 12;
24pub const SQLITE_FULL: i32 = 13;
25pub const SQLITE_CANTOPEN: i32 = 14;
26pub const SQLITE_PROTOCOL: i32 = 15;
27pub const SQLITE_EMPTY: i32 = 16;
28pub const SQLITE_SCHEMA: i32 = 17;
29pub const SQLITE_TOOBIG: i32 = 18;
30pub const SQLITE_CONSTRAINT: i32 = 19;
31pub const SQLITE_MISMATCH: i32 = 20;
32pub const SQLITE_MISUSE: i32 = 21;
33pub const SQLITE_NOLFS: i32 = 22;
34pub const SQLITE_AUTH: i32 = 23;
35pub const SQLITE_FORMAT: i32 = 24;
36pub const SQLITE_RANGE: i32 = 25;
37pub const SQLITE_NOTADB: i32 = 26;
38pub const SQLITE_NOTICE: i32 = 27;
39pub const SQLITE_WARNING: i32 = 28;
40pub const SQLITE_ROW: i32 = 100;
41pub const SQLITE_DONE: i32 = 101;
42pub const SQLITE_ERROR_MISSING_COLLSEQ: i32 = 257;
43pub const SQLITE_ERROR_RETRY: i32 = 513;
44pub const SQLITE_ERROR_SNAPSHOT: i32 = 769;
45pub const SQLITE_IOERR_READ: i32 = 266;
46pub const SQLITE_IOERR_SHORT_READ: i32 = 522;
47pub const SQLITE_IOERR_WRITE: i32 = 778;
48pub const SQLITE_IOERR_FSYNC: i32 = 1034;
49pub const SQLITE_IOERR_DIR_FSYNC: i32 = 1290;
50pub const SQLITE_IOERR_TRUNCATE: i32 = 1546;
51pub const SQLITE_IOERR_FSTAT: i32 = 1802;
52pub const SQLITE_IOERR_UNLOCK: i32 = 2058;
53pub const SQLITE_IOERR_RDLOCK: i32 = 2314;
54pub const SQLITE_IOERR_DELETE: i32 = 2570;
55pub const SQLITE_IOERR_BLOCKED: i32 = 2826;
56pub const SQLITE_IOERR_NOMEM: i32 = 3082;
57pub const SQLITE_IOERR_ACCESS: i32 = 3338;
58pub const SQLITE_IOERR_CHECKRESERVEDLOCK: i32 = 3594;
59pub const SQLITE_IOERR_LOCK: i32 = 3850;
60pub const SQLITE_IOERR_CLOSE: i32 = 4106;
61pub const SQLITE_IOERR_DIR_CLOSE: i32 = 4362;
62pub const SQLITE_IOERR_SHMOPEN: i32 = 4618;
63pub const SQLITE_IOERR_SHMSIZE: i32 = 4874;
64pub const SQLITE_IOERR_SHMLOCK: i32 = 5130;
65pub const SQLITE_IOERR_SHMMAP: i32 = 5386;
66pub const SQLITE_IOERR_SEEK: i32 = 5642;
67pub const SQLITE_IOERR_DELETE_NOENT: i32 = 5898;
68pub const SQLITE_IOERR_MMAP: i32 = 6154;
69pub const SQLITE_IOERR_GETTEMPPATH: i32 = 6410;
70pub const SQLITE_IOERR_CONVPATH: i32 = 6666;
71pub const SQLITE_IOERR_VNODE: i32 = 6922;
72pub const SQLITE_IOERR_AUTH: i32 = 7178;
73pub const SQLITE_IOERR_BEGIN_ATOMIC: i32 = 7434;
74pub const SQLITE_IOERR_COMMIT_ATOMIC: i32 = 7690;
75pub const SQLITE_IOERR_ROLLBACK_ATOMIC: i32 = 7946;
76pub const SQLITE_IOERR_DATA: i32 = 8202;
77pub const SQLITE_IOERR_CORRUPTFS: i32 = 8458;
78pub const SQLITE_LOCKED_SHAREDCACHE: i32 = 262;
79pub const SQLITE_LOCKED_VTAB: i32 = 518;
80pub const SQLITE_BUSY_RECOVERY: i32 = 261;
81pub const SQLITE_BUSY_SNAPSHOT: i32 = 517;
82pub const SQLITE_BUSY_TIMEOUT: i32 = 773;
83pub const SQLITE_CANTOPEN_NOTEMPDIR: i32 = 270;
84pub const SQLITE_CANTOPEN_ISDIR: i32 = 526;
85pub const SQLITE_CANTOPEN_FULLPATH: i32 = 782;
86pub const SQLITE_CANTOPEN_CONVPATH: i32 = 1038;
87pub const SQLITE_CANTOPEN_DIRTYWAL: i32 = 1294;
88pub const SQLITE_CANTOPEN_SYMLINK: i32 = 1550;
89pub const SQLITE_CORRUPT_VTAB: i32 = 267;
90pub const SQLITE_CORRUPT_SEQUENCE: i32 = 523;
91pub const SQLITE_CORRUPT_INDEX: i32 = 779;
92pub const SQLITE_READONLY_RECOVERY: i32 = 264;
93pub const SQLITE_READONLY_CANTLOCK: i32 = 520;
94pub const SQLITE_READONLY_ROLLBACK: i32 = 776;
95pub const SQLITE_READONLY_DBMOVED: i32 = 1032;
96pub const SQLITE_READONLY_CANTINIT: i32 = 1288;
97pub const SQLITE_READONLY_DIRECTORY: i32 = 1544;
98pub const SQLITE_ABORT_ROLLBACK: i32 = 516;
99pub const SQLITE_CONSTRAINT_CHECK: i32 = 275;
100pub const SQLITE_CONSTRAINT_COMMITHOOK: i32 = 531;
101pub const SQLITE_CONSTRAINT_FOREIGNKEY: i32 = 787;
102pub const SQLITE_CONSTRAINT_FUNCTION: i32 = 1043;
103pub const SQLITE_CONSTRAINT_NOTNULL: i32 = 1299;
104pub const SQLITE_CONSTRAINT_PRIMARYKEY: i32 = 1555;
105pub const SQLITE_CONSTRAINT_TRIGGER: i32 = 1811;
106pub const SQLITE_CONSTRAINT_UNIQUE: i32 = 2067;
107pub const SQLITE_CONSTRAINT_VTAB: i32 = 2323;
108pub const SQLITE_CONSTRAINT_ROWID: i32 = 2579;
109pub const SQLITE_CONSTRAINT_PINNED: i32 = 2835;
110pub const SQLITE_CONSTRAINT_DATATYPE: i32 = 3091;
111pub const SQLITE_NOTICE_RECOVER_WAL: i32 = 283;
112pub const SQLITE_NOTICE_RECOVER_ROLLBACK: i32 = 539;
113pub const SQLITE_WARNING_AUTOINDEX: i32 = 284;
114pub const SQLITE_AUTH_USER: i32 = 279;
115pub const SQLITE_OK_LOAD_PERMANENTLY: i32 = 256;
116pub const SQLITE_OK_SYMLINK: i32 = 512;
117pub const SQLITE_OPEN_READONLY: i32 = 1;
118pub const SQLITE_OPEN_READWRITE: i32 = 2;
119pub const SQLITE_OPEN_CREATE: i32 = 4;
120pub const SQLITE_OPEN_DELETEONCLOSE: i32 = 8;
121pub const SQLITE_OPEN_EXCLUSIVE: i32 = 16;
122pub const SQLITE_OPEN_AUTOPROXY: i32 = 32;
123pub const SQLITE_OPEN_URI: i32 = 64;
124pub const SQLITE_OPEN_MEMORY: i32 = 128;
125pub const SQLITE_OPEN_MAIN_DB: i32 = 256;
126pub const SQLITE_OPEN_TEMP_DB: i32 = 512;
127pub const SQLITE_OPEN_TRANSIENT_DB: i32 = 1024;
128pub const SQLITE_OPEN_MAIN_JOURNAL: i32 = 2048;
129pub const SQLITE_OPEN_TEMP_JOURNAL: i32 = 4096;
130pub const SQLITE_OPEN_SUBJOURNAL: i32 = 8192;
131pub const SQLITE_OPEN_SUPER_JOURNAL: i32 = 16384;
132pub const SQLITE_OPEN_NOMUTEX: i32 = 32768;
133pub const SQLITE_OPEN_FULLMUTEX: i32 = 65536;
134pub const SQLITE_OPEN_SHAREDCACHE: i32 = 131072;
135pub const SQLITE_OPEN_PRIVATECACHE: i32 = 262144;
136pub const SQLITE_OPEN_WAL: i32 = 524288;
137pub const SQLITE_OPEN_NOFOLLOW: i32 = 16777216;
138pub const SQLITE_OPEN_EXRESCODE: i32 = 33554432;
139pub const SQLITE_OPEN_MASTER_JOURNAL: i32 = 16384;
140pub const SQLITE_IOCAP_ATOMIC: i32 = 1;
141pub const SQLITE_IOCAP_ATOMIC512: i32 = 2;
142pub const SQLITE_IOCAP_ATOMIC1K: i32 = 4;
143pub const SQLITE_IOCAP_ATOMIC2K: i32 = 8;
144pub const SQLITE_IOCAP_ATOMIC4K: i32 = 16;
145pub const SQLITE_IOCAP_ATOMIC8K: i32 = 32;
146pub const SQLITE_IOCAP_ATOMIC16K: i32 = 64;
147pub const SQLITE_IOCAP_ATOMIC32K: i32 = 128;
148pub const SQLITE_IOCAP_ATOMIC64K: i32 = 256;
149pub const SQLITE_IOCAP_SAFE_APPEND: i32 = 512;
150pub const SQLITE_IOCAP_SEQUENTIAL: i32 = 1024;
151pub const SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN: i32 = 2048;
152pub const SQLITE_IOCAP_POWERSAFE_OVERWRITE: i32 = 4096;
153pub const SQLITE_IOCAP_IMMUTABLE: i32 = 8192;
154pub const SQLITE_IOCAP_BATCH_ATOMIC: i32 = 16384;
155pub const SQLITE_LOCK_NONE: i32 = 0;
156pub const SQLITE_LOCK_SHARED: i32 = 1;
157pub const SQLITE_LOCK_RESERVED: i32 = 2;
158pub const SQLITE_LOCK_PENDING: i32 = 3;
159pub const SQLITE_LOCK_EXCLUSIVE: i32 = 4;
160pub const SQLITE_SYNC_NORMAL: i32 = 2;
161pub const SQLITE_SYNC_FULL: i32 = 3;
162pub const SQLITE_SYNC_DATAONLY: i32 = 16;
163pub const SQLITE_FCNTL_LOCKSTATE: i32 = 1;
164pub const SQLITE_FCNTL_GET_LOCKPROXYFILE: i32 = 2;
165pub const SQLITE_FCNTL_SET_LOCKPROXYFILE: i32 = 3;
166pub const SQLITE_FCNTL_LAST_ERRNO: i32 = 4;
167pub const SQLITE_FCNTL_SIZE_HINT: i32 = 5;
168pub const SQLITE_FCNTL_CHUNK_SIZE: i32 = 6;
169pub const SQLITE_FCNTL_FILE_POINTER: i32 = 7;
170pub const SQLITE_FCNTL_SYNC_OMITTED: i32 = 8;
171pub const SQLITE_FCNTL_WIN32_AV_RETRY: i32 = 9;
172pub const SQLITE_FCNTL_PERSIST_WAL: i32 = 10;
173pub const SQLITE_FCNTL_OVERWRITE: i32 = 11;
174pub const SQLITE_FCNTL_VFSNAME: i32 = 12;
175pub const SQLITE_FCNTL_POWERSAFE_OVERWRITE: i32 = 13;
176pub const SQLITE_FCNTL_PRAGMA: i32 = 14;
177pub const SQLITE_FCNTL_BUSYHANDLER: i32 = 15;
178pub const SQLITE_FCNTL_TEMPFILENAME: i32 = 16;
179pub const SQLITE_FCNTL_MMAP_SIZE: i32 = 18;
180pub const SQLITE_FCNTL_TRACE: i32 = 19;
181pub const SQLITE_FCNTL_HAS_MOVED: i32 = 20;
182pub const SQLITE_FCNTL_SYNC: i32 = 21;
183pub const SQLITE_FCNTL_COMMIT_PHASETWO: i32 = 22;
184pub const SQLITE_FCNTL_WIN32_SET_HANDLE: i32 = 23;
185pub const SQLITE_FCNTL_WAL_BLOCK: i32 = 24;
186pub const SQLITE_FCNTL_ZIPVFS: i32 = 25;
187pub const SQLITE_FCNTL_RBU: i32 = 26;
188pub const SQLITE_FCNTL_VFS_POINTER: i32 = 27;
189pub const SQLITE_FCNTL_JOURNAL_POINTER: i32 = 28;
190pub const SQLITE_FCNTL_WIN32_GET_HANDLE: i32 = 29;
191pub const SQLITE_FCNTL_PDB: i32 = 30;
192pub const SQLITE_FCNTL_BEGIN_ATOMIC_WRITE: i32 = 31;
193pub const SQLITE_FCNTL_COMMIT_ATOMIC_WRITE: i32 = 32;
194pub const SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE: i32 = 33;
195pub const SQLITE_FCNTL_LOCK_TIMEOUT: i32 = 34;
196pub const SQLITE_FCNTL_DATA_VERSION: i32 = 35;
197pub const SQLITE_FCNTL_SIZE_LIMIT: i32 = 36;
198pub const SQLITE_FCNTL_CKPT_DONE: i32 = 37;
199pub const SQLITE_FCNTL_RESERVE_BYTES: i32 = 38;
200pub const SQLITE_FCNTL_CKPT_START: i32 = 39;
201pub const SQLITE_FCNTL_EXTERNAL_READER: i32 = 40;
202pub const SQLITE_FCNTL_CKSM_FILE: i32 = 41;
203pub const SQLITE_GET_LOCKPROXYFILE: i32 = 2;
204pub const SQLITE_SET_LOCKPROXYFILE: i32 = 3;
205pub const SQLITE_LAST_ERRNO: i32 = 4;
206pub const SQLITE_ACCESS_EXISTS: i32 = 0;
207pub const SQLITE_ACCESS_READWRITE: i32 = 1;
208pub const SQLITE_ACCESS_READ: i32 = 2;
209pub const SQLITE_SHM_UNLOCK: i32 = 1;
210pub const SQLITE_SHM_LOCK: i32 = 2;
211pub const SQLITE_SHM_SHARED: i32 = 4;
212pub const SQLITE_SHM_EXCLUSIVE: i32 = 8;
213pub const SQLITE_SHM_NLOCK: i32 = 8;
214pub const SQLITE_CONFIG_SINGLETHREAD: i32 = 1;
215pub const SQLITE_CONFIG_MULTITHREAD: i32 = 2;
216pub const SQLITE_CONFIG_SERIALIZED: i32 = 3;
217pub const SQLITE_CONFIG_MALLOC: i32 = 4;
218pub const SQLITE_CONFIG_GETMALLOC: i32 = 5;
219pub const SQLITE_CONFIG_SCRATCH: i32 = 6;
220pub const SQLITE_CONFIG_PAGECACHE: i32 = 7;
221pub const SQLITE_CONFIG_HEAP: i32 = 8;
222pub const SQLITE_CONFIG_MEMSTATUS: i32 = 9;
223pub const SQLITE_CONFIG_MUTEX: i32 = 10;
224pub const SQLITE_CONFIG_GETMUTEX: i32 = 11;
225pub const SQLITE_CONFIG_LOOKASIDE: i32 = 13;
226pub const SQLITE_CONFIG_PCACHE: i32 = 14;
227pub const SQLITE_CONFIG_GETPCACHE: i32 = 15;
228pub const SQLITE_CONFIG_LOG: i32 = 16;
229pub const SQLITE_CONFIG_URI: i32 = 17;
230pub const SQLITE_CONFIG_PCACHE2: i32 = 18;
231pub const SQLITE_CONFIG_GETPCACHE2: i32 = 19;
232pub const SQLITE_CONFIG_COVERING_INDEX_SCAN: i32 = 20;
233pub const SQLITE_CONFIG_SQLLOG: i32 = 21;
234pub const SQLITE_CONFIG_MMAP_SIZE: i32 = 22;
235pub const SQLITE_CONFIG_WIN32_HEAPSIZE: i32 = 23;
236pub const SQLITE_CONFIG_PCACHE_HDRSZ: i32 = 24;
237pub const SQLITE_CONFIG_PMASZ: i32 = 25;
238pub const SQLITE_CONFIG_STMTJRNL_SPILL: i32 = 26;
239pub const SQLITE_CONFIG_SMALL_MALLOC: i32 = 27;
240pub const SQLITE_CONFIG_SORTERREF_SIZE: i32 = 28;
241pub const SQLITE_CONFIG_MEMDB_MAXSIZE: i32 = 29;
242pub const SQLITE_DBCONFIG_MAINDBNAME: i32 = 1000;
243pub const SQLITE_DBCONFIG_LOOKASIDE: i32 = 1001;
244pub const SQLITE_DBCONFIG_ENABLE_FKEY: i32 = 1002;
245pub const SQLITE_DBCONFIG_ENABLE_TRIGGER: i32 = 1003;
246pub const SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER: i32 = 1004;
247pub const SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION: i32 = 1005;
248pub const SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE: i32 = 1006;
249pub const SQLITE_DBCONFIG_ENABLE_QPSG: i32 = 1007;
250pub const SQLITE_DBCONFIG_TRIGGER_EQP: i32 = 1008;
251pub const SQLITE_DBCONFIG_RESET_DATABASE: i32 = 1009;
252pub const SQLITE_DBCONFIG_DEFENSIVE: i32 = 1010;
253pub const SQLITE_DBCONFIG_WRITABLE_SCHEMA: i32 = 1011;
254pub const SQLITE_DBCONFIG_LEGACY_ALTER_TABLE: i32 = 1012;
255pub const SQLITE_DBCONFIG_DQS_DML: i32 = 1013;
256pub const SQLITE_DBCONFIG_DQS_DDL: i32 = 1014;
257pub const SQLITE_DBCONFIG_ENABLE_VIEW: i32 = 1015;
258pub const SQLITE_DBCONFIG_LEGACY_FILE_FORMAT: i32 = 1016;
259pub const SQLITE_DBCONFIG_TRUSTED_SCHEMA: i32 = 1017;
260pub const SQLITE_DBCONFIG_MAX: i32 = 1017;
261pub const SQLITE_DENY: i32 = 1;
262pub const SQLITE_IGNORE: i32 = 2;
263pub const SQLITE_CREATE_INDEX: i32 = 1;
264pub const SQLITE_CREATE_TABLE: i32 = 2;
265pub const SQLITE_CREATE_TEMP_INDEX: i32 = 3;
266pub const SQLITE_CREATE_TEMP_TABLE: i32 = 4;
267pub const SQLITE_CREATE_TEMP_TRIGGER: i32 = 5;
268pub const SQLITE_CREATE_TEMP_VIEW: i32 = 6;
269pub const SQLITE_CREATE_TRIGGER: i32 = 7;
270pub const SQLITE_CREATE_VIEW: i32 = 8;
271pub const SQLITE_DELETE: i32 = 9;
272pub const SQLITE_DROP_INDEX: i32 = 10;
273pub const SQLITE_DROP_TABLE: i32 = 11;
274pub const SQLITE_DROP_TEMP_INDEX: i32 = 12;
275pub const SQLITE_DROP_TEMP_TABLE: i32 = 13;
276pub const SQLITE_DROP_TEMP_TRIGGER: i32 = 14;
277pub const SQLITE_DROP_TEMP_VIEW: i32 = 15;
278pub const SQLITE_DROP_TRIGGER: i32 = 16;
279pub const SQLITE_DROP_VIEW: i32 = 17;
280pub const SQLITE_INSERT: i32 = 18;
281pub const SQLITE_PRAGMA: i32 = 19;
282pub const SQLITE_READ: i32 = 20;
283pub const SQLITE_SELECT: i32 = 21;
284pub const SQLITE_TRANSACTION: i32 = 22;
285pub const SQLITE_UPDATE: i32 = 23;
286pub const SQLITE_ATTACH: i32 = 24;
287pub const SQLITE_DETACH: i32 = 25;
288pub const SQLITE_ALTER_TABLE: i32 = 26;
289pub const SQLITE_REINDEX: i32 = 27;
290pub const SQLITE_ANALYZE: i32 = 28;
291pub const SQLITE_CREATE_VTABLE: i32 = 29;
292pub const SQLITE_DROP_VTABLE: i32 = 30;
293pub const SQLITE_FUNCTION: i32 = 31;
294pub const SQLITE_SAVEPOINT: i32 = 32;
295pub const SQLITE_COPY: i32 = 0;
296pub const SQLITE_RECURSIVE: i32 = 33;
297pub const SQLITE_TRACE_STMT: i32 = 1;
298pub const SQLITE_TRACE_PROFILE: i32 = 2;
299pub const SQLITE_TRACE_ROW: i32 = 4;
300pub const SQLITE_TRACE_CLOSE: i32 = 8;
301pub const SQLITE_LIMIT_LENGTH: i32 = 0;
302pub const SQLITE_LIMIT_SQL_LENGTH: i32 = 1;
303pub const SQLITE_LIMIT_COLUMN: i32 = 2;
304pub const SQLITE_LIMIT_EXPR_DEPTH: i32 = 3;
305pub const SQLITE_LIMIT_COMPOUND_SELECT: i32 = 4;
306pub const SQLITE_LIMIT_VDBE_OP: i32 = 5;
307pub const SQLITE_LIMIT_FUNCTION_ARG: i32 = 6;
308pub const SQLITE_LIMIT_ATTACHED: i32 = 7;
309pub const SQLITE_LIMIT_LIKE_PATTERN_LENGTH: i32 = 8;
310pub const SQLITE_LIMIT_VARIABLE_NUMBER: i32 = 9;
311pub const SQLITE_LIMIT_TRIGGER_DEPTH: i32 = 10;
312pub const SQLITE_LIMIT_WORKER_THREADS: i32 = 11;
313pub const SQLITE_PREPARE_PERSISTENT: i32 = 1;
314pub const SQLITE_PREPARE_NORMALIZE: i32 = 2;
315pub const SQLITE_PREPARE_NO_VTAB: i32 = 4;
316pub const SQLITE_INTEGER: i32 = 1;
317pub const SQLITE_FLOAT: i32 = 2;
318pub const SQLITE_BLOB: i32 = 4;
319pub const SQLITE_NULL: i32 = 5;
320pub const SQLITE_TEXT: i32 = 3;
321pub const SQLITE3_TEXT: i32 = 3;
322pub const SQLITE_UTF8: i32 = 1;
323pub const SQLITE_UTF16LE: i32 = 2;
324pub const SQLITE_UTF16BE: i32 = 3;
325pub const SQLITE_UTF16: i32 = 4;
326pub const SQLITE_ANY: i32 = 5;
327pub const SQLITE_UTF16_ALIGNED: i32 = 8;
328pub const SQLITE_DETERMINISTIC: i32 = 2048;
329pub const SQLITE_DIRECTONLY: i32 = 524288;
330pub const SQLITE_SUBTYPE: i32 = 1048576;
331pub const SQLITE_INNOCUOUS: i32 = 2097152;
332pub const SQLITE_WIN32_DATA_DIRECTORY_TYPE: i32 = 1;
333pub const SQLITE_WIN32_TEMP_DIRECTORY_TYPE: i32 = 2;
334pub const SQLITE_TXN_NONE: i32 = 0;
335pub const SQLITE_TXN_READ: i32 = 1;
336pub const SQLITE_TXN_WRITE: i32 = 2;
337pub const SQLITE_INDEX_SCAN_UNIQUE: i32 = 1;
338pub const SQLITE_INDEX_CONSTRAINT_EQ: i32 = 2;
339pub const SQLITE_INDEX_CONSTRAINT_GT: i32 = 4;
340pub const SQLITE_INDEX_CONSTRAINT_LE: i32 = 8;
341pub const SQLITE_INDEX_CONSTRAINT_LT: i32 = 16;
342pub const SQLITE_INDEX_CONSTRAINT_GE: i32 = 32;
343pub const SQLITE_INDEX_CONSTRAINT_MATCH: i32 = 64;
344pub const SQLITE_INDEX_CONSTRAINT_LIKE: i32 = 65;
345pub const SQLITE_INDEX_CONSTRAINT_GLOB: i32 = 66;
346pub const SQLITE_INDEX_CONSTRAINT_REGEXP: i32 = 67;
347pub const SQLITE_INDEX_CONSTRAINT_NE: i32 = 68;
348pub const SQLITE_INDEX_CONSTRAINT_ISNOT: i32 = 69;
349pub const SQLITE_INDEX_CONSTRAINT_ISNOTNULL: i32 = 70;
350pub const SQLITE_INDEX_CONSTRAINT_ISNULL: i32 = 71;
351pub const SQLITE_INDEX_CONSTRAINT_IS: i32 = 72;
352pub const SQLITE_INDEX_CONSTRAINT_LIMIT: i32 = 73;
353pub const SQLITE_INDEX_CONSTRAINT_OFFSET: i32 = 74;
354pub const SQLITE_INDEX_CONSTRAINT_FUNCTION: i32 = 150;
355pub const SQLITE_MUTEX_FAST: i32 = 0;
356pub const SQLITE_MUTEX_RECURSIVE: i32 = 1;
357pub const SQLITE_MUTEX_STATIC_MAIN: i32 = 2;
358pub const SQLITE_MUTEX_STATIC_MEM: i32 = 3;
359pub const SQLITE_MUTEX_STATIC_MEM2: i32 = 4;
360pub const SQLITE_MUTEX_STATIC_OPEN: i32 = 4;
361pub const SQLITE_MUTEX_STATIC_PRNG: i32 = 5;
362pub const SQLITE_MUTEX_STATIC_LRU: i32 = 6;
363pub const SQLITE_MUTEX_STATIC_LRU2: i32 = 7;
364pub const SQLITE_MUTEX_STATIC_PMEM: i32 = 7;
365pub const SQLITE_MUTEX_STATIC_APP1: i32 = 8;
366pub const SQLITE_MUTEX_STATIC_APP2: i32 = 9;
367pub const SQLITE_MUTEX_STATIC_APP3: i32 = 10;
368pub const SQLITE_MUTEX_STATIC_VFS1: i32 = 11;
369pub const SQLITE_MUTEX_STATIC_VFS2: i32 = 12;
370pub const SQLITE_MUTEX_STATIC_VFS3: i32 = 13;
371pub const SQLITE_MUTEX_STATIC_MASTER: i32 = 2;
372pub const SQLITE_TESTCTRL_FIRST: i32 = 5;
373pub const SQLITE_TESTCTRL_PRNG_SAVE: i32 = 5;
374pub const SQLITE_TESTCTRL_PRNG_RESTORE: i32 = 6;
375pub const SQLITE_TESTCTRL_PRNG_RESET: i32 = 7;
376pub const SQLITE_TESTCTRL_BITVEC_TEST: i32 = 8;
377pub const SQLITE_TESTCTRL_FAULT_INSTALL: i32 = 9;
378pub const SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: i32 = 10;
379pub const SQLITE_TESTCTRL_PENDING_BYTE: i32 = 11;
380pub const SQLITE_TESTCTRL_ASSERT: i32 = 12;
381pub const SQLITE_TESTCTRL_ALWAYS: i32 = 13;
382pub const SQLITE_TESTCTRL_RESERVE: i32 = 14;
383pub const SQLITE_TESTCTRL_OPTIMIZATIONS: i32 = 15;
384pub const SQLITE_TESTCTRL_ISKEYWORD: i32 = 16;
385pub const SQLITE_TESTCTRL_SCRATCHMALLOC: i32 = 17;
386pub const SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: i32 = 17;
387pub const SQLITE_TESTCTRL_LOCALTIME_FAULT: i32 = 18;
388pub const SQLITE_TESTCTRL_EXPLAIN_STMT: i32 = 19;
389pub const SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: i32 = 19;
390pub const SQLITE_TESTCTRL_NEVER_CORRUPT: i32 = 20;
391pub const SQLITE_TESTCTRL_VDBE_COVERAGE: i32 = 21;
392pub const SQLITE_TESTCTRL_BYTEORDER: i32 = 22;
393pub const SQLITE_TESTCTRL_ISINIT: i32 = 23;
394pub const SQLITE_TESTCTRL_SORTER_MMAP: i32 = 24;
395pub const SQLITE_TESTCTRL_IMPOSTER: i32 = 25;
396pub const SQLITE_TESTCTRL_PARSER_COVERAGE: i32 = 26;
397pub const SQLITE_TESTCTRL_RESULT_INTREAL: i32 = 27;
398pub const SQLITE_TESTCTRL_PRNG_SEED: i32 = 28;
399pub const SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS: i32 = 29;
400pub const SQLITE_TESTCTRL_SEEK_COUNT: i32 = 30;
401pub const SQLITE_TESTCTRL_TRACEFLAGS: i32 = 31;
402pub const SQLITE_TESTCTRL_TUNE: i32 = 32;
403pub const SQLITE_TESTCTRL_LOGEST: i32 = 33;
404pub const SQLITE_TESTCTRL_LAST: i32 = 33;
405pub const SQLITE_STATUS_MEMORY_USED: i32 = 0;
406pub const SQLITE_STATUS_PAGECACHE_USED: i32 = 1;
407pub const SQLITE_STATUS_PAGECACHE_OVERFLOW: i32 = 2;
408pub const SQLITE_STATUS_SCRATCH_USED: i32 = 3;
409pub const SQLITE_STATUS_SCRATCH_OVERFLOW: i32 = 4;
410pub const SQLITE_STATUS_MALLOC_SIZE: i32 = 5;
411pub const SQLITE_STATUS_PARSER_STACK: i32 = 6;
412pub const SQLITE_STATUS_PAGECACHE_SIZE: i32 = 7;
413pub const SQLITE_STATUS_SCRATCH_SIZE: i32 = 8;
414pub const SQLITE_STATUS_MALLOC_COUNT: i32 = 9;
415pub const SQLITE_DBSTATUS_LOOKASIDE_USED: i32 = 0;
416pub const SQLITE_DBSTATUS_CACHE_USED: i32 = 1;
417pub const SQLITE_DBSTATUS_SCHEMA_USED: i32 = 2;
418pub const SQLITE_DBSTATUS_STMT_USED: i32 = 3;
419pub const SQLITE_DBSTATUS_LOOKASIDE_HIT: i32 = 4;
420pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE: i32 = 5;
421pub const SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: i32 = 6;
422pub const SQLITE_DBSTATUS_CACHE_HIT: i32 = 7;
423pub const SQLITE_DBSTATUS_CACHE_MISS: i32 = 8;
424pub const SQLITE_DBSTATUS_CACHE_WRITE: i32 = 9;
425pub const SQLITE_DBSTATUS_DEFERRED_FKS: i32 = 10;
426pub const SQLITE_DBSTATUS_CACHE_USED_SHARED: i32 = 11;
427pub const SQLITE_DBSTATUS_CACHE_SPILL: i32 = 12;
428pub const SQLITE_DBSTATUS_MAX: i32 = 12;
429pub const SQLITE_STMTSTATUS_FULLSCAN_STEP: i32 = 1;
430pub const SQLITE_STMTSTATUS_SORT: i32 = 2;
431pub const SQLITE_STMTSTATUS_AUTOINDEX: i32 = 3;
432pub const SQLITE_STMTSTATUS_VM_STEP: i32 = 4;
433pub const SQLITE_STMTSTATUS_REPREPARE: i32 = 5;
434pub const SQLITE_STMTSTATUS_RUN: i32 = 6;
435pub const SQLITE_STMTSTATUS_FILTER_MISS: i32 = 7;
436pub const SQLITE_STMTSTATUS_FILTER_HIT: i32 = 8;
437pub const SQLITE_STMTSTATUS_MEMUSED: i32 = 99;
438pub const SQLITE_CHECKPOINT_PASSIVE: i32 = 0;
439pub const SQLITE_CHECKPOINT_FULL: i32 = 1;
440pub const SQLITE_CHECKPOINT_RESTART: i32 = 2;
441pub const SQLITE_CHECKPOINT_TRUNCATE: i32 = 3;
442pub const SQLITE_VTAB_CONSTRAINT_SUPPORT: i32 = 1;
443pub const SQLITE_VTAB_INNOCUOUS: i32 = 2;
444pub const SQLITE_VTAB_DIRECTONLY: i32 = 3;
445pub const SQLITE_ROLLBACK: i32 = 1;
446pub const SQLITE_FAIL: i32 = 3;
447pub const SQLITE_REPLACE: i32 = 5;
448pub const SQLITE_SCANSTAT_NLOOP: i32 = 0;
449pub const SQLITE_SCANSTAT_NVISIT: i32 = 1;
450pub const SQLITE_SCANSTAT_EST: i32 = 2;
451pub const SQLITE_SCANSTAT_NAME: i32 = 3;
452pub const SQLITE_SCANSTAT_EXPLAIN: i32 = 4;
453pub const SQLITE_SCANSTAT_SELECTID: i32 = 5;
454pub const SQLITE_SERIALIZE_NOCOPY: i32 = 1;
455pub const SQLITE_DESERIALIZE_FREEONCLOSE: i32 = 1;
456pub const SQLITE_DESERIALIZE_RESIZEABLE: i32 = 2;
457pub const SQLITE_DESERIALIZE_READONLY: i32 = 4;
458pub const NOT_WITHIN: i32 = 0;
459pub const PARTLY_WITHIN: i32 = 1;
460pub const FULLY_WITHIN: i32 = 2;
461pub const FTS5_TOKENIZE_QUERY: i32 = 1;
462pub const FTS5_TOKENIZE_PREFIX: i32 = 2;
463pub const FTS5_TOKENIZE_DOCUMENT: i32 = 4;
464pub const FTS5_TOKENIZE_AUX: i32 = 8;
465pub const FTS5_TOKEN_COLOCATED: i32 = 1;
466pub type va_list = __builtin_va_list;
467extern "C" {
468 pub static sqlite3_version: [::std::os::raw::c_char; 0usize];
469}
470#[repr(C)]
471#[derive(Debug, Copy, Clone)]
472pub struct sqlite3 {
473 _unused: [u8; 0],
474}
475pub type sqlite_int64 = ::std::os::raw::c_longlong;
476pub type sqlite_uint64 = ::std::os::raw::c_ulonglong;
477pub type sqlite3_int64 = sqlite_int64;
478pub type sqlite3_uint64 = sqlite_uint64;
479pub type sqlite3_callback = ::std::option::Option<
480 unsafe extern "C" fn(
481 arg1: *mut ::std::os::raw::c_void,
482 arg2: ::std::os::raw::c_int,
483 arg3: *mut *mut ::std::os::raw::c_char,
484 arg4: *mut *mut ::std::os::raw::c_char,
485 ) -> ::std::os::raw::c_int,
486>;
487#[repr(C)]
488#[derive(Debug, Copy, Clone)]
489pub struct sqlite3_file {
490 pub pMethods: *const sqlite3_io_methods,
491}
492#[test]
493fn bindgen_test_layout_sqlite3_file() {
494 const UNINIT: ::std::mem::MaybeUninit<sqlite3_file> = ::std::mem::MaybeUninit::uninit();
495 let ptr = UNINIT.as_ptr();
496 assert_eq!(
497 ::std::mem::size_of::<sqlite3_file>(),
498 8usize,
499 concat!("Size of: ", stringify!(sqlite3_file))
500 );
501 assert_eq!(
502 ::std::mem::align_of::<sqlite3_file>(),
503 8usize,
504 concat!("Alignment of ", stringify!(sqlite3_file))
505 );
506 assert_eq!(
507 unsafe { ::std::ptr::addr_of!((*ptr).pMethods) as usize - ptr as usize },
508 0usize,
509 concat!(
510 "Offset of field: ",
511 stringify!(sqlite3_file),
512 "::",
513 stringify!(pMethods)
514 )
515 );
516}
517#[repr(C)]
518#[derive(Debug, Copy, Clone)]
519pub struct sqlite3_io_methods {
520 pub iVersion: ::std::os::raw::c_int,
521 pub xClose: ::std::option::Option<
522 unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int,
523 >,
524 pub xRead: ::std::option::Option<
525 unsafe extern "C" fn(
526 arg1: *mut sqlite3_file,
527 arg2: *mut ::std::os::raw::c_void,
528 iAmt: ::std::os::raw::c_int,
529 iOfst: sqlite3_int64,
530 ) -> ::std::os::raw::c_int,
531 >,
532 pub xWrite: ::std::option::Option<
533 unsafe extern "C" fn(
534 arg1: *mut sqlite3_file,
535 arg2: *const ::std::os::raw::c_void,
536 iAmt: ::std::os::raw::c_int,
537 iOfst: sqlite3_int64,
538 ) -> ::std::os::raw::c_int,
539 >,
540 pub xTruncate: ::std::option::Option<
541 unsafe extern "C" fn(arg1: *mut sqlite3_file, size: sqlite3_int64) -> ::std::os::raw::c_int,
542 >,
543 pub xSync: ::std::option::Option<
544 unsafe extern "C" fn(
545 arg1: *mut sqlite3_file,
546 flags: ::std::os::raw::c_int,
547 ) -> ::std::os::raw::c_int,
548 >,
549 pub xFileSize: ::std::option::Option<
550 unsafe extern "C" fn(
551 arg1: *mut sqlite3_file,
552 pSize: *mut sqlite3_int64,
553 ) -> ::std::os::raw::c_int,
554 >,
555 pub xLock: ::std::option::Option<
556 unsafe extern "C" fn(
557 arg1: *mut sqlite3_file,
558 arg2: ::std::os::raw::c_int,
559 ) -> ::std::os::raw::c_int,
560 >,
561 pub xUnlock: ::std::option::Option<
562 unsafe extern "C" fn(
563 arg1: *mut sqlite3_file,
564 arg2: ::std::os::raw::c_int,
565 ) -> ::std::os::raw::c_int,
566 >,
567 pub xCheckReservedLock: ::std::option::Option<
568 unsafe extern "C" fn(
569 arg1: *mut sqlite3_file,
570 pResOut: *mut ::std::os::raw::c_int,
571 ) -> ::std::os::raw::c_int,
572 >,
573 pub xFileControl: ::std::option::Option<
574 unsafe extern "C" fn(
575 arg1: *mut sqlite3_file,
576 op: ::std::os::raw::c_int,
577 pArg: *mut ::std::os::raw::c_void,
578 ) -> ::std::os::raw::c_int,
579 >,
580 pub xSectorSize: ::std::option::Option<
581 unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int,
582 >,
583 pub xDeviceCharacteristics: ::std::option::Option<
584 unsafe extern "C" fn(arg1: *mut sqlite3_file) -> ::std::os::raw::c_int,
585 >,
586 pub xShmMap: ::std::option::Option<
587 unsafe extern "C" fn(
588 arg1: *mut sqlite3_file,
589 iPg: ::std::os::raw::c_int,
590 pgsz: ::std::os::raw::c_int,
591 arg2: ::std::os::raw::c_int,
592 arg3: *mut *mut ::std::os::raw::c_void,
593 ) -> ::std::os::raw::c_int,
594 >,
595 pub xShmLock: ::std::option::Option<
596 unsafe extern "C" fn(
597 arg1: *mut sqlite3_file,
598 offset: ::std::os::raw::c_int,
599 n: ::std::os::raw::c_int,
600 flags: ::std::os::raw::c_int,
601 ) -> ::std::os::raw::c_int,
602 >,
603 pub xShmBarrier: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_file)>,
604 pub xShmUnmap: ::std::option::Option<
605 unsafe extern "C" fn(
606 arg1: *mut sqlite3_file,
607 deleteFlag: ::std::os::raw::c_int,
608 ) -> ::std::os::raw::c_int,
609 >,
610 pub xFetch: ::std::option::Option<
611 unsafe extern "C" fn(
612 arg1: *mut sqlite3_file,
613 iOfst: sqlite3_int64,
614 iAmt: ::std::os::raw::c_int,
615 pp: *mut *mut ::std::os::raw::c_void,
616 ) -> ::std::os::raw::c_int,
617 >,
618 pub xUnfetch: ::std::option::Option<
619 unsafe extern "C" fn(
620 arg1: *mut sqlite3_file,
621 iOfst: sqlite3_int64,
622 p: *mut ::std::os::raw::c_void,
623 ) -> ::std::os::raw::c_int,
624 >,
625}
626#[test]
627fn bindgen_test_layout_sqlite3_io_methods() {
628 const UNINIT: ::std::mem::MaybeUninit<sqlite3_io_methods> = ::std::mem::MaybeUninit::uninit();
629 let ptr = UNINIT.as_ptr();
630 assert_eq!(
631 ::std::mem::size_of::<sqlite3_io_methods>(),
632 152usize,
633 concat!("Size of: ", stringify!(sqlite3_io_methods))
634 );
635 assert_eq!(
636 ::std::mem::align_of::<sqlite3_io_methods>(),
637 8usize,
638 concat!("Alignment of ", stringify!(sqlite3_io_methods))
639 );
640 assert_eq!(
641 unsafe { ::std::ptr::addr_of!((*ptr).iVersion) as usize - ptr as usize },
642 0usize,
643 concat!(
644 "Offset of field: ",
645 stringify!(sqlite3_io_methods),
646 "::",
647 stringify!(iVersion)
648 )
649 );
650 assert_eq!(
651 unsafe { ::std::ptr::addr_of!((*ptr).xClose) as usize - ptr as usize },
652 8usize,
653 concat!(
654 "Offset of field: ",
655 stringify!(sqlite3_io_methods),
656 "::",
657 stringify!(xClose)
658 )
659 );
660 assert_eq!(
661 unsafe { ::std::ptr::addr_of!((*ptr).xRead) as usize - ptr as usize },
662 16usize,
663 concat!(
664 "Offset of field: ",
665 stringify!(sqlite3_io_methods),
666 "::",
667 stringify!(xRead)
668 )
669 );
670 assert_eq!(
671 unsafe { ::std::ptr::addr_of!((*ptr).xWrite) as usize - ptr as usize },
672 24usize,
673 concat!(
674 "Offset of field: ",
675 stringify!(sqlite3_io_methods),
676 "::",
677 stringify!(xWrite)
678 )
679 );
680 assert_eq!(
681 unsafe { ::std::ptr::addr_of!((*ptr).xTruncate) as usize - ptr as usize },
682 32usize,
683 concat!(
684 "Offset of field: ",
685 stringify!(sqlite3_io_methods),
686 "::",
687 stringify!(xTruncate)
688 )
689 );
690 assert_eq!(
691 unsafe { ::std::ptr::addr_of!((*ptr).xSync) as usize - ptr as usize },
692 40usize,
693 concat!(
694 "Offset of field: ",
695 stringify!(sqlite3_io_methods),
696 "::",
697 stringify!(xSync)
698 )
699 );
700 assert_eq!(
701 unsafe { ::std::ptr::addr_of!((*ptr).xFileSize) as usize - ptr as usize },
702 48usize,
703 concat!(
704 "Offset of field: ",
705 stringify!(sqlite3_io_methods),
706 "::",
707 stringify!(xFileSize)
708 )
709 );
710 assert_eq!(
711 unsafe { ::std::ptr::addr_of!((*ptr).xLock) as usize - ptr as usize },
712 56usize,
713 concat!(
714 "Offset of field: ",
715 stringify!(sqlite3_io_methods),
716 "::",
717 stringify!(xLock)
718 )
719 );
720 assert_eq!(
721 unsafe { ::std::ptr::addr_of!((*ptr).xUnlock) as usize - ptr as usize },
722 64usize,
723 concat!(
724 "Offset of field: ",
725 stringify!(sqlite3_io_methods),
726 "::",
727 stringify!(xUnlock)
728 )
729 );
730 assert_eq!(
731 unsafe { ::std::ptr::addr_of!((*ptr).xCheckReservedLock) as usize - ptr as usize },
732 72usize,
733 concat!(
734 "Offset of field: ",
735 stringify!(sqlite3_io_methods),
736 "::",
737 stringify!(xCheckReservedLock)
738 )
739 );
740 assert_eq!(
741 unsafe { ::std::ptr::addr_of!((*ptr).xFileControl) as usize - ptr as usize },
742 80usize,
743 concat!(
744 "Offset of field: ",
745 stringify!(sqlite3_io_methods),
746 "::",
747 stringify!(xFileControl)
748 )
749 );
750 assert_eq!(
751 unsafe { ::std::ptr::addr_of!((*ptr).xSectorSize) as usize - ptr as usize },
752 88usize,
753 concat!(
754 "Offset of field: ",
755 stringify!(sqlite3_io_methods),
756 "::",
757 stringify!(xSectorSize)
758 )
759 );
760 assert_eq!(
761 unsafe { ::std::ptr::addr_of!((*ptr).xDeviceCharacteristics) as usize - ptr as usize },
762 96usize,
763 concat!(
764 "Offset of field: ",
765 stringify!(sqlite3_io_methods),
766 "::",
767 stringify!(xDeviceCharacteristics)
768 )
769 );
770 assert_eq!(
771 unsafe { ::std::ptr::addr_of!((*ptr).xShmMap) as usize - ptr as usize },
772 104usize,
773 concat!(
774 "Offset of field: ",
775 stringify!(sqlite3_io_methods),
776 "::",
777 stringify!(xShmMap)
778 )
779 );
780 assert_eq!(
781 unsafe { ::std::ptr::addr_of!((*ptr).xShmLock) as usize - ptr as usize },
782 112usize,
783 concat!(
784 "Offset of field: ",
785 stringify!(sqlite3_io_methods),
786 "::",
787 stringify!(xShmLock)
788 )
789 );
790 assert_eq!(
791 unsafe { ::std::ptr::addr_of!((*ptr).xShmBarrier) as usize - ptr as usize },
792 120usize,
793 concat!(
794 "Offset of field: ",
795 stringify!(sqlite3_io_methods),
796 "::",
797 stringify!(xShmBarrier)
798 )
799 );
800 assert_eq!(
801 unsafe { ::std::ptr::addr_of!((*ptr).xShmUnmap) as usize - ptr as usize },
802 128usize,
803 concat!(
804 "Offset of field: ",
805 stringify!(sqlite3_io_methods),
806 "::",
807 stringify!(xShmUnmap)
808 )
809 );
810 assert_eq!(
811 unsafe { ::std::ptr::addr_of!((*ptr).xFetch) as usize - ptr as usize },
812 136usize,
813 concat!(
814 "Offset of field: ",
815 stringify!(sqlite3_io_methods),
816 "::",
817 stringify!(xFetch)
818 )
819 );
820 assert_eq!(
821 unsafe { ::std::ptr::addr_of!((*ptr).xUnfetch) as usize - ptr as usize },
822 144usize,
823 concat!(
824 "Offset of field: ",
825 stringify!(sqlite3_io_methods),
826 "::",
827 stringify!(xUnfetch)
828 )
829 );
830}
831#[repr(C)]
832#[derive(Debug, Copy, Clone)]
833pub struct sqlite3_mutex {
834 _unused: [u8; 0],
835}
836pub type sqlite3_syscall_ptr = ::std::option::Option<unsafe extern "C" fn()>;
837#[repr(C)]
838#[derive(Debug, Copy, Clone)]
839pub struct sqlite3_vfs {
840 pub iVersion: ::std::os::raw::c_int,
841 pub szOsFile: ::std::os::raw::c_int,
842 pub mxPathname: ::std::os::raw::c_int,
843 pub pNext: *mut sqlite3_vfs,
844 pub zName: *const ::std::os::raw::c_char,
845 pub pAppData: *mut ::std::os::raw::c_void,
846 pub xOpen: ::std::option::Option<
847 unsafe extern "C" fn(
848 arg1: *mut sqlite3_vfs,
849 zName: *const ::std::os::raw::c_char,
850 arg2: *mut sqlite3_file,
851 flags: ::std::os::raw::c_int,
852 pOutFlags: *mut ::std::os::raw::c_int,
853 ) -> ::std::os::raw::c_int,
854 >,
855 pub xDelete: ::std::option::Option<
856 unsafe extern "C" fn(
857 arg1: *mut sqlite3_vfs,
858 zName: *const ::std::os::raw::c_char,
859 syncDir: ::std::os::raw::c_int,
860 ) -> ::std::os::raw::c_int,
861 >,
862 pub xAccess: ::std::option::Option<
863 unsafe extern "C" fn(
864 arg1: *mut sqlite3_vfs,
865 zName: *const ::std::os::raw::c_char,
866 flags: ::std::os::raw::c_int,
867 pResOut: *mut ::std::os::raw::c_int,
868 ) -> ::std::os::raw::c_int,
869 >,
870 pub xFullPathname: ::std::option::Option<
871 unsafe extern "C" fn(
872 arg1: *mut sqlite3_vfs,
873 zName: *const ::std::os::raw::c_char,
874 nOut: ::std::os::raw::c_int,
875 zOut: *mut ::std::os::raw::c_char,
876 ) -> ::std::os::raw::c_int,
877 >,
878 pub xDlOpen: ::std::option::Option<
879 unsafe extern "C" fn(
880 arg1: *mut sqlite3_vfs,
881 zFilename: *const ::std::os::raw::c_char,
882 ) -> *mut ::std::os::raw::c_void,
883 >,
884 pub xDlError: ::std::option::Option<
885 unsafe extern "C" fn(
886 arg1: *mut sqlite3_vfs,
887 nByte: ::std::os::raw::c_int,
888 zErrMsg: *mut ::std::os::raw::c_char,
889 ),
890 >,
891 pub xDlSym: ::std::option::Option<
892 unsafe extern "C" fn(
893 arg1: *mut sqlite3_vfs,
894 arg2: *mut ::std::os::raw::c_void,
895 zSymbol: *const ::std::os::raw::c_char,
896 ) -> ::std::option::Option<
897 unsafe extern "C" fn(
898 arg1: *mut sqlite3_vfs,
899 arg2: *mut ::std::os::raw::c_void,
900 zSymbol: *const ::std::os::raw::c_char,
901 ),
902 >,
903 >,
904 pub xDlClose: ::std::option::Option<
905 unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut ::std::os::raw::c_void),
906 >,
907 pub xRandomness: ::std::option::Option<
908 unsafe extern "C" fn(
909 arg1: *mut sqlite3_vfs,
910 nByte: ::std::os::raw::c_int,
911 zOut: *mut ::std::os::raw::c_char,
912 ) -> ::std::os::raw::c_int,
913 >,
914 pub xSleep: ::std::option::Option<
915 unsafe extern "C" fn(
916 arg1: *mut sqlite3_vfs,
917 microseconds: ::std::os::raw::c_int,
918 ) -> ::std::os::raw::c_int,
919 >,
920 pub xCurrentTime: ::std::option::Option<
921 unsafe extern "C" fn(arg1: *mut sqlite3_vfs, arg2: *mut f64) -> ::std::os::raw::c_int,
922 >,
923 pub xGetLastError: ::std::option::Option<
924 unsafe extern "C" fn(
925 arg1: *mut sqlite3_vfs,
926 arg2: ::std::os::raw::c_int,
927 arg3: *mut ::std::os::raw::c_char,
928 ) -> ::std::os::raw::c_int,
929 >,
930 pub xCurrentTimeInt64: ::std::option::Option<
931 unsafe extern "C" fn(
932 arg1: *mut sqlite3_vfs,
933 arg2: *mut sqlite3_int64,
934 ) -> ::std::os::raw::c_int,
935 >,
936 pub xSetSystemCall: ::std::option::Option<
937 unsafe extern "C" fn(
938 arg1: *mut sqlite3_vfs,
939 zName: *const ::std::os::raw::c_char,
940 arg2: sqlite3_syscall_ptr,
941 ) -> ::std::os::raw::c_int,
942 >,
943 pub xGetSystemCall: ::std::option::Option<
944 unsafe extern "C" fn(
945 arg1: *mut sqlite3_vfs,
946 zName: *const ::std::os::raw::c_char,
947 ) -> sqlite3_syscall_ptr,
948 >,
949 pub xNextSystemCall: ::std::option::Option<
950 unsafe extern "C" fn(
951 arg1: *mut sqlite3_vfs,
952 zName: *const ::std::os::raw::c_char,
953 ) -> *const ::std::os::raw::c_char,
954 >,
955}
956#[test]
957fn bindgen_test_layout_sqlite3_vfs() {
958 const UNINIT: ::std::mem::MaybeUninit<sqlite3_vfs> = ::std::mem::MaybeUninit::uninit();
959 let ptr = UNINIT.as_ptr();
960 assert_eq!(
961 ::std::mem::size_of::<sqlite3_vfs>(),
962 168usize,
963 concat!("Size of: ", stringify!(sqlite3_vfs))
964 );
965 assert_eq!(
966 ::std::mem::align_of::<sqlite3_vfs>(),
967 8usize,
968 concat!("Alignment of ", stringify!(sqlite3_vfs))
969 );
970 assert_eq!(
971 unsafe { ::std::ptr::addr_of!((*ptr).iVersion) as usize - ptr as usize },
972 0usize,
973 concat!(
974 "Offset of field: ",
975 stringify!(sqlite3_vfs),
976 "::",
977 stringify!(iVersion)
978 )
979 );
980 assert_eq!(
981 unsafe { ::std::ptr::addr_of!((*ptr).szOsFile) as usize - ptr as usize },
982 4usize,
983 concat!(
984 "Offset of field: ",
985 stringify!(sqlite3_vfs),
986 "::",
987 stringify!(szOsFile)
988 )
989 );
990 assert_eq!(
991 unsafe { ::std::ptr::addr_of!((*ptr).mxPathname) as usize - ptr as usize },
992 8usize,
993 concat!(
994 "Offset of field: ",
995 stringify!(sqlite3_vfs),
996 "::",
997 stringify!(mxPathname)
998 )
999 );
1000 assert_eq!(
1001 unsafe { ::std::ptr::addr_of!((*ptr).pNext) as usize - ptr as usize },
1002 16usize,
1003 concat!(
1004 "Offset of field: ",
1005 stringify!(sqlite3_vfs),
1006 "::",
1007 stringify!(pNext)
1008 )
1009 );
1010 assert_eq!(
1011 unsafe { ::std::ptr::addr_of!((*ptr).zName) as usize - ptr as usize },
1012 24usize,
1013 concat!(
1014 "Offset of field: ",
1015 stringify!(sqlite3_vfs),
1016 "::",
1017 stringify!(zName)
1018 )
1019 );
1020 assert_eq!(
1021 unsafe { ::std::ptr::addr_of!((*ptr).pAppData) as usize - ptr as usize },
1022 32usize,
1023 concat!(
1024 "Offset of field: ",
1025 stringify!(sqlite3_vfs),
1026 "::",
1027 stringify!(pAppData)
1028 )
1029 );
1030 assert_eq!(
1031 unsafe { ::std::ptr::addr_of!((*ptr).xOpen) as usize - ptr as usize },
1032 40usize,
1033 concat!(
1034 "Offset of field: ",
1035 stringify!(sqlite3_vfs),
1036 "::",
1037 stringify!(xOpen)
1038 )
1039 );
1040 assert_eq!(
1041 unsafe { ::std::ptr::addr_of!((*ptr).xDelete) as usize - ptr as usize },
1042 48usize,
1043 concat!(
1044 "Offset of field: ",
1045 stringify!(sqlite3_vfs),
1046 "::",
1047 stringify!(xDelete)
1048 )
1049 );
1050 assert_eq!(
1051 unsafe { ::std::ptr::addr_of!((*ptr).xAccess) as usize - ptr as usize },
1052 56usize,
1053 concat!(
1054 "Offset of field: ",
1055 stringify!(sqlite3_vfs),
1056 "::",
1057 stringify!(xAccess)
1058 )
1059 );
1060 assert_eq!(
1061 unsafe { ::std::ptr::addr_of!((*ptr).xFullPathname) as usize - ptr as usize },
1062 64usize,
1063 concat!(
1064 "Offset of field: ",
1065 stringify!(sqlite3_vfs),
1066 "::",
1067 stringify!(xFullPathname)
1068 )
1069 );
1070 assert_eq!(
1071 unsafe { ::std::ptr::addr_of!((*ptr).xDlOpen) as usize - ptr as usize },
1072 72usize,
1073 concat!(
1074 "Offset of field: ",
1075 stringify!(sqlite3_vfs),
1076 "::",
1077 stringify!(xDlOpen)
1078 )
1079 );
1080 assert_eq!(
1081 unsafe { ::std::ptr::addr_of!((*ptr).xDlError) as usize - ptr as usize },
1082 80usize,
1083 concat!(
1084 "Offset of field: ",
1085 stringify!(sqlite3_vfs),
1086 "::",
1087 stringify!(xDlError)
1088 )
1089 );
1090 assert_eq!(
1091 unsafe { ::std::ptr::addr_of!((*ptr).xDlSym) as usize - ptr as usize },
1092 88usize,
1093 concat!(
1094 "Offset of field: ",
1095 stringify!(sqlite3_vfs),
1096 "::",
1097 stringify!(xDlSym)
1098 )
1099 );
1100 assert_eq!(
1101 unsafe { ::std::ptr::addr_of!((*ptr).xDlClose) as usize - ptr as usize },
1102 96usize,
1103 concat!(
1104 "Offset of field: ",
1105 stringify!(sqlite3_vfs),
1106 "::",
1107 stringify!(xDlClose)
1108 )
1109 );
1110 assert_eq!(
1111 unsafe { ::std::ptr::addr_of!((*ptr).xRandomness) as usize - ptr as usize },
1112 104usize,
1113 concat!(
1114 "Offset of field: ",
1115 stringify!(sqlite3_vfs),
1116 "::",
1117 stringify!(xRandomness)
1118 )
1119 );
1120 assert_eq!(
1121 unsafe { ::std::ptr::addr_of!((*ptr).xSleep) as usize - ptr as usize },
1122 112usize,
1123 concat!(
1124 "Offset of field: ",
1125 stringify!(sqlite3_vfs),
1126 "::",
1127 stringify!(xSleep)
1128 )
1129 );
1130 assert_eq!(
1131 unsafe { ::std::ptr::addr_of!((*ptr).xCurrentTime) as usize - ptr as usize },
1132 120usize,
1133 concat!(
1134 "Offset of field: ",
1135 stringify!(sqlite3_vfs),
1136 "::",
1137 stringify!(xCurrentTime)
1138 )
1139 );
1140 assert_eq!(
1141 unsafe { ::std::ptr::addr_of!((*ptr).xGetLastError) as usize - ptr as usize },
1142 128usize,
1143 concat!(
1144 "Offset of field: ",
1145 stringify!(sqlite3_vfs),
1146 "::",
1147 stringify!(xGetLastError)
1148 )
1149 );
1150 assert_eq!(
1151 unsafe { ::std::ptr::addr_of!((*ptr).xCurrentTimeInt64) as usize - ptr as usize },
1152 136usize,
1153 concat!(
1154 "Offset of field: ",
1155 stringify!(sqlite3_vfs),
1156 "::",
1157 stringify!(xCurrentTimeInt64)
1158 )
1159 );
1160 assert_eq!(
1161 unsafe { ::std::ptr::addr_of!((*ptr).xSetSystemCall) as usize - ptr as usize },
1162 144usize,
1163 concat!(
1164 "Offset of field: ",
1165 stringify!(sqlite3_vfs),
1166 "::",
1167 stringify!(xSetSystemCall)
1168 )
1169 );
1170 assert_eq!(
1171 unsafe { ::std::ptr::addr_of!((*ptr).xGetSystemCall) as usize - ptr as usize },
1172 152usize,
1173 concat!(
1174 "Offset of field: ",
1175 stringify!(sqlite3_vfs),
1176 "::",
1177 stringify!(xGetSystemCall)
1178 )
1179 );
1180 assert_eq!(
1181 unsafe { ::std::ptr::addr_of!((*ptr).xNextSystemCall) as usize - ptr as usize },
1182 160usize,
1183 concat!(
1184 "Offset of field: ",
1185 stringify!(sqlite3_vfs),
1186 "::",
1187 stringify!(xNextSystemCall)
1188 )
1189 );
1190}
1191#[repr(C)]
1192#[derive(Debug, Copy, Clone)]
1193pub struct sqlite3_mem_methods {
1194 pub xMalloc: ::std::option::Option<
1195 unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void,
1196 >,
1197 pub xFree: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
1198 pub xRealloc: ::std::option::Option<
1199 unsafe extern "C" fn(
1200 arg1: *mut ::std::os::raw::c_void,
1201 arg2: ::std::os::raw::c_int,
1202 ) -> *mut ::std::os::raw::c_void,
1203 >,
1204 pub xSize: ::std::option::Option<
1205 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
1206 >,
1207 pub xRoundup: ::std::option::Option<
1208 unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
1209 >,
1210 pub xInit: ::std::option::Option<
1211 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
1212 >,
1213 pub xShutdown: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
1214 pub pAppData: *mut ::std::os::raw::c_void,
1215}
1216#[test]
1217fn bindgen_test_layout_sqlite3_mem_methods() {
1218 const UNINIT: ::std::mem::MaybeUninit<sqlite3_mem_methods> = ::std::mem::MaybeUninit::uninit();
1219 let ptr = UNINIT.as_ptr();
1220 assert_eq!(
1221 ::std::mem::size_of::<sqlite3_mem_methods>(),
1222 64usize,
1223 concat!("Size of: ", stringify!(sqlite3_mem_methods))
1224 );
1225 assert_eq!(
1226 ::std::mem::align_of::<sqlite3_mem_methods>(),
1227 8usize,
1228 concat!("Alignment of ", stringify!(sqlite3_mem_methods))
1229 );
1230 assert_eq!(
1231 unsafe { ::std::ptr::addr_of!((*ptr).xMalloc) as usize - ptr as usize },
1232 0usize,
1233 concat!(
1234 "Offset of field: ",
1235 stringify!(sqlite3_mem_methods),
1236 "::",
1237 stringify!(xMalloc)
1238 )
1239 );
1240 assert_eq!(
1241 unsafe { ::std::ptr::addr_of!((*ptr).xFree) as usize - ptr as usize },
1242 8usize,
1243 concat!(
1244 "Offset of field: ",
1245 stringify!(sqlite3_mem_methods),
1246 "::",
1247 stringify!(xFree)
1248 )
1249 );
1250 assert_eq!(
1251 unsafe { ::std::ptr::addr_of!((*ptr).xRealloc) as usize - ptr as usize },
1252 16usize,
1253 concat!(
1254 "Offset of field: ",
1255 stringify!(sqlite3_mem_methods),
1256 "::",
1257 stringify!(xRealloc)
1258 )
1259 );
1260 assert_eq!(
1261 unsafe { ::std::ptr::addr_of!((*ptr).xSize) as usize - ptr as usize },
1262 24usize,
1263 concat!(
1264 "Offset of field: ",
1265 stringify!(sqlite3_mem_methods),
1266 "::",
1267 stringify!(xSize)
1268 )
1269 );
1270 assert_eq!(
1271 unsafe { ::std::ptr::addr_of!((*ptr).xRoundup) as usize - ptr as usize },
1272 32usize,
1273 concat!(
1274 "Offset of field: ",
1275 stringify!(sqlite3_mem_methods),
1276 "::",
1277 stringify!(xRoundup)
1278 )
1279 );
1280 assert_eq!(
1281 unsafe { ::std::ptr::addr_of!((*ptr).xInit) as usize - ptr as usize },
1282 40usize,
1283 concat!(
1284 "Offset of field: ",
1285 stringify!(sqlite3_mem_methods),
1286 "::",
1287 stringify!(xInit)
1288 )
1289 );
1290 assert_eq!(
1291 unsafe { ::std::ptr::addr_of!((*ptr).xShutdown) as usize - ptr as usize },
1292 48usize,
1293 concat!(
1294 "Offset of field: ",
1295 stringify!(sqlite3_mem_methods),
1296 "::",
1297 stringify!(xShutdown)
1298 )
1299 );
1300 assert_eq!(
1301 unsafe { ::std::ptr::addr_of!((*ptr).pAppData) as usize - ptr as usize },
1302 56usize,
1303 concat!(
1304 "Offset of field: ",
1305 stringify!(sqlite3_mem_methods),
1306 "::",
1307 stringify!(pAppData)
1308 )
1309 );
1310}
1311#[repr(C)]
1312#[derive(Debug, Copy, Clone)]
1313pub struct sqlite3_stmt {
1314 _unused: [u8; 0],
1315}
1316#[repr(C)]
1317#[derive(Debug, Copy, Clone)]
1318pub struct sqlite3_value {
1319 _unused: [u8; 0],
1320}
1321#[repr(C)]
1322#[derive(Debug, Copy, Clone)]
1323pub struct sqlite3_context {
1324 _unused: [u8; 0],
1325}
1326pub type sqlite3_destructor_type =
1327 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>;
1328extern "C" {
1329 pub static mut sqlite3_temp_directory: *mut ::std::os::raw::c_char;
1330}
1331extern "C" {
1332 pub static mut sqlite3_data_directory: *mut ::std::os::raw::c_char;
1333}
1334#[repr(C)]
1335#[derive(Debug, Copy, Clone)]
1336pub struct sqlite3_module {
1337 pub iVersion: ::std::os::raw::c_int,
1338 pub xCreate: ::std::option::Option<
1339 unsafe extern "C" fn(
1340 arg1: *mut sqlite3,
1341 pAux: *mut ::std::os::raw::c_void,
1342 argc: ::std::os::raw::c_int,
1343 argv: *const *const ::std::os::raw::c_char,
1344 ppVTab: *mut *mut sqlite3_vtab,
1345 arg2: *mut *mut ::std::os::raw::c_char,
1346 ) -> ::std::os::raw::c_int,
1347 >,
1348 pub xConnect: ::std::option::Option<
1349 unsafe extern "C" fn(
1350 arg1: *mut sqlite3,
1351 pAux: *mut ::std::os::raw::c_void,
1352 argc: ::std::os::raw::c_int,
1353 argv: *const *const ::std::os::raw::c_char,
1354 ppVTab: *mut *mut sqlite3_vtab,
1355 arg2: *mut *mut ::std::os::raw::c_char,
1356 ) -> ::std::os::raw::c_int,
1357 >,
1358 pub xBestIndex: ::std::option::Option<
1359 unsafe extern "C" fn(
1360 pVTab: *mut sqlite3_vtab,
1361 arg1: *mut sqlite3_index_info,
1362 ) -> ::std::os::raw::c_int,
1363 >,
1364 pub xDisconnect: ::std::option::Option<
1365 unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int,
1366 >,
1367 pub xDestroy: ::std::option::Option<
1368 unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int,
1369 >,
1370 pub xOpen: ::std::option::Option<
1371 unsafe extern "C" fn(
1372 pVTab: *mut sqlite3_vtab,
1373 ppCursor: *mut *mut sqlite3_vtab_cursor,
1374 ) -> ::std::os::raw::c_int,
1375 >,
1376 pub xClose: ::std::option::Option<
1377 unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int,
1378 >,
1379 pub xFilter: ::std::option::Option<
1380 unsafe extern "C" fn(
1381 arg1: *mut sqlite3_vtab_cursor,
1382 idxNum: ::std::os::raw::c_int,
1383 idxStr: *const ::std::os::raw::c_char,
1384 argc: ::std::os::raw::c_int,
1385 argv: *mut *mut sqlite3_value,
1386 ) -> ::std::os::raw::c_int,
1387 >,
1388 pub xNext: ::std::option::Option<
1389 unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int,
1390 >,
1391 pub xEof: ::std::option::Option<
1392 unsafe extern "C" fn(arg1: *mut sqlite3_vtab_cursor) -> ::std::os::raw::c_int,
1393 >,
1394 pub xColumn: ::std::option::Option<
1395 unsafe extern "C" fn(
1396 arg1: *mut sqlite3_vtab_cursor,
1397 arg2: *mut sqlite3_context,
1398 arg3: ::std::os::raw::c_int,
1399 ) -> ::std::os::raw::c_int,
1400 >,
1401 pub xRowid: ::std::option::Option<
1402 unsafe extern "C" fn(
1403 arg1: *mut sqlite3_vtab_cursor,
1404 pRowid: *mut sqlite3_int64,
1405 ) -> ::std::os::raw::c_int,
1406 >,
1407 pub xUpdate: ::std::option::Option<
1408 unsafe extern "C" fn(
1409 arg1: *mut sqlite3_vtab,
1410 arg2: ::std::os::raw::c_int,
1411 arg3: *mut *mut sqlite3_value,
1412 arg4: *mut sqlite3_int64,
1413 ) -> ::std::os::raw::c_int,
1414 >,
1415 pub xBegin: ::std::option::Option<
1416 unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int,
1417 >,
1418 pub xSync: ::std::option::Option<
1419 unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int,
1420 >,
1421 pub xCommit: ::std::option::Option<
1422 unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int,
1423 >,
1424 pub xRollback: ::std::option::Option<
1425 unsafe extern "C" fn(pVTab: *mut sqlite3_vtab) -> ::std::os::raw::c_int,
1426 >,
1427 pub xFindFunction: ::std::option::Option<
1428 unsafe extern "C" fn(
1429 pVtab: *mut sqlite3_vtab,
1430 nArg: ::std::os::raw::c_int,
1431 zName: *const ::std::os::raw::c_char,
1432 pxFunc: *mut ::std::option::Option<
1433 unsafe extern "C" fn(
1434 arg1: *mut sqlite3_context,
1435 arg2: ::std::os::raw::c_int,
1436 arg3: *mut *mut sqlite3_value,
1437 ),
1438 >,
1439 ppArg: *mut *mut ::std::os::raw::c_void,
1440 ) -> ::std::os::raw::c_int,
1441 >,
1442 pub xRename: ::std::option::Option<
1443 unsafe extern "C" fn(
1444 pVtab: *mut sqlite3_vtab,
1445 zNew: *const ::std::os::raw::c_char,
1446 ) -> ::std::os::raw::c_int,
1447 >,
1448 pub xSavepoint: ::std::option::Option<
1449 unsafe extern "C" fn(
1450 pVTab: *mut sqlite3_vtab,
1451 arg1: ::std::os::raw::c_int,
1452 ) -> ::std::os::raw::c_int,
1453 >,
1454 pub xRelease: ::std::option::Option<
1455 unsafe extern "C" fn(
1456 pVTab: *mut sqlite3_vtab,
1457 arg1: ::std::os::raw::c_int,
1458 ) -> ::std::os::raw::c_int,
1459 >,
1460 pub xRollbackTo: ::std::option::Option<
1461 unsafe extern "C" fn(
1462 pVTab: *mut sqlite3_vtab,
1463 arg1: ::std::os::raw::c_int,
1464 ) -> ::std::os::raw::c_int,
1465 >,
1466 pub xShadowName: ::std::option::Option<
1467 unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int,
1468 >,
1469}
1470#[test]
1471fn bindgen_test_layout_sqlite3_module() {
1472 const UNINIT: ::std::mem::MaybeUninit<sqlite3_module> = ::std::mem::MaybeUninit::uninit();
1473 let ptr = UNINIT.as_ptr();
1474 assert_eq!(
1475 ::std::mem::size_of::<sqlite3_module>(),
1476 192usize,
1477 concat!("Size of: ", stringify!(sqlite3_module))
1478 );
1479 assert_eq!(
1480 ::std::mem::align_of::<sqlite3_module>(),
1481 8usize,
1482 concat!("Alignment of ", stringify!(sqlite3_module))
1483 );
1484 assert_eq!(
1485 unsafe { ::std::ptr::addr_of!((*ptr).iVersion) as usize - ptr as usize },
1486 0usize,
1487 concat!(
1488 "Offset of field: ",
1489 stringify!(sqlite3_module),
1490 "::",
1491 stringify!(iVersion)
1492 )
1493 );
1494 assert_eq!(
1495 unsafe { ::std::ptr::addr_of!((*ptr).xCreate) as usize - ptr as usize },
1496 8usize,
1497 concat!(
1498 "Offset of field: ",
1499 stringify!(sqlite3_module),
1500 "::",
1501 stringify!(xCreate)
1502 )
1503 );
1504 assert_eq!(
1505 unsafe { ::std::ptr::addr_of!((*ptr).xConnect) as usize - ptr as usize },
1506 16usize,
1507 concat!(
1508 "Offset of field: ",
1509 stringify!(sqlite3_module),
1510 "::",
1511 stringify!(xConnect)
1512 )
1513 );
1514 assert_eq!(
1515 unsafe { ::std::ptr::addr_of!((*ptr).xBestIndex) as usize - ptr as usize },
1516 24usize,
1517 concat!(
1518 "Offset of field: ",
1519 stringify!(sqlite3_module),
1520 "::",
1521 stringify!(xBestIndex)
1522 )
1523 );
1524 assert_eq!(
1525 unsafe { ::std::ptr::addr_of!((*ptr).xDisconnect) as usize - ptr as usize },
1526 32usize,
1527 concat!(
1528 "Offset of field: ",
1529 stringify!(sqlite3_module),
1530 "::",
1531 stringify!(xDisconnect)
1532 )
1533 );
1534 assert_eq!(
1535 unsafe { ::std::ptr::addr_of!((*ptr).xDestroy) as usize - ptr as usize },
1536 40usize,
1537 concat!(
1538 "Offset of field: ",
1539 stringify!(sqlite3_module),
1540 "::",
1541 stringify!(xDestroy)
1542 )
1543 );
1544 assert_eq!(
1545 unsafe { ::std::ptr::addr_of!((*ptr).xOpen) as usize - ptr as usize },
1546 48usize,
1547 concat!(
1548 "Offset of field: ",
1549 stringify!(sqlite3_module),
1550 "::",
1551 stringify!(xOpen)
1552 )
1553 );
1554 assert_eq!(
1555 unsafe { ::std::ptr::addr_of!((*ptr).xClose) as usize - ptr as usize },
1556 56usize,
1557 concat!(
1558 "Offset of field: ",
1559 stringify!(sqlite3_module),
1560 "::",
1561 stringify!(xClose)
1562 )
1563 );
1564 assert_eq!(
1565 unsafe { ::std::ptr::addr_of!((*ptr).xFilter) as usize - ptr as usize },
1566 64usize,
1567 concat!(
1568 "Offset of field: ",
1569 stringify!(sqlite3_module),
1570 "::",
1571 stringify!(xFilter)
1572 )
1573 );
1574 assert_eq!(
1575 unsafe { ::std::ptr::addr_of!((*ptr).xNext) as usize - ptr as usize },
1576 72usize,
1577 concat!(
1578 "Offset of field: ",
1579 stringify!(sqlite3_module),
1580 "::",
1581 stringify!(xNext)
1582 )
1583 );
1584 assert_eq!(
1585 unsafe { ::std::ptr::addr_of!((*ptr).xEof) as usize - ptr as usize },
1586 80usize,
1587 concat!(
1588 "Offset of field: ",
1589 stringify!(sqlite3_module),
1590 "::",
1591 stringify!(xEof)
1592 )
1593 );
1594 assert_eq!(
1595 unsafe { ::std::ptr::addr_of!((*ptr).xColumn) as usize - ptr as usize },
1596 88usize,
1597 concat!(
1598 "Offset of field: ",
1599 stringify!(sqlite3_module),
1600 "::",
1601 stringify!(xColumn)
1602 )
1603 );
1604 assert_eq!(
1605 unsafe { ::std::ptr::addr_of!((*ptr).xRowid) as usize - ptr as usize },
1606 96usize,
1607 concat!(
1608 "Offset of field: ",
1609 stringify!(sqlite3_module),
1610 "::",
1611 stringify!(xRowid)
1612 )
1613 );
1614 assert_eq!(
1615 unsafe { ::std::ptr::addr_of!((*ptr).xUpdate) as usize - ptr as usize },
1616 104usize,
1617 concat!(
1618 "Offset of field: ",
1619 stringify!(sqlite3_module),
1620 "::",
1621 stringify!(xUpdate)
1622 )
1623 );
1624 assert_eq!(
1625 unsafe { ::std::ptr::addr_of!((*ptr).xBegin) as usize - ptr as usize },
1626 112usize,
1627 concat!(
1628 "Offset of field: ",
1629 stringify!(sqlite3_module),
1630 "::",
1631 stringify!(xBegin)
1632 )
1633 );
1634 assert_eq!(
1635 unsafe { ::std::ptr::addr_of!((*ptr).xSync) as usize - ptr as usize },
1636 120usize,
1637 concat!(
1638 "Offset of field: ",
1639 stringify!(sqlite3_module),
1640 "::",
1641 stringify!(xSync)
1642 )
1643 );
1644 assert_eq!(
1645 unsafe { ::std::ptr::addr_of!((*ptr).xCommit) as usize - ptr as usize },
1646 128usize,
1647 concat!(
1648 "Offset of field: ",
1649 stringify!(sqlite3_module),
1650 "::",
1651 stringify!(xCommit)
1652 )
1653 );
1654 assert_eq!(
1655 unsafe { ::std::ptr::addr_of!((*ptr).xRollback) as usize - ptr as usize },
1656 136usize,
1657 concat!(
1658 "Offset of field: ",
1659 stringify!(sqlite3_module),
1660 "::",
1661 stringify!(xRollback)
1662 )
1663 );
1664 assert_eq!(
1665 unsafe { ::std::ptr::addr_of!((*ptr).xFindFunction) as usize - ptr as usize },
1666 144usize,
1667 concat!(
1668 "Offset of field: ",
1669 stringify!(sqlite3_module),
1670 "::",
1671 stringify!(xFindFunction)
1672 )
1673 );
1674 assert_eq!(
1675 unsafe { ::std::ptr::addr_of!((*ptr).xRename) as usize - ptr as usize },
1676 152usize,
1677 concat!(
1678 "Offset of field: ",
1679 stringify!(sqlite3_module),
1680 "::",
1681 stringify!(xRename)
1682 )
1683 );
1684 assert_eq!(
1685 unsafe { ::std::ptr::addr_of!((*ptr).xSavepoint) as usize - ptr as usize },
1686 160usize,
1687 concat!(
1688 "Offset of field: ",
1689 stringify!(sqlite3_module),
1690 "::",
1691 stringify!(xSavepoint)
1692 )
1693 );
1694 assert_eq!(
1695 unsafe { ::std::ptr::addr_of!((*ptr).xRelease) as usize - ptr as usize },
1696 168usize,
1697 concat!(
1698 "Offset of field: ",
1699 stringify!(sqlite3_module),
1700 "::",
1701 stringify!(xRelease)
1702 )
1703 );
1704 assert_eq!(
1705 unsafe { ::std::ptr::addr_of!((*ptr).xRollbackTo) as usize - ptr as usize },
1706 176usize,
1707 concat!(
1708 "Offset of field: ",
1709 stringify!(sqlite3_module),
1710 "::",
1711 stringify!(xRollbackTo)
1712 )
1713 );
1714 assert_eq!(
1715 unsafe { ::std::ptr::addr_of!((*ptr).xShadowName) as usize - ptr as usize },
1716 184usize,
1717 concat!(
1718 "Offset of field: ",
1719 stringify!(sqlite3_module),
1720 "::",
1721 stringify!(xShadowName)
1722 )
1723 );
1724}
1725#[repr(C)]
1726#[derive(Debug, Copy, Clone)]
1727pub struct sqlite3_index_info {
1728 pub nConstraint: ::std::os::raw::c_int,
1729 pub aConstraint: *mut sqlite3_index_info_sqlite3_index_constraint,
1730 pub nOrderBy: ::std::os::raw::c_int,
1731 pub aOrderBy: *mut sqlite3_index_info_sqlite3_index_orderby,
1732 pub aConstraintUsage: *mut sqlite3_index_info_sqlite3_index_constraint_usage,
1733 pub idxNum: ::std::os::raw::c_int,
1734 pub idxStr: *mut ::std::os::raw::c_char,
1735 pub needToFreeIdxStr: ::std::os::raw::c_int,
1736 pub orderByConsumed: ::std::os::raw::c_int,
1737 pub estimatedCost: f64,
1738 pub estimatedRows: sqlite3_int64,
1739 pub idxFlags: ::std::os::raw::c_int,
1740 pub colUsed: sqlite3_uint64,
1741}
1742#[repr(C)]
1743#[derive(Debug, Copy, Clone)]
1744pub struct sqlite3_index_info_sqlite3_index_constraint {
1745 pub iColumn: ::std::os::raw::c_int,
1746 pub op: ::std::os::raw::c_uchar,
1747 pub usable: ::std::os::raw::c_uchar,
1748 pub iTermOffset: ::std::os::raw::c_int,
1749}
1750#[test]
1751fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint() {
1752 const UNINIT: ::std::mem::MaybeUninit<sqlite3_index_info_sqlite3_index_constraint> =
1753 ::std::mem::MaybeUninit::uninit();
1754 let ptr = UNINIT.as_ptr();
1755 assert_eq!(
1756 ::std::mem::size_of::<sqlite3_index_info_sqlite3_index_constraint>(),
1757 12usize,
1758 concat!(
1759 "Size of: ",
1760 stringify!(sqlite3_index_info_sqlite3_index_constraint)
1761 )
1762 );
1763 assert_eq!(
1764 ::std::mem::align_of::<sqlite3_index_info_sqlite3_index_constraint>(),
1765 4usize,
1766 concat!(
1767 "Alignment of ",
1768 stringify!(sqlite3_index_info_sqlite3_index_constraint)
1769 )
1770 );
1771 assert_eq!(
1772 unsafe { ::std::ptr::addr_of!((*ptr).iColumn) as usize - ptr as usize },
1773 0usize,
1774 concat!(
1775 "Offset of field: ",
1776 stringify!(sqlite3_index_info_sqlite3_index_constraint),
1777 "::",
1778 stringify!(iColumn)
1779 )
1780 );
1781 assert_eq!(
1782 unsafe { ::std::ptr::addr_of!((*ptr).op) as usize - ptr as usize },
1783 4usize,
1784 concat!(
1785 "Offset of field: ",
1786 stringify!(sqlite3_index_info_sqlite3_index_constraint),
1787 "::",
1788 stringify!(op)
1789 )
1790 );
1791 assert_eq!(
1792 unsafe { ::std::ptr::addr_of!((*ptr).usable) as usize - ptr as usize },
1793 5usize,
1794 concat!(
1795 "Offset of field: ",
1796 stringify!(sqlite3_index_info_sqlite3_index_constraint),
1797 "::",
1798 stringify!(usable)
1799 )
1800 );
1801 assert_eq!(
1802 unsafe { ::std::ptr::addr_of!((*ptr).iTermOffset) as usize - ptr as usize },
1803 8usize,
1804 concat!(
1805 "Offset of field: ",
1806 stringify!(sqlite3_index_info_sqlite3_index_constraint),
1807 "::",
1808 stringify!(iTermOffset)
1809 )
1810 );
1811}
1812#[repr(C)]
1813#[derive(Debug, Copy, Clone)]
1814pub struct sqlite3_index_info_sqlite3_index_orderby {
1815 pub iColumn: ::std::os::raw::c_int,
1816 pub desc: ::std::os::raw::c_uchar,
1817}
1818#[test]
1819fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_orderby() {
1820 const UNINIT: ::std::mem::MaybeUninit<sqlite3_index_info_sqlite3_index_orderby> =
1821 ::std::mem::MaybeUninit::uninit();
1822 let ptr = UNINIT.as_ptr();
1823 assert_eq!(
1824 ::std::mem::size_of::<sqlite3_index_info_sqlite3_index_orderby>(),
1825 8usize,
1826 concat!(
1827 "Size of: ",
1828 stringify!(sqlite3_index_info_sqlite3_index_orderby)
1829 )
1830 );
1831 assert_eq!(
1832 ::std::mem::align_of::<sqlite3_index_info_sqlite3_index_orderby>(),
1833 4usize,
1834 concat!(
1835 "Alignment of ",
1836 stringify!(sqlite3_index_info_sqlite3_index_orderby)
1837 )
1838 );
1839 assert_eq!(
1840 unsafe { ::std::ptr::addr_of!((*ptr).iColumn) as usize - ptr as usize },
1841 0usize,
1842 concat!(
1843 "Offset of field: ",
1844 stringify!(sqlite3_index_info_sqlite3_index_orderby),
1845 "::",
1846 stringify!(iColumn)
1847 )
1848 );
1849 assert_eq!(
1850 unsafe { ::std::ptr::addr_of!((*ptr).desc) as usize - ptr as usize },
1851 4usize,
1852 concat!(
1853 "Offset of field: ",
1854 stringify!(sqlite3_index_info_sqlite3_index_orderby),
1855 "::",
1856 stringify!(desc)
1857 )
1858 );
1859}
1860#[repr(C)]
1861#[derive(Debug, Copy, Clone)]
1862pub struct sqlite3_index_info_sqlite3_index_constraint_usage {
1863 pub argvIndex: ::std::os::raw::c_int,
1864 pub omit: ::std::os::raw::c_uchar,
1865}
1866#[test]
1867fn bindgen_test_layout_sqlite3_index_info_sqlite3_index_constraint_usage() {
1868 const UNINIT: ::std::mem::MaybeUninit<sqlite3_index_info_sqlite3_index_constraint_usage> =
1869 ::std::mem::MaybeUninit::uninit();
1870 let ptr = UNINIT.as_ptr();
1871 assert_eq!(
1872 ::std::mem::size_of::<sqlite3_index_info_sqlite3_index_constraint_usage>(),
1873 8usize,
1874 concat!(
1875 "Size of: ",
1876 stringify!(sqlite3_index_info_sqlite3_index_constraint_usage)
1877 )
1878 );
1879 assert_eq!(
1880 ::std::mem::align_of::<sqlite3_index_info_sqlite3_index_constraint_usage>(),
1881 4usize,
1882 concat!(
1883 "Alignment of ",
1884 stringify!(sqlite3_index_info_sqlite3_index_constraint_usage)
1885 )
1886 );
1887 assert_eq!(
1888 unsafe { ::std::ptr::addr_of!((*ptr).argvIndex) as usize - ptr as usize },
1889 0usize,
1890 concat!(
1891 "Offset of field: ",
1892 stringify!(sqlite3_index_info_sqlite3_index_constraint_usage),
1893 "::",
1894 stringify!(argvIndex)
1895 )
1896 );
1897 assert_eq!(
1898 unsafe { ::std::ptr::addr_of!((*ptr).omit) as usize - ptr as usize },
1899 4usize,
1900 concat!(
1901 "Offset of field: ",
1902 stringify!(sqlite3_index_info_sqlite3_index_constraint_usage),
1903 "::",
1904 stringify!(omit)
1905 )
1906 );
1907}
1908#[test]
1909fn bindgen_test_layout_sqlite3_index_info() {
1910 const UNINIT: ::std::mem::MaybeUninit<sqlite3_index_info> = ::std::mem::MaybeUninit::uninit();
1911 let ptr = UNINIT.as_ptr();
1912 assert_eq!(
1913 ::std::mem::size_of::<sqlite3_index_info>(),
1914 96usize,
1915 concat!("Size of: ", stringify!(sqlite3_index_info))
1916 );
1917 assert_eq!(
1918 ::std::mem::align_of::<sqlite3_index_info>(),
1919 8usize,
1920 concat!("Alignment of ", stringify!(sqlite3_index_info))
1921 );
1922 assert_eq!(
1923 unsafe { ::std::ptr::addr_of!((*ptr).nConstraint) as usize - ptr as usize },
1924 0usize,
1925 concat!(
1926 "Offset of field: ",
1927 stringify!(sqlite3_index_info),
1928 "::",
1929 stringify!(nConstraint)
1930 )
1931 );
1932 assert_eq!(
1933 unsafe { ::std::ptr::addr_of!((*ptr).aConstraint) as usize - ptr as usize },
1934 8usize,
1935 concat!(
1936 "Offset of field: ",
1937 stringify!(sqlite3_index_info),
1938 "::",
1939 stringify!(aConstraint)
1940 )
1941 );
1942 assert_eq!(
1943 unsafe { ::std::ptr::addr_of!((*ptr).nOrderBy) as usize - ptr as usize },
1944 16usize,
1945 concat!(
1946 "Offset of field: ",
1947 stringify!(sqlite3_index_info),
1948 "::",
1949 stringify!(nOrderBy)
1950 )
1951 );
1952 assert_eq!(
1953 unsafe { ::std::ptr::addr_of!((*ptr).aOrderBy) as usize - ptr as usize },
1954 24usize,
1955 concat!(
1956 "Offset of field: ",
1957 stringify!(sqlite3_index_info),
1958 "::",
1959 stringify!(aOrderBy)
1960 )
1961 );
1962 assert_eq!(
1963 unsafe { ::std::ptr::addr_of!((*ptr).aConstraintUsage) as usize - ptr as usize },
1964 32usize,
1965 concat!(
1966 "Offset of field: ",
1967 stringify!(sqlite3_index_info),
1968 "::",
1969 stringify!(aConstraintUsage)
1970 )
1971 );
1972 assert_eq!(
1973 unsafe { ::std::ptr::addr_of!((*ptr).idxNum) as usize - ptr as usize },
1974 40usize,
1975 concat!(
1976 "Offset of field: ",
1977 stringify!(sqlite3_index_info),
1978 "::",
1979 stringify!(idxNum)
1980 )
1981 );
1982 assert_eq!(
1983 unsafe { ::std::ptr::addr_of!((*ptr).idxStr) as usize - ptr as usize },
1984 48usize,
1985 concat!(
1986 "Offset of field: ",
1987 stringify!(sqlite3_index_info),
1988 "::",
1989 stringify!(idxStr)
1990 )
1991 );
1992 assert_eq!(
1993 unsafe { ::std::ptr::addr_of!((*ptr).needToFreeIdxStr) as usize - ptr as usize },
1994 56usize,
1995 concat!(
1996 "Offset of field: ",
1997 stringify!(sqlite3_index_info),
1998 "::",
1999 stringify!(needToFreeIdxStr)
2000 )
2001 );
2002 assert_eq!(
2003 unsafe { ::std::ptr::addr_of!((*ptr).orderByConsumed) as usize - ptr as usize },
2004 60usize,
2005 concat!(
2006 "Offset of field: ",
2007 stringify!(sqlite3_index_info),
2008 "::",
2009 stringify!(orderByConsumed)
2010 )
2011 );
2012 assert_eq!(
2013 unsafe { ::std::ptr::addr_of!((*ptr).estimatedCost) as usize - ptr as usize },
2014 64usize,
2015 concat!(
2016 "Offset of field: ",
2017 stringify!(sqlite3_index_info),
2018 "::",
2019 stringify!(estimatedCost)
2020 )
2021 );
2022 assert_eq!(
2023 unsafe { ::std::ptr::addr_of!((*ptr).estimatedRows) as usize - ptr as usize },
2024 72usize,
2025 concat!(
2026 "Offset of field: ",
2027 stringify!(sqlite3_index_info),
2028 "::",
2029 stringify!(estimatedRows)
2030 )
2031 );
2032 assert_eq!(
2033 unsafe { ::std::ptr::addr_of!((*ptr).idxFlags) as usize - ptr as usize },
2034 80usize,
2035 concat!(
2036 "Offset of field: ",
2037 stringify!(sqlite3_index_info),
2038 "::",
2039 stringify!(idxFlags)
2040 )
2041 );
2042 assert_eq!(
2043 unsafe { ::std::ptr::addr_of!((*ptr).colUsed) as usize - ptr as usize },
2044 88usize,
2045 concat!(
2046 "Offset of field: ",
2047 stringify!(sqlite3_index_info),
2048 "::",
2049 stringify!(colUsed)
2050 )
2051 );
2052}
2053#[repr(C)]
2054#[derive(Debug, Copy, Clone)]
2055pub struct sqlite3_vtab {
2056 pub pModule: *const sqlite3_module,
2057 pub nRef: ::std::os::raw::c_int,
2058 pub zErrMsg: *mut ::std::os::raw::c_char,
2059}
2060#[test]
2061fn bindgen_test_layout_sqlite3_vtab() {
2062 const UNINIT: ::std::mem::MaybeUninit<sqlite3_vtab> = ::std::mem::MaybeUninit::uninit();
2063 let ptr = UNINIT.as_ptr();
2064 assert_eq!(
2065 ::std::mem::size_of::<sqlite3_vtab>(),
2066 24usize,
2067 concat!("Size of: ", stringify!(sqlite3_vtab))
2068 );
2069 assert_eq!(
2070 ::std::mem::align_of::<sqlite3_vtab>(),
2071 8usize,
2072 concat!("Alignment of ", stringify!(sqlite3_vtab))
2073 );
2074 assert_eq!(
2075 unsafe { ::std::ptr::addr_of!((*ptr).pModule) as usize - ptr as usize },
2076 0usize,
2077 concat!(
2078 "Offset of field: ",
2079 stringify!(sqlite3_vtab),
2080 "::",
2081 stringify!(pModule)
2082 )
2083 );
2084 assert_eq!(
2085 unsafe { ::std::ptr::addr_of!((*ptr).nRef) as usize - ptr as usize },
2086 8usize,
2087 concat!(
2088 "Offset of field: ",
2089 stringify!(sqlite3_vtab),
2090 "::",
2091 stringify!(nRef)
2092 )
2093 );
2094 assert_eq!(
2095 unsafe { ::std::ptr::addr_of!((*ptr).zErrMsg) as usize - ptr as usize },
2096 16usize,
2097 concat!(
2098 "Offset of field: ",
2099 stringify!(sqlite3_vtab),
2100 "::",
2101 stringify!(zErrMsg)
2102 )
2103 );
2104}
2105#[repr(C)]
2106#[derive(Debug, Copy, Clone)]
2107pub struct sqlite3_vtab_cursor {
2108 pub pVtab: *mut sqlite3_vtab,
2109}
2110#[test]
2111fn bindgen_test_layout_sqlite3_vtab_cursor() {
2112 const UNINIT: ::std::mem::MaybeUninit<sqlite3_vtab_cursor> = ::std::mem::MaybeUninit::uninit();
2113 let ptr = UNINIT.as_ptr();
2114 assert_eq!(
2115 ::std::mem::size_of::<sqlite3_vtab_cursor>(),
2116 8usize,
2117 concat!("Size of: ", stringify!(sqlite3_vtab_cursor))
2118 );
2119 assert_eq!(
2120 ::std::mem::align_of::<sqlite3_vtab_cursor>(),
2121 8usize,
2122 concat!("Alignment of ", stringify!(sqlite3_vtab_cursor))
2123 );
2124 assert_eq!(
2125 unsafe { ::std::ptr::addr_of!((*ptr).pVtab) as usize - ptr as usize },
2126 0usize,
2127 concat!(
2128 "Offset of field: ",
2129 stringify!(sqlite3_vtab_cursor),
2130 "::",
2131 stringify!(pVtab)
2132 )
2133 );
2134}
2135#[repr(C)]
2136#[derive(Debug, Copy, Clone)]
2137pub struct sqlite3_blob {
2138 _unused: [u8; 0],
2139}
2140#[repr(C)]
2141#[derive(Debug, Copy, Clone)]
2142pub struct sqlite3_mutex_methods {
2143 pub xMutexInit: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
2144 pub xMutexEnd: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
2145 pub xMutexAlloc: ::std::option::Option<
2146 unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex,
2147 >,
2148 pub xMutexFree: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_mutex)>,
2149 pub xMutexEnter: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_mutex)>,
2150 pub xMutexTry: ::std::option::Option<
2151 unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int,
2152 >,
2153 pub xMutexLeave: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_mutex)>,
2154 pub xMutexHeld: ::std::option::Option<
2155 unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int,
2156 >,
2157 pub xMutexNotheld: ::std::option::Option<
2158 unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int,
2159 >,
2160}
2161#[test]
2162fn bindgen_test_layout_sqlite3_mutex_methods() {
2163 const UNINIT: ::std::mem::MaybeUninit<sqlite3_mutex_methods> =
2164 ::std::mem::MaybeUninit::uninit();
2165 let ptr = UNINIT.as_ptr();
2166 assert_eq!(
2167 ::std::mem::size_of::<sqlite3_mutex_methods>(),
2168 72usize,
2169 concat!("Size of: ", stringify!(sqlite3_mutex_methods))
2170 );
2171 assert_eq!(
2172 ::std::mem::align_of::<sqlite3_mutex_methods>(),
2173 8usize,
2174 concat!("Alignment of ", stringify!(sqlite3_mutex_methods))
2175 );
2176 assert_eq!(
2177 unsafe { ::std::ptr::addr_of!((*ptr).xMutexInit) as usize - ptr as usize },
2178 0usize,
2179 concat!(
2180 "Offset of field: ",
2181 stringify!(sqlite3_mutex_methods),
2182 "::",
2183 stringify!(xMutexInit)
2184 )
2185 );
2186 assert_eq!(
2187 unsafe { ::std::ptr::addr_of!((*ptr).xMutexEnd) as usize - ptr as usize },
2188 8usize,
2189 concat!(
2190 "Offset of field: ",
2191 stringify!(sqlite3_mutex_methods),
2192 "::",
2193 stringify!(xMutexEnd)
2194 )
2195 );
2196 assert_eq!(
2197 unsafe { ::std::ptr::addr_of!((*ptr).xMutexAlloc) as usize - ptr as usize },
2198 16usize,
2199 concat!(
2200 "Offset of field: ",
2201 stringify!(sqlite3_mutex_methods),
2202 "::",
2203 stringify!(xMutexAlloc)
2204 )
2205 );
2206 assert_eq!(
2207 unsafe { ::std::ptr::addr_of!((*ptr).xMutexFree) as usize - ptr as usize },
2208 24usize,
2209 concat!(
2210 "Offset of field: ",
2211 stringify!(sqlite3_mutex_methods),
2212 "::",
2213 stringify!(xMutexFree)
2214 )
2215 );
2216 assert_eq!(
2217 unsafe { ::std::ptr::addr_of!((*ptr).xMutexEnter) as usize - ptr as usize },
2218 32usize,
2219 concat!(
2220 "Offset of field: ",
2221 stringify!(sqlite3_mutex_methods),
2222 "::",
2223 stringify!(xMutexEnter)
2224 )
2225 );
2226 assert_eq!(
2227 unsafe { ::std::ptr::addr_of!((*ptr).xMutexTry) as usize - ptr as usize },
2228 40usize,
2229 concat!(
2230 "Offset of field: ",
2231 stringify!(sqlite3_mutex_methods),
2232 "::",
2233 stringify!(xMutexTry)
2234 )
2235 );
2236 assert_eq!(
2237 unsafe { ::std::ptr::addr_of!((*ptr).xMutexLeave) as usize - ptr as usize },
2238 48usize,
2239 concat!(
2240 "Offset of field: ",
2241 stringify!(sqlite3_mutex_methods),
2242 "::",
2243 stringify!(xMutexLeave)
2244 )
2245 );
2246 assert_eq!(
2247 unsafe { ::std::ptr::addr_of!((*ptr).xMutexHeld) as usize - ptr as usize },
2248 56usize,
2249 concat!(
2250 "Offset of field: ",
2251 stringify!(sqlite3_mutex_methods),
2252 "::",
2253 stringify!(xMutexHeld)
2254 )
2255 );
2256 assert_eq!(
2257 unsafe { ::std::ptr::addr_of!((*ptr).xMutexNotheld) as usize - ptr as usize },
2258 64usize,
2259 concat!(
2260 "Offset of field: ",
2261 stringify!(sqlite3_mutex_methods),
2262 "::",
2263 stringify!(xMutexNotheld)
2264 )
2265 );
2266}
2267#[repr(C)]
2268#[derive(Debug, Copy, Clone)]
2269pub struct sqlite3_str {
2270 _unused: [u8; 0],
2271}
2272#[repr(C)]
2273#[derive(Debug, Copy, Clone)]
2274pub struct sqlite3_pcache {
2275 _unused: [u8; 0],
2276}
2277#[repr(C)]
2278#[derive(Debug, Copy, Clone)]
2279pub struct sqlite3_pcache_page {
2280 pub pBuf: *mut ::std::os::raw::c_void,
2281 pub pExtra: *mut ::std::os::raw::c_void,
2282}
2283#[test]
2284fn bindgen_test_layout_sqlite3_pcache_page() {
2285 const UNINIT: ::std::mem::MaybeUninit<sqlite3_pcache_page> = ::std::mem::MaybeUninit::uninit();
2286 let ptr = UNINIT.as_ptr();
2287 assert_eq!(
2288 ::std::mem::size_of::<sqlite3_pcache_page>(),
2289 16usize,
2290 concat!("Size of: ", stringify!(sqlite3_pcache_page))
2291 );
2292 assert_eq!(
2293 ::std::mem::align_of::<sqlite3_pcache_page>(),
2294 8usize,
2295 concat!("Alignment of ", stringify!(sqlite3_pcache_page))
2296 );
2297 assert_eq!(
2298 unsafe { ::std::ptr::addr_of!((*ptr).pBuf) as usize - ptr as usize },
2299 0usize,
2300 concat!(
2301 "Offset of field: ",
2302 stringify!(sqlite3_pcache_page),
2303 "::",
2304 stringify!(pBuf)
2305 )
2306 );
2307 assert_eq!(
2308 unsafe { ::std::ptr::addr_of!((*ptr).pExtra) as usize - ptr as usize },
2309 8usize,
2310 concat!(
2311 "Offset of field: ",
2312 stringify!(sqlite3_pcache_page),
2313 "::",
2314 stringify!(pExtra)
2315 )
2316 );
2317}
2318#[repr(C)]
2319#[derive(Debug, Copy, Clone)]
2320pub struct sqlite3_pcache_methods2 {
2321 pub iVersion: ::std::os::raw::c_int,
2322 pub pArg: *mut ::std::os::raw::c_void,
2323 pub xInit: ::std::option::Option<
2324 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
2325 >,
2326 pub xShutdown: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
2327 pub xCreate: ::std::option::Option<
2328 unsafe extern "C" fn(
2329 szPage: ::std::os::raw::c_int,
2330 szExtra: ::std::os::raw::c_int,
2331 bPurgeable: ::std::os::raw::c_int,
2332 ) -> *mut sqlite3_pcache,
2333 >,
2334 pub xCachesize: ::std::option::Option<
2335 unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int),
2336 >,
2337 pub xPagecount: ::std::option::Option<
2338 unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int,
2339 >,
2340 pub xFetch: ::std::option::Option<
2341 unsafe extern "C" fn(
2342 arg1: *mut sqlite3_pcache,
2343 key: ::std::os::raw::c_uint,
2344 createFlag: ::std::os::raw::c_int,
2345 ) -> *mut sqlite3_pcache_page,
2346 >,
2347 pub xUnpin: ::std::option::Option<
2348 unsafe extern "C" fn(
2349 arg1: *mut sqlite3_pcache,
2350 arg2: *mut sqlite3_pcache_page,
2351 discard: ::std::os::raw::c_int,
2352 ),
2353 >,
2354 pub xRekey: ::std::option::Option<
2355 unsafe extern "C" fn(
2356 arg1: *mut sqlite3_pcache,
2357 arg2: *mut sqlite3_pcache_page,
2358 oldKey: ::std::os::raw::c_uint,
2359 newKey: ::std::os::raw::c_uint,
2360 ),
2361 >,
2362 pub xTruncate: ::std::option::Option<
2363 unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint),
2364 >,
2365 pub xDestroy: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_pcache)>,
2366 pub xShrink: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_pcache)>,
2367}
2368#[test]
2369fn bindgen_test_layout_sqlite3_pcache_methods2() {
2370 const UNINIT: ::std::mem::MaybeUninit<sqlite3_pcache_methods2> =
2371 ::std::mem::MaybeUninit::uninit();
2372 let ptr = UNINIT.as_ptr();
2373 assert_eq!(
2374 ::std::mem::size_of::<sqlite3_pcache_methods2>(),
2375 104usize,
2376 concat!("Size of: ", stringify!(sqlite3_pcache_methods2))
2377 );
2378 assert_eq!(
2379 ::std::mem::align_of::<sqlite3_pcache_methods2>(),
2380 8usize,
2381 concat!("Alignment of ", stringify!(sqlite3_pcache_methods2))
2382 );
2383 assert_eq!(
2384 unsafe { ::std::ptr::addr_of!((*ptr).iVersion) as usize - ptr as usize },
2385 0usize,
2386 concat!(
2387 "Offset of field: ",
2388 stringify!(sqlite3_pcache_methods2),
2389 "::",
2390 stringify!(iVersion)
2391 )
2392 );
2393 assert_eq!(
2394 unsafe { ::std::ptr::addr_of!((*ptr).pArg) as usize - ptr as usize },
2395 8usize,
2396 concat!(
2397 "Offset of field: ",
2398 stringify!(sqlite3_pcache_methods2),
2399 "::",
2400 stringify!(pArg)
2401 )
2402 );
2403 assert_eq!(
2404 unsafe { ::std::ptr::addr_of!((*ptr).xInit) as usize - ptr as usize },
2405 16usize,
2406 concat!(
2407 "Offset of field: ",
2408 stringify!(sqlite3_pcache_methods2),
2409 "::",
2410 stringify!(xInit)
2411 )
2412 );
2413 assert_eq!(
2414 unsafe { ::std::ptr::addr_of!((*ptr).xShutdown) as usize - ptr as usize },
2415 24usize,
2416 concat!(
2417 "Offset of field: ",
2418 stringify!(sqlite3_pcache_methods2),
2419 "::",
2420 stringify!(xShutdown)
2421 )
2422 );
2423 assert_eq!(
2424 unsafe { ::std::ptr::addr_of!((*ptr).xCreate) as usize - ptr as usize },
2425 32usize,
2426 concat!(
2427 "Offset of field: ",
2428 stringify!(sqlite3_pcache_methods2),
2429 "::",
2430 stringify!(xCreate)
2431 )
2432 );
2433 assert_eq!(
2434 unsafe { ::std::ptr::addr_of!((*ptr).xCachesize) as usize - ptr as usize },
2435 40usize,
2436 concat!(
2437 "Offset of field: ",
2438 stringify!(sqlite3_pcache_methods2),
2439 "::",
2440 stringify!(xCachesize)
2441 )
2442 );
2443 assert_eq!(
2444 unsafe { ::std::ptr::addr_of!((*ptr).xPagecount) as usize - ptr as usize },
2445 48usize,
2446 concat!(
2447 "Offset of field: ",
2448 stringify!(sqlite3_pcache_methods2),
2449 "::",
2450 stringify!(xPagecount)
2451 )
2452 );
2453 assert_eq!(
2454 unsafe { ::std::ptr::addr_of!((*ptr).xFetch) as usize - ptr as usize },
2455 56usize,
2456 concat!(
2457 "Offset of field: ",
2458 stringify!(sqlite3_pcache_methods2),
2459 "::",
2460 stringify!(xFetch)
2461 )
2462 );
2463 assert_eq!(
2464 unsafe { ::std::ptr::addr_of!((*ptr).xUnpin) as usize - ptr as usize },
2465 64usize,
2466 concat!(
2467 "Offset of field: ",
2468 stringify!(sqlite3_pcache_methods2),
2469 "::",
2470 stringify!(xUnpin)
2471 )
2472 );
2473 assert_eq!(
2474 unsafe { ::std::ptr::addr_of!((*ptr).xRekey) as usize - ptr as usize },
2475 72usize,
2476 concat!(
2477 "Offset of field: ",
2478 stringify!(sqlite3_pcache_methods2),
2479 "::",
2480 stringify!(xRekey)
2481 )
2482 );
2483 assert_eq!(
2484 unsafe { ::std::ptr::addr_of!((*ptr).xTruncate) as usize - ptr as usize },
2485 80usize,
2486 concat!(
2487 "Offset of field: ",
2488 stringify!(sqlite3_pcache_methods2),
2489 "::",
2490 stringify!(xTruncate)
2491 )
2492 );
2493 assert_eq!(
2494 unsafe { ::std::ptr::addr_of!((*ptr).xDestroy) as usize - ptr as usize },
2495 88usize,
2496 concat!(
2497 "Offset of field: ",
2498 stringify!(sqlite3_pcache_methods2),
2499 "::",
2500 stringify!(xDestroy)
2501 )
2502 );
2503 assert_eq!(
2504 unsafe { ::std::ptr::addr_of!((*ptr).xShrink) as usize - ptr as usize },
2505 96usize,
2506 concat!(
2507 "Offset of field: ",
2508 stringify!(sqlite3_pcache_methods2),
2509 "::",
2510 stringify!(xShrink)
2511 )
2512 );
2513}
2514#[repr(C)]
2515#[derive(Debug, Copy, Clone)]
2516pub struct sqlite3_pcache_methods {
2517 pub pArg: *mut ::std::os::raw::c_void,
2518 pub xInit: ::std::option::Option<
2519 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
2520 >,
2521 pub xShutdown: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
2522 pub xCreate: ::std::option::Option<
2523 unsafe extern "C" fn(
2524 szPage: ::std::os::raw::c_int,
2525 bPurgeable: ::std::os::raw::c_int,
2526 ) -> *mut sqlite3_pcache,
2527 >,
2528 pub xCachesize: ::std::option::Option<
2529 unsafe extern "C" fn(arg1: *mut sqlite3_pcache, nCachesize: ::std::os::raw::c_int),
2530 >,
2531 pub xPagecount: ::std::option::Option<
2532 unsafe extern "C" fn(arg1: *mut sqlite3_pcache) -> ::std::os::raw::c_int,
2533 >,
2534 pub xFetch: ::std::option::Option<
2535 unsafe extern "C" fn(
2536 arg1: *mut sqlite3_pcache,
2537 key: ::std::os::raw::c_uint,
2538 createFlag: ::std::os::raw::c_int,
2539 ) -> *mut ::std::os::raw::c_void,
2540 >,
2541 pub xUnpin: ::std::option::Option<
2542 unsafe extern "C" fn(
2543 arg1: *mut sqlite3_pcache,
2544 arg2: *mut ::std::os::raw::c_void,
2545 discard: ::std::os::raw::c_int,
2546 ),
2547 >,
2548 pub xRekey: ::std::option::Option<
2549 unsafe extern "C" fn(
2550 arg1: *mut sqlite3_pcache,
2551 arg2: *mut ::std::os::raw::c_void,
2552 oldKey: ::std::os::raw::c_uint,
2553 newKey: ::std::os::raw::c_uint,
2554 ),
2555 >,
2556 pub xTruncate: ::std::option::Option<
2557 unsafe extern "C" fn(arg1: *mut sqlite3_pcache, iLimit: ::std::os::raw::c_uint),
2558 >,
2559 pub xDestroy: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_pcache)>,
2560}
2561#[test]
2562fn bindgen_test_layout_sqlite3_pcache_methods() {
2563 const UNINIT: ::std::mem::MaybeUninit<sqlite3_pcache_methods> =
2564 ::std::mem::MaybeUninit::uninit();
2565 let ptr = UNINIT.as_ptr();
2566 assert_eq!(
2567 ::std::mem::size_of::<sqlite3_pcache_methods>(),
2568 88usize,
2569 concat!("Size of: ", stringify!(sqlite3_pcache_methods))
2570 );
2571 assert_eq!(
2572 ::std::mem::align_of::<sqlite3_pcache_methods>(),
2573 8usize,
2574 concat!("Alignment of ", stringify!(sqlite3_pcache_methods))
2575 );
2576 assert_eq!(
2577 unsafe { ::std::ptr::addr_of!((*ptr).pArg) as usize - ptr as usize },
2578 0usize,
2579 concat!(
2580 "Offset of field: ",
2581 stringify!(sqlite3_pcache_methods),
2582 "::",
2583 stringify!(pArg)
2584 )
2585 );
2586 assert_eq!(
2587 unsafe { ::std::ptr::addr_of!((*ptr).xInit) as usize - ptr as usize },
2588 8usize,
2589 concat!(
2590 "Offset of field: ",
2591 stringify!(sqlite3_pcache_methods),
2592 "::",
2593 stringify!(xInit)
2594 )
2595 );
2596 assert_eq!(
2597 unsafe { ::std::ptr::addr_of!((*ptr).xShutdown) as usize - ptr as usize },
2598 16usize,
2599 concat!(
2600 "Offset of field: ",
2601 stringify!(sqlite3_pcache_methods),
2602 "::",
2603 stringify!(xShutdown)
2604 )
2605 );
2606 assert_eq!(
2607 unsafe { ::std::ptr::addr_of!((*ptr).xCreate) as usize - ptr as usize },
2608 24usize,
2609 concat!(
2610 "Offset of field: ",
2611 stringify!(sqlite3_pcache_methods),
2612 "::",
2613 stringify!(xCreate)
2614 )
2615 );
2616 assert_eq!(
2617 unsafe { ::std::ptr::addr_of!((*ptr).xCachesize) as usize - ptr as usize },
2618 32usize,
2619 concat!(
2620 "Offset of field: ",
2621 stringify!(sqlite3_pcache_methods),
2622 "::",
2623 stringify!(xCachesize)
2624 )
2625 );
2626 assert_eq!(
2627 unsafe { ::std::ptr::addr_of!((*ptr).xPagecount) as usize - ptr as usize },
2628 40usize,
2629 concat!(
2630 "Offset of field: ",
2631 stringify!(sqlite3_pcache_methods),
2632 "::",
2633 stringify!(xPagecount)
2634 )
2635 );
2636 assert_eq!(
2637 unsafe { ::std::ptr::addr_of!((*ptr).xFetch) as usize - ptr as usize },
2638 48usize,
2639 concat!(
2640 "Offset of field: ",
2641 stringify!(sqlite3_pcache_methods),
2642 "::",
2643 stringify!(xFetch)
2644 )
2645 );
2646 assert_eq!(
2647 unsafe { ::std::ptr::addr_of!((*ptr).xUnpin) as usize - ptr as usize },
2648 56usize,
2649 concat!(
2650 "Offset of field: ",
2651 stringify!(sqlite3_pcache_methods),
2652 "::",
2653 stringify!(xUnpin)
2654 )
2655 );
2656 assert_eq!(
2657 unsafe { ::std::ptr::addr_of!((*ptr).xRekey) as usize - ptr as usize },
2658 64usize,
2659 concat!(
2660 "Offset of field: ",
2661 stringify!(sqlite3_pcache_methods),
2662 "::",
2663 stringify!(xRekey)
2664 )
2665 );
2666 assert_eq!(
2667 unsafe { ::std::ptr::addr_of!((*ptr).xTruncate) as usize - ptr as usize },
2668 72usize,
2669 concat!(
2670 "Offset of field: ",
2671 stringify!(sqlite3_pcache_methods),
2672 "::",
2673 stringify!(xTruncate)
2674 )
2675 );
2676 assert_eq!(
2677 unsafe { ::std::ptr::addr_of!((*ptr).xDestroy) as usize - ptr as usize },
2678 80usize,
2679 concat!(
2680 "Offset of field: ",
2681 stringify!(sqlite3_pcache_methods),
2682 "::",
2683 stringify!(xDestroy)
2684 )
2685 );
2686}
2687#[repr(C)]
2688#[derive(Debug, Copy, Clone)]
2689pub struct sqlite3_backup {
2690 _unused: [u8; 0],
2691}
2692#[repr(C)]
2693#[derive(Debug, Copy, Clone)]
2694pub struct sqlite3_snapshot {
2695 pub hidden: [::std::os::raw::c_uchar; 48usize],
2696}
2697#[test]
2698fn bindgen_test_layout_sqlite3_snapshot() {
2699 const UNINIT: ::std::mem::MaybeUninit<sqlite3_snapshot> = ::std::mem::MaybeUninit::uninit();
2700 let ptr = UNINIT.as_ptr();
2701 assert_eq!(
2702 ::std::mem::size_of::<sqlite3_snapshot>(),
2703 48usize,
2704 concat!("Size of: ", stringify!(sqlite3_snapshot))
2705 );
2706 assert_eq!(
2707 ::std::mem::align_of::<sqlite3_snapshot>(),
2708 1usize,
2709 concat!("Alignment of ", stringify!(sqlite3_snapshot))
2710 );
2711 assert_eq!(
2712 unsafe { ::std::ptr::addr_of!((*ptr).hidden) as usize - ptr as usize },
2713 0usize,
2714 concat!(
2715 "Offset of field: ",
2716 stringify!(sqlite3_snapshot),
2717 "::",
2718 stringify!(hidden)
2719 )
2720 );
2721}
2722pub type sqlite3_rtree_dbl = f64;
2723#[repr(C)]
2724#[derive(Debug, Copy, Clone)]
2725pub struct sqlite3_rtree_geometry {
2726 pub pContext: *mut ::std::os::raw::c_void,
2727 pub nParam: ::std::os::raw::c_int,
2728 pub aParam: *mut sqlite3_rtree_dbl,
2729 pub pUser: *mut ::std::os::raw::c_void,
2730 pub xDelUser: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
2731}
2732#[test]
2733fn bindgen_test_layout_sqlite3_rtree_geometry() {
2734 const UNINIT: ::std::mem::MaybeUninit<sqlite3_rtree_geometry> =
2735 ::std::mem::MaybeUninit::uninit();
2736 let ptr = UNINIT.as_ptr();
2737 assert_eq!(
2738 ::std::mem::size_of::<sqlite3_rtree_geometry>(),
2739 40usize,
2740 concat!("Size of: ", stringify!(sqlite3_rtree_geometry))
2741 );
2742 assert_eq!(
2743 ::std::mem::align_of::<sqlite3_rtree_geometry>(),
2744 8usize,
2745 concat!("Alignment of ", stringify!(sqlite3_rtree_geometry))
2746 );
2747 assert_eq!(
2748 unsafe { ::std::ptr::addr_of!((*ptr).pContext) as usize - ptr as usize },
2749 0usize,
2750 concat!(
2751 "Offset of field: ",
2752 stringify!(sqlite3_rtree_geometry),
2753 "::",
2754 stringify!(pContext)
2755 )
2756 );
2757 assert_eq!(
2758 unsafe { ::std::ptr::addr_of!((*ptr).nParam) as usize - ptr as usize },
2759 8usize,
2760 concat!(
2761 "Offset of field: ",
2762 stringify!(sqlite3_rtree_geometry),
2763 "::",
2764 stringify!(nParam)
2765 )
2766 );
2767 assert_eq!(
2768 unsafe { ::std::ptr::addr_of!((*ptr).aParam) as usize - ptr as usize },
2769 16usize,
2770 concat!(
2771 "Offset of field: ",
2772 stringify!(sqlite3_rtree_geometry),
2773 "::",
2774 stringify!(aParam)
2775 )
2776 );
2777 assert_eq!(
2778 unsafe { ::std::ptr::addr_of!((*ptr).pUser) as usize - ptr as usize },
2779 24usize,
2780 concat!(
2781 "Offset of field: ",
2782 stringify!(sqlite3_rtree_geometry),
2783 "::",
2784 stringify!(pUser)
2785 )
2786 );
2787 assert_eq!(
2788 unsafe { ::std::ptr::addr_of!((*ptr).xDelUser) as usize - ptr as usize },
2789 32usize,
2790 concat!(
2791 "Offset of field: ",
2792 stringify!(sqlite3_rtree_geometry),
2793 "::",
2794 stringify!(xDelUser)
2795 )
2796 );
2797}
2798#[repr(C)]
2799#[derive(Debug, Copy, Clone)]
2800pub struct sqlite3_rtree_query_info {
2801 pub pContext: *mut ::std::os::raw::c_void,
2802 pub nParam: ::std::os::raw::c_int,
2803 pub aParam: *mut sqlite3_rtree_dbl,
2804 pub pUser: *mut ::std::os::raw::c_void,
2805 pub xDelUser: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
2806 pub aCoord: *mut sqlite3_rtree_dbl,
2807 pub anQueue: *mut ::std::os::raw::c_uint,
2808 pub nCoord: ::std::os::raw::c_int,
2809 pub iLevel: ::std::os::raw::c_int,
2810 pub mxLevel: ::std::os::raw::c_int,
2811 pub iRowid: sqlite3_int64,
2812 pub rParentScore: sqlite3_rtree_dbl,
2813 pub eParentWithin: ::std::os::raw::c_int,
2814 pub eWithin: ::std::os::raw::c_int,
2815 pub rScore: sqlite3_rtree_dbl,
2816 pub apSqlParam: *mut *mut sqlite3_value,
2817}
2818#[test]
2819fn bindgen_test_layout_sqlite3_rtree_query_info() {
2820 const UNINIT: ::std::mem::MaybeUninit<sqlite3_rtree_query_info> =
2821 ::std::mem::MaybeUninit::uninit();
2822 let ptr = UNINIT.as_ptr();
2823 assert_eq!(
2824 ::std::mem::size_of::<sqlite3_rtree_query_info>(),
2825 112usize,
2826 concat!("Size of: ", stringify!(sqlite3_rtree_query_info))
2827 );
2828 assert_eq!(
2829 ::std::mem::align_of::<sqlite3_rtree_query_info>(),
2830 8usize,
2831 concat!("Alignment of ", stringify!(sqlite3_rtree_query_info))
2832 );
2833 assert_eq!(
2834 unsafe { ::std::ptr::addr_of!((*ptr).pContext) as usize - ptr as usize },
2835 0usize,
2836 concat!(
2837 "Offset of field: ",
2838 stringify!(sqlite3_rtree_query_info),
2839 "::",
2840 stringify!(pContext)
2841 )
2842 );
2843 assert_eq!(
2844 unsafe { ::std::ptr::addr_of!((*ptr).nParam) as usize - ptr as usize },
2845 8usize,
2846 concat!(
2847 "Offset of field: ",
2848 stringify!(sqlite3_rtree_query_info),
2849 "::",
2850 stringify!(nParam)
2851 )
2852 );
2853 assert_eq!(
2854 unsafe { ::std::ptr::addr_of!((*ptr).aParam) as usize - ptr as usize },
2855 16usize,
2856 concat!(
2857 "Offset of field: ",
2858 stringify!(sqlite3_rtree_query_info),
2859 "::",
2860 stringify!(aParam)
2861 )
2862 );
2863 assert_eq!(
2864 unsafe { ::std::ptr::addr_of!((*ptr).pUser) as usize - ptr as usize },
2865 24usize,
2866 concat!(
2867 "Offset of field: ",
2868 stringify!(sqlite3_rtree_query_info),
2869 "::",
2870 stringify!(pUser)
2871 )
2872 );
2873 assert_eq!(
2874 unsafe { ::std::ptr::addr_of!((*ptr).xDelUser) as usize - ptr as usize },
2875 32usize,
2876 concat!(
2877 "Offset of field: ",
2878 stringify!(sqlite3_rtree_query_info),
2879 "::",
2880 stringify!(xDelUser)
2881 )
2882 );
2883 assert_eq!(
2884 unsafe { ::std::ptr::addr_of!((*ptr).aCoord) as usize - ptr as usize },
2885 40usize,
2886 concat!(
2887 "Offset of field: ",
2888 stringify!(sqlite3_rtree_query_info),
2889 "::",
2890 stringify!(aCoord)
2891 )
2892 );
2893 assert_eq!(
2894 unsafe { ::std::ptr::addr_of!((*ptr).anQueue) as usize - ptr as usize },
2895 48usize,
2896 concat!(
2897 "Offset of field: ",
2898 stringify!(sqlite3_rtree_query_info),
2899 "::",
2900 stringify!(anQueue)
2901 )
2902 );
2903 assert_eq!(
2904 unsafe { ::std::ptr::addr_of!((*ptr).nCoord) as usize - ptr as usize },
2905 56usize,
2906 concat!(
2907 "Offset of field: ",
2908 stringify!(sqlite3_rtree_query_info),
2909 "::",
2910 stringify!(nCoord)
2911 )
2912 );
2913 assert_eq!(
2914 unsafe { ::std::ptr::addr_of!((*ptr).iLevel) as usize - ptr as usize },
2915 60usize,
2916 concat!(
2917 "Offset of field: ",
2918 stringify!(sqlite3_rtree_query_info),
2919 "::",
2920 stringify!(iLevel)
2921 )
2922 );
2923 assert_eq!(
2924 unsafe { ::std::ptr::addr_of!((*ptr).mxLevel) as usize - ptr as usize },
2925 64usize,
2926 concat!(
2927 "Offset of field: ",
2928 stringify!(sqlite3_rtree_query_info),
2929 "::",
2930 stringify!(mxLevel)
2931 )
2932 );
2933 assert_eq!(
2934 unsafe { ::std::ptr::addr_of!((*ptr).iRowid) as usize - ptr as usize },
2935 72usize,
2936 concat!(
2937 "Offset of field: ",
2938 stringify!(sqlite3_rtree_query_info),
2939 "::",
2940 stringify!(iRowid)
2941 )
2942 );
2943 assert_eq!(
2944 unsafe { ::std::ptr::addr_of!((*ptr).rParentScore) as usize - ptr as usize },
2945 80usize,
2946 concat!(
2947 "Offset of field: ",
2948 stringify!(sqlite3_rtree_query_info),
2949 "::",
2950 stringify!(rParentScore)
2951 )
2952 );
2953 assert_eq!(
2954 unsafe { ::std::ptr::addr_of!((*ptr).eParentWithin) as usize - ptr as usize },
2955 88usize,
2956 concat!(
2957 "Offset of field: ",
2958 stringify!(sqlite3_rtree_query_info),
2959 "::",
2960 stringify!(eParentWithin)
2961 )
2962 );
2963 assert_eq!(
2964 unsafe { ::std::ptr::addr_of!((*ptr).eWithin) as usize - ptr as usize },
2965 92usize,
2966 concat!(
2967 "Offset of field: ",
2968 stringify!(sqlite3_rtree_query_info),
2969 "::",
2970 stringify!(eWithin)
2971 )
2972 );
2973 assert_eq!(
2974 unsafe { ::std::ptr::addr_of!((*ptr).rScore) as usize - ptr as usize },
2975 96usize,
2976 concat!(
2977 "Offset of field: ",
2978 stringify!(sqlite3_rtree_query_info),
2979 "::",
2980 stringify!(rScore)
2981 )
2982 );
2983 assert_eq!(
2984 unsafe { ::std::ptr::addr_of!((*ptr).apSqlParam) as usize - ptr as usize },
2985 104usize,
2986 concat!(
2987 "Offset of field: ",
2988 stringify!(sqlite3_rtree_query_info),
2989 "::",
2990 stringify!(apSqlParam)
2991 )
2992 );
2993}
2994#[repr(C)]
2995#[derive(Debug, Copy, Clone)]
2996pub struct Fts5Context {
2997 _unused: [u8; 0],
2998}
2999pub type fts5_extension_function = ::std::option::Option<
3000 unsafe extern "C" fn(
3001 pApi: *const Fts5ExtensionApi,
3002 pFts: *mut Fts5Context,
3003 pCtx: *mut sqlite3_context,
3004 nVal: ::std::os::raw::c_int,
3005 apVal: *mut *mut sqlite3_value,
3006 ),
3007>;
3008#[repr(C)]
3009#[derive(Debug, Copy, Clone)]
3010pub struct Fts5PhraseIter {
3011 pub a: *const ::std::os::raw::c_uchar,
3012 pub b: *const ::std::os::raw::c_uchar,
3013}
3014#[test]
3015fn bindgen_test_layout_Fts5PhraseIter() {
3016 const UNINIT: ::std::mem::MaybeUninit<Fts5PhraseIter> = ::std::mem::MaybeUninit::uninit();
3017 let ptr = UNINIT.as_ptr();
3018 assert_eq!(
3019 ::std::mem::size_of::<Fts5PhraseIter>(),
3020 16usize,
3021 concat!("Size of: ", stringify!(Fts5PhraseIter))
3022 );
3023 assert_eq!(
3024 ::std::mem::align_of::<Fts5PhraseIter>(),
3025 8usize,
3026 concat!("Alignment of ", stringify!(Fts5PhraseIter))
3027 );
3028 assert_eq!(
3029 unsafe { ::std::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
3030 0usize,
3031 concat!(
3032 "Offset of field: ",
3033 stringify!(Fts5PhraseIter),
3034 "::",
3035 stringify!(a)
3036 )
3037 );
3038 assert_eq!(
3039 unsafe { ::std::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
3040 8usize,
3041 concat!(
3042 "Offset of field: ",
3043 stringify!(Fts5PhraseIter),
3044 "::",
3045 stringify!(b)
3046 )
3047 );
3048}
3049#[repr(C)]
3050#[derive(Debug, Copy, Clone)]
3051pub struct Fts5ExtensionApi {
3052 pub iVersion: ::std::os::raw::c_int,
3053 pub xUserData: ::std::option::Option<
3054 unsafe extern "C" fn(arg1: *mut Fts5Context) -> *mut ::std::os::raw::c_void,
3055 >,
3056 pub xColumnCount: ::std::option::Option<
3057 unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int,
3058 >,
3059 pub xRowCount: ::std::option::Option<
3060 unsafe extern "C" fn(
3061 arg1: *mut Fts5Context,
3062 pnRow: *mut sqlite3_int64,
3063 ) -> ::std::os::raw::c_int,
3064 >,
3065 pub xColumnTotalSize: ::std::option::Option<
3066 unsafe extern "C" fn(
3067 arg1: *mut Fts5Context,
3068 iCol: ::std::os::raw::c_int,
3069 pnToken: *mut sqlite3_int64,
3070 ) -> ::std::os::raw::c_int,
3071 >,
3072 pub xTokenize: ::std::option::Option<
3073 unsafe extern "C" fn(
3074 arg1: *mut Fts5Context,
3075 pText: *const ::std::os::raw::c_char,
3076 nText: ::std::os::raw::c_int,
3077 pCtx: *mut ::std::os::raw::c_void,
3078 xToken: ::std::option::Option<
3079 unsafe extern "C" fn(
3080 arg1: *mut ::std::os::raw::c_void,
3081 arg2: ::std::os::raw::c_int,
3082 arg3: *const ::std::os::raw::c_char,
3083 arg4: ::std::os::raw::c_int,
3084 arg5: ::std::os::raw::c_int,
3085 arg6: ::std::os::raw::c_int,
3086 ) -> ::std::os::raw::c_int,
3087 >,
3088 ) -> ::std::os::raw::c_int,
3089 >,
3090 pub xPhraseCount: ::std::option::Option<
3091 unsafe extern "C" fn(arg1: *mut Fts5Context) -> ::std::os::raw::c_int,
3092 >,
3093 pub xPhraseSize: ::std::option::Option<
3094 unsafe extern "C" fn(
3095 arg1: *mut Fts5Context,
3096 iPhrase: ::std::os::raw::c_int,
3097 ) -> ::std::os::raw::c_int,
3098 >,
3099 pub xInstCount: ::std::option::Option<
3100 unsafe extern "C" fn(
3101 arg1: *mut Fts5Context,
3102 pnInst: *mut ::std::os::raw::c_int,
3103 ) -> ::std::os::raw::c_int,
3104 >,
3105 pub xInst: ::std::option::Option<
3106 unsafe extern "C" fn(
3107 arg1: *mut Fts5Context,
3108 iIdx: ::std::os::raw::c_int,
3109 piPhrase: *mut ::std::os::raw::c_int,
3110 piCol: *mut ::std::os::raw::c_int,
3111 piOff: *mut ::std::os::raw::c_int,
3112 ) -> ::std::os::raw::c_int,
3113 >,
3114 pub xRowid:
3115 ::std::option::Option<unsafe extern "C" fn(arg1: *mut Fts5Context) -> sqlite3_int64>,
3116 pub xColumnText: ::std::option::Option<
3117 unsafe extern "C" fn(
3118 arg1: *mut Fts5Context,
3119 iCol: ::std::os::raw::c_int,
3120 pz: *mut *const ::std::os::raw::c_char,
3121 pn: *mut ::std::os::raw::c_int,
3122 ) -> ::std::os::raw::c_int,
3123 >,
3124 pub xColumnSize: ::std::option::Option<
3125 unsafe extern "C" fn(
3126 arg1: *mut Fts5Context,
3127 iCol: ::std::os::raw::c_int,
3128 pnToken: *mut ::std::os::raw::c_int,
3129 ) -> ::std::os::raw::c_int,
3130 >,
3131 pub xQueryPhrase: ::std::option::Option<
3132 unsafe extern "C" fn(
3133 arg1: *mut Fts5Context,
3134 iPhrase: ::std::os::raw::c_int,
3135 pUserData: *mut ::std::os::raw::c_void,
3136 arg2: ::std::option::Option<
3137 unsafe extern "C" fn(
3138 arg1: *const Fts5ExtensionApi,
3139 arg2: *mut Fts5Context,
3140 arg3: *mut ::std::os::raw::c_void,
3141 ) -> ::std::os::raw::c_int,
3142 >,
3143 ) -> ::std::os::raw::c_int,
3144 >,
3145 pub xSetAuxdata: ::std::option::Option<
3146 unsafe extern "C" fn(
3147 arg1: *mut Fts5Context,
3148 pAux: *mut ::std::os::raw::c_void,
3149 xDelete: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
3150 ) -> ::std::os::raw::c_int,
3151 >,
3152 pub xGetAuxdata: ::std::option::Option<
3153 unsafe extern "C" fn(
3154 arg1: *mut Fts5Context,
3155 bClear: ::std::os::raw::c_int,
3156 ) -> *mut ::std::os::raw::c_void,
3157 >,
3158 pub xPhraseFirst: ::std::option::Option<
3159 unsafe extern "C" fn(
3160 arg1: *mut Fts5Context,
3161 iPhrase: ::std::os::raw::c_int,
3162 arg2: *mut Fts5PhraseIter,
3163 arg3: *mut ::std::os::raw::c_int,
3164 arg4: *mut ::std::os::raw::c_int,
3165 ) -> ::std::os::raw::c_int,
3166 >,
3167 pub xPhraseNext: ::std::option::Option<
3168 unsafe extern "C" fn(
3169 arg1: *mut Fts5Context,
3170 arg2: *mut Fts5PhraseIter,
3171 piCol: *mut ::std::os::raw::c_int,
3172 piOff: *mut ::std::os::raw::c_int,
3173 ),
3174 >,
3175 pub xPhraseFirstColumn: ::std::option::Option<
3176 unsafe extern "C" fn(
3177 arg1: *mut Fts5Context,
3178 iPhrase: ::std::os::raw::c_int,
3179 arg2: *mut Fts5PhraseIter,
3180 arg3: *mut ::std::os::raw::c_int,
3181 ) -> ::std::os::raw::c_int,
3182 >,
3183 pub xPhraseNextColumn: ::std::option::Option<
3184 unsafe extern "C" fn(
3185 arg1: *mut Fts5Context,
3186 arg2: *mut Fts5PhraseIter,
3187 piCol: *mut ::std::os::raw::c_int,
3188 ),
3189 >,
3190}
3191#[test]
3192fn bindgen_test_layout_Fts5ExtensionApi() {
3193 const UNINIT: ::std::mem::MaybeUninit<Fts5ExtensionApi> = ::std::mem::MaybeUninit::uninit();
3194 let ptr = UNINIT.as_ptr();
3195 assert_eq!(
3196 ::std::mem::size_of::<Fts5ExtensionApi>(),
3197 160usize,
3198 concat!("Size of: ", stringify!(Fts5ExtensionApi))
3199 );
3200 assert_eq!(
3201 ::std::mem::align_of::<Fts5ExtensionApi>(),
3202 8usize,
3203 concat!("Alignment of ", stringify!(Fts5ExtensionApi))
3204 );
3205 assert_eq!(
3206 unsafe { ::std::ptr::addr_of!((*ptr).iVersion) as usize - ptr as usize },
3207 0usize,
3208 concat!(
3209 "Offset of field: ",
3210 stringify!(Fts5ExtensionApi),
3211 "::",
3212 stringify!(iVersion)
3213 )
3214 );
3215 assert_eq!(
3216 unsafe { ::std::ptr::addr_of!((*ptr).xUserData) as usize - ptr as usize },
3217 8usize,
3218 concat!(
3219 "Offset of field: ",
3220 stringify!(Fts5ExtensionApi),
3221 "::",
3222 stringify!(xUserData)
3223 )
3224 );
3225 assert_eq!(
3226 unsafe { ::std::ptr::addr_of!((*ptr).xColumnCount) as usize - ptr as usize },
3227 16usize,
3228 concat!(
3229 "Offset of field: ",
3230 stringify!(Fts5ExtensionApi),
3231 "::",
3232 stringify!(xColumnCount)
3233 )
3234 );
3235 assert_eq!(
3236 unsafe { ::std::ptr::addr_of!((*ptr).xRowCount) as usize - ptr as usize },
3237 24usize,
3238 concat!(
3239 "Offset of field: ",
3240 stringify!(Fts5ExtensionApi),
3241 "::",
3242 stringify!(xRowCount)
3243 )
3244 );
3245 assert_eq!(
3246 unsafe { ::std::ptr::addr_of!((*ptr).xColumnTotalSize) as usize - ptr as usize },
3247 32usize,
3248 concat!(
3249 "Offset of field: ",
3250 stringify!(Fts5ExtensionApi),
3251 "::",
3252 stringify!(xColumnTotalSize)
3253 )
3254 );
3255 assert_eq!(
3256 unsafe { ::std::ptr::addr_of!((*ptr).xTokenize) as usize - ptr as usize },
3257 40usize,
3258 concat!(
3259 "Offset of field: ",
3260 stringify!(Fts5ExtensionApi),
3261 "::",
3262 stringify!(xTokenize)
3263 )
3264 );
3265 assert_eq!(
3266 unsafe { ::std::ptr::addr_of!((*ptr).xPhraseCount) as usize - ptr as usize },
3267 48usize,
3268 concat!(
3269 "Offset of field: ",
3270 stringify!(Fts5ExtensionApi),
3271 "::",
3272 stringify!(xPhraseCount)
3273 )
3274 );
3275 assert_eq!(
3276 unsafe { ::std::ptr::addr_of!((*ptr).xPhraseSize) as usize - ptr as usize },
3277 56usize,
3278 concat!(
3279 "Offset of field: ",
3280 stringify!(Fts5ExtensionApi),
3281 "::",
3282 stringify!(xPhraseSize)
3283 )
3284 );
3285 assert_eq!(
3286 unsafe { ::std::ptr::addr_of!((*ptr).xInstCount) as usize - ptr as usize },
3287 64usize,
3288 concat!(
3289 "Offset of field: ",
3290 stringify!(Fts5ExtensionApi),
3291 "::",
3292 stringify!(xInstCount)
3293 )
3294 );
3295 assert_eq!(
3296 unsafe { ::std::ptr::addr_of!((*ptr).xInst) as usize - ptr as usize },
3297 72usize,
3298 concat!(
3299 "Offset of field: ",
3300 stringify!(Fts5ExtensionApi),
3301 "::",
3302 stringify!(xInst)
3303 )
3304 );
3305 assert_eq!(
3306 unsafe { ::std::ptr::addr_of!((*ptr).xRowid) as usize - ptr as usize },
3307 80usize,
3308 concat!(
3309 "Offset of field: ",
3310 stringify!(Fts5ExtensionApi),
3311 "::",
3312 stringify!(xRowid)
3313 )
3314 );
3315 assert_eq!(
3316 unsafe { ::std::ptr::addr_of!((*ptr).xColumnText) as usize - ptr as usize },
3317 88usize,
3318 concat!(
3319 "Offset of field: ",
3320 stringify!(Fts5ExtensionApi),
3321 "::",
3322 stringify!(xColumnText)
3323 )
3324 );
3325 assert_eq!(
3326 unsafe { ::std::ptr::addr_of!((*ptr).xColumnSize) as usize - ptr as usize },
3327 96usize,
3328 concat!(
3329 "Offset of field: ",
3330 stringify!(Fts5ExtensionApi),
3331 "::",
3332 stringify!(xColumnSize)
3333 )
3334 );
3335 assert_eq!(
3336 unsafe { ::std::ptr::addr_of!((*ptr).xQueryPhrase) as usize - ptr as usize },
3337 104usize,
3338 concat!(
3339 "Offset of field: ",
3340 stringify!(Fts5ExtensionApi),
3341 "::",
3342 stringify!(xQueryPhrase)
3343 )
3344 );
3345 assert_eq!(
3346 unsafe { ::std::ptr::addr_of!((*ptr).xSetAuxdata) as usize - ptr as usize },
3347 112usize,
3348 concat!(
3349 "Offset of field: ",
3350 stringify!(Fts5ExtensionApi),
3351 "::",
3352 stringify!(xSetAuxdata)
3353 )
3354 );
3355 assert_eq!(
3356 unsafe { ::std::ptr::addr_of!((*ptr).xGetAuxdata) as usize - ptr as usize },
3357 120usize,
3358 concat!(
3359 "Offset of field: ",
3360 stringify!(Fts5ExtensionApi),
3361 "::",
3362 stringify!(xGetAuxdata)
3363 )
3364 );
3365 assert_eq!(
3366 unsafe { ::std::ptr::addr_of!((*ptr).xPhraseFirst) as usize - ptr as usize },
3367 128usize,
3368 concat!(
3369 "Offset of field: ",
3370 stringify!(Fts5ExtensionApi),
3371 "::",
3372 stringify!(xPhraseFirst)
3373 )
3374 );
3375 assert_eq!(
3376 unsafe { ::std::ptr::addr_of!((*ptr).xPhraseNext) as usize - ptr as usize },
3377 136usize,
3378 concat!(
3379 "Offset of field: ",
3380 stringify!(Fts5ExtensionApi),
3381 "::",
3382 stringify!(xPhraseNext)
3383 )
3384 );
3385 assert_eq!(
3386 unsafe { ::std::ptr::addr_of!((*ptr).xPhraseFirstColumn) as usize - ptr as usize },
3387 144usize,
3388 concat!(
3389 "Offset of field: ",
3390 stringify!(Fts5ExtensionApi),
3391 "::",
3392 stringify!(xPhraseFirstColumn)
3393 )
3394 );
3395 assert_eq!(
3396 unsafe { ::std::ptr::addr_of!((*ptr).xPhraseNextColumn) as usize - ptr as usize },
3397 152usize,
3398 concat!(
3399 "Offset of field: ",
3400 stringify!(Fts5ExtensionApi),
3401 "::",
3402 stringify!(xPhraseNextColumn)
3403 )
3404 );
3405}
3406#[repr(C)]
3407#[derive(Debug, Copy, Clone)]
3408pub struct Fts5Tokenizer {
3409 _unused: [u8; 0],
3410}
3411#[repr(C)]
3412#[derive(Debug, Copy, Clone)]
3413pub struct fts5_tokenizer {
3414 pub xCreate: ::std::option::Option<
3415 unsafe extern "C" fn(
3416 arg1: *mut ::std::os::raw::c_void,
3417 azArg: *mut *const ::std::os::raw::c_char,
3418 nArg: ::std::os::raw::c_int,
3419 ppOut: *mut *mut Fts5Tokenizer,
3420 ) -> ::std::os::raw::c_int,
3421 >,
3422 pub xDelete: ::std::option::Option<unsafe extern "C" fn(arg1: *mut Fts5Tokenizer)>,
3423 pub xTokenize: ::std::option::Option<
3424 unsafe extern "C" fn(
3425 arg1: *mut Fts5Tokenizer,
3426 pCtx: *mut ::std::os::raw::c_void,
3427 flags: ::std::os::raw::c_int,
3428 pText: *const ::std::os::raw::c_char,
3429 nText: ::std::os::raw::c_int,
3430 xToken: ::std::option::Option<
3431 unsafe extern "C" fn(
3432 pCtx: *mut ::std::os::raw::c_void,
3433 tflags: ::std::os::raw::c_int,
3434 pToken: *const ::std::os::raw::c_char,
3435 nToken: ::std::os::raw::c_int,
3436 iStart: ::std::os::raw::c_int,
3437 iEnd: ::std::os::raw::c_int,
3438 ) -> ::std::os::raw::c_int,
3439 >,
3440 ) -> ::std::os::raw::c_int,
3441 >,
3442}
3443#[test]
3444fn bindgen_test_layout_fts5_tokenizer() {
3445 const UNINIT: ::std::mem::MaybeUninit<fts5_tokenizer> = ::std::mem::MaybeUninit::uninit();
3446 let ptr = UNINIT.as_ptr();
3447 assert_eq!(
3448 ::std::mem::size_of::<fts5_tokenizer>(),
3449 24usize,
3450 concat!("Size of: ", stringify!(fts5_tokenizer))
3451 );
3452 assert_eq!(
3453 ::std::mem::align_of::<fts5_tokenizer>(),
3454 8usize,
3455 concat!("Alignment of ", stringify!(fts5_tokenizer))
3456 );
3457 assert_eq!(
3458 unsafe { ::std::ptr::addr_of!((*ptr).xCreate) as usize - ptr as usize },
3459 0usize,
3460 concat!(
3461 "Offset of field: ",
3462 stringify!(fts5_tokenizer),
3463 "::",
3464 stringify!(xCreate)
3465 )
3466 );
3467 assert_eq!(
3468 unsafe { ::std::ptr::addr_of!((*ptr).xDelete) as usize - ptr as usize },
3469 8usize,
3470 concat!(
3471 "Offset of field: ",
3472 stringify!(fts5_tokenizer),
3473 "::",
3474 stringify!(xDelete)
3475 )
3476 );
3477 assert_eq!(
3478 unsafe { ::std::ptr::addr_of!((*ptr).xTokenize) as usize - ptr as usize },
3479 16usize,
3480 concat!(
3481 "Offset of field: ",
3482 stringify!(fts5_tokenizer),
3483 "::",
3484 stringify!(xTokenize)
3485 )
3486 );
3487}
3488#[repr(C)]
3489#[derive(Debug, Copy, Clone)]
3490pub struct fts5_api {
3491 pub iVersion: ::std::os::raw::c_int,
3492 pub xCreateTokenizer: ::std::option::Option<
3493 unsafe extern "C" fn(
3494 pApi: *mut fts5_api,
3495 zName: *const ::std::os::raw::c_char,
3496 pContext: *mut ::std::os::raw::c_void,
3497 pTokenizer: *mut fts5_tokenizer,
3498 xDestroy: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
3499 ) -> ::std::os::raw::c_int,
3500 >,
3501 pub xFindTokenizer: ::std::option::Option<
3502 unsafe extern "C" fn(
3503 pApi: *mut fts5_api,
3504 zName: *const ::std::os::raw::c_char,
3505 ppContext: *mut *mut ::std::os::raw::c_void,
3506 pTokenizer: *mut fts5_tokenizer,
3507 ) -> ::std::os::raw::c_int,
3508 >,
3509 pub xCreateFunction: ::std::option::Option<
3510 unsafe extern "C" fn(
3511 pApi: *mut fts5_api,
3512 zName: *const ::std::os::raw::c_char,
3513 pContext: *mut ::std::os::raw::c_void,
3514 xFunction: fts5_extension_function,
3515 xDestroy: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
3516 ) -> ::std::os::raw::c_int,
3517 >,
3518}
3519#[test]
3520fn bindgen_test_layout_fts5_api() {
3521 const UNINIT: ::std::mem::MaybeUninit<fts5_api> = ::std::mem::MaybeUninit::uninit();
3522 let ptr = UNINIT.as_ptr();
3523 assert_eq!(
3524 ::std::mem::size_of::<fts5_api>(),
3525 32usize,
3526 concat!("Size of: ", stringify!(fts5_api))
3527 );
3528 assert_eq!(
3529 ::std::mem::align_of::<fts5_api>(),
3530 8usize,
3531 concat!("Alignment of ", stringify!(fts5_api))
3532 );
3533 assert_eq!(
3534 unsafe { ::std::ptr::addr_of!((*ptr).iVersion) as usize - ptr as usize },
3535 0usize,
3536 concat!(
3537 "Offset of field: ",
3538 stringify!(fts5_api),
3539 "::",
3540 stringify!(iVersion)
3541 )
3542 );
3543 assert_eq!(
3544 unsafe { ::std::ptr::addr_of!((*ptr).xCreateTokenizer) as usize - ptr as usize },
3545 8usize,
3546 concat!(
3547 "Offset of field: ",
3548 stringify!(fts5_api),
3549 "::",
3550 stringify!(xCreateTokenizer)
3551 )
3552 );
3553 assert_eq!(
3554 unsafe { ::std::ptr::addr_of!((*ptr).xFindTokenizer) as usize - ptr as usize },
3555 16usize,
3556 concat!(
3557 "Offset of field: ",
3558 stringify!(fts5_api),
3559 "::",
3560 stringify!(xFindTokenizer)
3561 )
3562 );
3563 assert_eq!(
3564 unsafe { ::std::ptr::addr_of!((*ptr).xCreateFunction) as usize - ptr as usize },
3565 24usize,
3566 concat!(
3567 "Offset of field: ",
3568 stringify!(fts5_api),
3569 "::",
3570 stringify!(xCreateFunction)
3571 )
3572 );
3573}
3574#[repr(C)]
3575#[derive(Debug, Copy, Clone)]
3576pub struct sqlite3_api_routines {
3577 pub aggregate_context: ::std::option::Option<
3578 unsafe extern "C" fn(
3579 arg1: *mut sqlite3_context,
3580 nBytes: ::std::os::raw::c_int,
3581 ) -> *mut ::std::os::raw::c_void,
3582 >,
3583 pub aggregate_count: ::std::option::Option<
3584 unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int,
3585 >,
3586 pub bind_blob: ::std::option::Option<
3587 unsafe extern "C" fn(
3588 arg1: *mut sqlite3_stmt,
3589 arg2: ::std::os::raw::c_int,
3590 arg3: *const ::std::os::raw::c_void,
3591 n: ::std::os::raw::c_int,
3592 arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
3593 ) -> ::std::os::raw::c_int,
3594 >,
3595 pub bind_double: ::std::option::Option<
3596 unsafe extern "C" fn(
3597 arg1: *mut sqlite3_stmt,
3598 arg2: ::std::os::raw::c_int,
3599 arg3: f64,
3600 ) -> ::std::os::raw::c_int,
3601 >,
3602 pub bind_int: ::std::option::Option<
3603 unsafe extern "C" fn(
3604 arg1: *mut sqlite3_stmt,
3605 arg2: ::std::os::raw::c_int,
3606 arg3: ::std::os::raw::c_int,
3607 ) -> ::std::os::raw::c_int,
3608 >,
3609 pub bind_int64: ::std::option::Option<
3610 unsafe extern "C" fn(
3611 arg1: *mut sqlite3_stmt,
3612 arg2: ::std::os::raw::c_int,
3613 arg3: sqlite_int64,
3614 ) -> ::std::os::raw::c_int,
3615 >,
3616 pub bind_null: ::std::option::Option<
3617 unsafe extern "C" fn(
3618 arg1: *mut sqlite3_stmt,
3619 arg2: ::std::os::raw::c_int,
3620 ) -> ::std::os::raw::c_int,
3621 >,
3622 pub bind_parameter_count: ::std::option::Option<
3623 unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
3624 >,
3625 pub bind_parameter_index: ::std::option::Option<
3626 unsafe extern "C" fn(
3627 arg1: *mut sqlite3_stmt,
3628 zName: *const ::std::os::raw::c_char,
3629 ) -> ::std::os::raw::c_int,
3630 >,
3631 pub bind_parameter_name: ::std::option::Option<
3632 unsafe extern "C" fn(
3633 arg1: *mut sqlite3_stmt,
3634 arg2: ::std::os::raw::c_int,
3635 ) -> *const ::std::os::raw::c_char,
3636 >,
3637 pub bind_text: ::std::option::Option<
3638 unsafe extern "C" fn(
3639 arg1: *mut sqlite3_stmt,
3640 arg2: ::std::os::raw::c_int,
3641 arg3: *const ::std::os::raw::c_char,
3642 n: ::std::os::raw::c_int,
3643 arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
3644 ) -> ::std::os::raw::c_int,
3645 >,
3646 pub bind_text16: ::std::option::Option<
3647 unsafe extern "C" fn(
3648 arg1: *mut sqlite3_stmt,
3649 arg2: ::std::os::raw::c_int,
3650 arg3: *const ::std::os::raw::c_void,
3651 arg4: ::std::os::raw::c_int,
3652 arg5: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
3653 ) -> ::std::os::raw::c_int,
3654 >,
3655 pub bind_value: ::std::option::Option<
3656 unsafe extern "C" fn(
3657 arg1: *mut sqlite3_stmt,
3658 arg2: ::std::os::raw::c_int,
3659 arg3: *const sqlite3_value,
3660 ) -> ::std::os::raw::c_int,
3661 >,
3662 pub busy_handler: ::std::option::Option<
3663 unsafe extern "C" fn(
3664 arg1: *mut sqlite3,
3665 arg2: ::std::option::Option<
3666 unsafe extern "C" fn(
3667 arg1: *mut ::std::os::raw::c_void,
3668 arg2: ::std::os::raw::c_int,
3669 ) -> ::std::os::raw::c_int,
3670 >,
3671 arg3: *mut ::std::os::raw::c_void,
3672 ) -> ::std::os::raw::c_int,
3673 >,
3674 pub busy_timeout: ::std::option::Option<
3675 unsafe extern "C" fn(
3676 arg1: *mut sqlite3,
3677 ms: ::std::os::raw::c_int,
3678 ) -> ::std::os::raw::c_int,
3679 >,
3680 pub changes:
3681 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
3682 pub close:
3683 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
3684 pub collation_needed: ::std::option::Option<
3685 unsafe extern "C" fn(
3686 arg1: *mut sqlite3,
3687 arg2: *mut ::std::os::raw::c_void,
3688 arg3: ::std::option::Option<
3689 unsafe extern "C" fn(
3690 arg1: *mut ::std::os::raw::c_void,
3691 arg2: *mut sqlite3,
3692 eTextRep: ::std::os::raw::c_int,
3693 arg3: *const ::std::os::raw::c_char,
3694 ),
3695 >,
3696 ) -> ::std::os::raw::c_int,
3697 >,
3698 pub collation_needed16: ::std::option::Option<
3699 unsafe extern "C" fn(
3700 arg1: *mut sqlite3,
3701 arg2: *mut ::std::os::raw::c_void,
3702 arg3: ::std::option::Option<
3703 unsafe extern "C" fn(
3704 arg1: *mut ::std::os::raw::c_void,
3705 arg2: *mut sqlite3,
3706 eTextRep: ::std::os::raw::c_int,
3707 arg3: *const ::std::os::raw::c_void,
3708 ),
3709 >,
3710 ) -> ::std::os::raw::c_int,
3711 >,
3712 pub column_blob: ::std::option::Option<
3713 unsafe extern "C" fn(
3714 arg1: *mut sqlite3_stmt,
3715 iCol: ::std::os::raw::c_int,
3716 ) -> *const ::std::os::raw::c_void,
3717 >,
3718 pub column_bytes: ::std::option::Option<
3719 unsafe extern "C" fn(
3720 arg1: *mut sqlite3_stmt,
3721 iCol: ::std::os::raw::c_int,
3722 ) -> ::std::os::raw::c_int,
3723 >,
3724 pub column_bytes16: ::std::option::Option<
3725 unsafe extern "C" fn(
3726 arg1: *mut sqlite3_stmt,
3727 iCol: ::std::os::raw::c_int,
3728 ) -> ::std::os::raw::c_int,
3729 >,
3730 pub column_count: ::std::option::Option<
3731 unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
3732 >,
3733 pub column_database_name: ::std::option::Option<
3734 unsafe extern "C" fn(
3735 arg1: *mut sqlite3_stmt,
3736 arg2: ::std::os::raw::c_int,
3737 ) -> *const ::std::os::raw::c_char,
3738 >,
3739 pub column_database_name16: ::std::option::Option<
3740 unsafe extern "C" fn(
3741 arg1: *mut sqlite3_stmt,
3742 arg2: ::std::os::raw::c_int,
3743 ) -> *const ::std::os::raw::c_void,
3744 >,
3745 pub column_decltype: ::std::option::Option<
3746 unsafe extern "C" fn(
3747 arg1: *mut sqlite3_stmt,
3748 i: ::std::os::raw::c_int,
3749 ) -> *const ::std::os::raw::c_char,
3750 >,
3751 pub column_decltype16: ::std::option::Option<
3752 unsafe extern "C" fn(
3753 arg1: *mut sqlite3_stmt,
3754 arg2: ::std::os::raw::c_int,
3755 ) -> *const ::std::os::raw::c_void,
3756 >,
3757 pub column_double: ::std::option::Option<
3758 unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> f64,
3759 >,
3760 pub column_int: ::std::option::Option<
3761 unsafe extern "C" fn(
3762 arg1: *mut sqlite3_stmt,
3763 iCol: ::std::os::raw::c_int,
3764 ) -> ::std::os::raw::c_int,
3765 >,
3766 pub column_int64: ::std::option::Option<
3767 unsafe extern "C" fn(arg1: *mut sqlite3_stmt, iCol: ::std::os::raw::c_int) -> sqlite_int64,
3768 >,
3769 pub column_name: ::std::option::Option<
3770 unsafe extern "C" fn(
3771 arg1: *mut sqlite3_stmt,
3772 arg2: ::std::os::raw::c_int,
3773 ) -> *const ::std::os::raw::c_char,
3774 >,
3775 pub column_name16: ::std::option::Option<
3776 unsafe extern "C" fn(
3777 arg1: *mut sqlite3_stmt,
3778 arg2: ::std::os::raw::c_int,
3779 ) -> *const ::std::os::raw::c_void,
3780 >,
3781 pub column_origin_name: ::std::option::Option<
3782 unsafe extern "C" fn(
3783 arg1: *mut sqlite3_stmt,
3784 arg2: ::std::os::raw::c_int,
3785 ) -> *const ::std::os::raw::c_char,
3786 >,
3787 pub column_origin_name16: ::std::option::Option<
3788 unsafe extern "C" fn(
3789 arg1: *mut sqlite3_stmt,
3790 arg2: ::std::os::raw::c_int,
3791 ) -> *const ::std::os::raw::c_void,
3792 >,
3793 pub column_table_name: ::std::option::Option<
3794 unsafe extern "C" fn(
3795 arg1: *mut sqlite3_stmt,
3796 arg2: ::std::os::raw::c_int,
3797 ) -> *const ::std::os::raw::c_char,
3798 >,
3799 pub column_table_name16: ::std::option::Option<
3800 unsafe extern "C" fn(
3801 arg1: *mut sqlite3_stmt,
3802 arg2: ::std::os::raw::c_int,
3803 ) -> *const ::std::os::raw::c_void,
3804 >,
3805 pub column_text: ::std::option::Option<
3806 unsafe extern "C" fn(
3807 arg1: *mut sqlite3_stmt,
3808 iCol: ::std::os::raw::c_int,
3809 ) -> *const ::std::os::raw::c_uchar,
3810 >,
3811 pub column_text16: ::std::option::Option<
3812 unsafe extern "C" fn(
3813 arg1: *mut sqlite3_stmt,
3814 iCol: ::std::os::raw::c_int,
3815 ) -> *const ::std::os::raw::c_void,
3816 >,
3817 pub column_type: ::std::option::Option<
3818 unsafe extern "C" fn(
3819 arg1: *mut sqlite3_stmt,
3820 iCol: ::std::os::raw::c_int,
3821 ) -> ::std::os::raw::c_int,
3822 >,
3823 pub column_value: ::std::option::Option<
3824 unsafe extern "C" fn(
3825 arg1: *mut sqlite3_stmt,
3826 iCol: ::std::os::raw::c_int,
3827 ) -> *mut sqlite3_value,
3828 >,
3829 pub commit_hook: ::std::option::Option<
3830 unsafe extern "C" fn(
3831 arg1: *mut sqlite3,
3832 arg2: ::std::option::Option<
3833 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
3834 >,
3835 arg3: *mut ::std::os::raw::c_void,
3836 ) -> *mut ::std::os::raw::c_void,
3837 >,
3838 pub complete: ::std::option::Option<
3839 unsafe extern "C" fn(sql: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int,
3840 >,
3841 pub complete16: ::std::option::Option<
3842 unsafe extern "C" fn(sql: *const ::std::os::raw::c_void) -> ::std::os::raw::c_int,
3843 >,
3844 pub create_collation: ::std::option::Option<
3845 unsafe extern "C" fn(
3846 arg1: *mut sqlite3,
3847 arg2: *const ::std::os::raw::c_char,
3848 arg3: ::std::os::raw::c_int,
3849 arg4: *mut ::std::os::raw::c_void,
3850 arg5: ::std::option::Option<
3851 unsafe extern "C" fn(
3852 arg1: *mut ::std::os::raw::c_void,
3853 arg2: ::std::os::raw::c_int,
3854 arg3: *const ::std::os::raw::c_void,
3855 arg4: ::std::os::raw::c_int,
3856 arg5: *const ::std::os::raw::c_void,
3857 ) -> ::std::os::raw::c_int,
3858 >,
3859 ) -> ::std::os::raw::c_int,
3860 >,
3861 pub create_collation16: ::std::option::Option<
3862 unsafe extern "C" fn(
3863 arg1: *mut sqlite3,
3864 arg2: *const ::std::os::raw::c_void,
3865 arg3: ::std::os::raw::c_int,
3866 arg4: *mut ::std::os::raw::c_void,
3867 arg5: ::std::option::Option<
3868 unsafe extern "C" fn(
3869 arg1: *mut ::std::os::raw::c_void,
3870 arg2: ::std::os::raw::c_int,
3871 arg3: *const ::std::os::raw::c_void,
3872 arg4: ::std::os::raw::c_int,
3873 arg5: *const ::std::os::raw::c_void,
3874 ) -> ::std::os::raw::c_int,
3875 >,
3876 ) -> ::std::os::raw::c_int,
3877 >,
3878 pub create_function: ::std::option::Option<
3879 unsafe extern "C" fn(
3880 arg1: *mut sqlite3,
3881 arg2: *const ::std::os::raw::c_char,
3882 arg3: ::std::os::raw::c_int,
3883 arg4: ::std::os::raw::c_int,
3884 arg5: *mut ::std::os::raw::c_void,
3885 xFunc: ::std::option::Option<
3886 unsafe extern "C" fn(
3887 arg1: *mut sqlite3_context,
3888 arg2: ::std::os::raw::c_int,
3889 arg3: *mut *mut sqlite3_value,
3890 ),
3891 >,
3892 xStep: ::std::option::Option<
3893 unsafe extern "C" fn(
3894 arg1: *mut sqlite3_context,
3895 arg2: ::std::os::raw::c_int,
3896 arg3: *mut *mut sqlite3_value,
3897 ),
3898 >,
3899 xFinal: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
3900 ) -> ::std::os::raw::c_int,
3901 >,
3902 pub create_function16: ::std::option::Option<
3903 unsafe extern "C" fn(
3904 arg1: *mut sqlite3,
3905 arg2: *const ::std::os::raw::c_void,
3906 arg3: ::std::os::raw::c_int,
3907 arg4: ::std::os::raw::c_int,
3908 arg5: *mut ::std::os::raw::c_void,
3909 xFunc: ::std::option::Option<
3910 unsafe extern "C" fn(
3911 arg1: *mut sqlite3_context,
3912 arg2: ::std::os::raw::c_int,
3913 arg3: *mut *mut sqlite3_value,
3914 ),
3915 >,
3916 xStep: ::std::option::Option<
3917 unsafe extern "C" fn(
3918 arg1: *mut sqlite3_context,
3919 arg2: ::std::os::raw::c_int,
3920 arg3: *mut *mut sqlite3_value,
3921 ),
3922 >,
3923 xFinal: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
3924 ) -> ::std::os::raw::c_int,
3925 >,
3926 pub create_module: ::std::option::Option<
3927 unsafe extern "C" fn(
3928 arg1: *mut sqlite3,
3929 arg2: *const ::std::os::raw::c_char,
3930 arg3: *const sqlite3_module,
3931 arg4: *mut ::std::os::raw::c_void,
3932 ) -> ::std::os::raw::c_int,
3933 >,
3934 pub data_count: ::std::option::Option<
3935 unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
3936 >,
3937 pub db_handle:
3938 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut sqlite3>,
3939 pub declare_vtab: ::std::option::Option<
3940 unsafe extern "C" fn(
3941 arg1: *mut sqlite3,
3942 arg2: *const ::std::os::raw::c_char,
3943 ) -> ::std::os::raw::c_int,
3944 >,
3945 pub enable_shared_cache: ::std::option::Option<
3946 unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
3947 >,
3948 pub errcode:
3949 ::std::option::Option<unsafe extern "C" fn(db: *mut sqlite3) -> ::std::os::raw::c_int>,
3950 pub errmsg: ::std::option::Option<
3951 unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_char,
3952 >,
3953 pub errmsg16: ::std::option::Option<
3954 unsafe extern "C" fn(arg1: *mut sqlite3) -> *const ::std::os::raw::c_void,
3955 >,
3956 pub exec: ::std::option::Option<
3957 unsafe extern "C" fn(
3958 arg1: *mut sqlite3,
3959 arg2: *const ::std::os::raw::c_char,
3960 arg3: sqlite3_callback,
3961 arg4: *mut ::std::os::raw::c_void,
3962 arg5: *mut *mut ::std::os::raw::c_char,
3963 ) -> ::std::os::raw::c_int,
3964 >,
3965 pub expired: ::std::option::Option<
3966 unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
3967 >,
3968 pub finalize: ::std::option::Option<
3969 unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
3970 >,
3971 pub free: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
3972 pub free_table:
3973 ::std::option::Option<unsafe extern "C" fn(result: *mut *mut ::std::os::raw::c_char)>,
3974 pub get_autocommit:
3975 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
3976 pub get_auxdata: ::std::option::Option<
3977 unsafe extern "C" fn(
3978 arg1: *mut sqlite3_context,
3979 arg2: ::std::os::raw::c_int,
3980 ) -> *mut ::std::os::raw::c_void,
3981 >,
3982 pub get_table: ::std::option::Option<
3983 unsafe extern "C" fn(
3984 arg1: *mut sqlite3,
3985 arg2: *const ::std::os::raw::c_char,
3986 arg3: *mut *mut *mut ::std::os::raw::c_char,
3987 arg4: *mut ::std::os::raw::c_int,
3988 arg5: *mut ::std::os::raw::c_int,
3989 arg6: *mut *mut ::std::os::raw::c_char,
3990 ) -> ::std::os::raw::c_int,
3991 >,
3992 pub global_recover: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
3993 pub interruptx: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3)>,
3994 pub last_insert_rowid:
3995 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> sqlite_int64>,
3996 pub libversion: ::std::option::Option<unsafe extern "C" fn() -> *const ::std::os::raw::c_char>,
3997 pub libversion_number: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
3998 pub malloc: ::std::option::Option<
3999 unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_void,
4000 >,
4001 pub mprintf: ::std::option::Option<
4002 unsafe extern "C" fn(
4003 arg1: *const ::std::os::raw::c_char,
4004 ...
4005 ) -> *mut ::std::os::raw::c_char,
4006 >,
4007 pub open: ::std::option::Option<
4008 unsafe extern "C" fn(
4009 arg1: *const ::std::os::raw::c_char,
4010 arg2: *mut *mut sqlite3,
4011 ) -> ::std::os::raw::c_int,
4012 >,
4013 pub open16: ::std::option::Option<
4014 unsafe extern "C" fn(
4015 arg1: *const ::std::os::raw::c_void,
4016 arg2: *mut *mut sqlite3,
4017 ) -> ::std::os::raw::c_int,
4018 >,
4019 pub prepare: ::std::option::Option<
4020 unsafe extern "C" fn(
4021 arg1: *mut sqlite3,
4022 arg2: *const ::std::os::raw::c_char,
4023 arg3: ::std::os::raw::c_int,
4024 arg4: *mut *mut sqlite3_stmt,
4025 arg5: *mut *const ::std::os::raw::c_char,
4026 ) -> ::std::os::raw::c_int,
4027 >,
4028 pub prepare16: ::std::option::Option<
4029 unsafe extern "C" fn(
4030 arg1: *mut sqlite3,
4031 arg2: *const ::std::os::raw::c_void,
4032 arg3: ::std::os::raw::c_int,
4033 arg4: *mut *mut sqlite3_stmt,
4034 arg5: *mut *const ::std::os::raw::c_void,
4035 ) -> ::std::os::raw::c_int,
4036 >,
4037 pub profile: ::std::option::Option<
4038 unsafe extern "C" fn(
4039 arg1: *mut sqlite3,
4040 arg2: ::std::option::Option<
4041 unsafe extern "C" fn(
4042 arg1: *mut ::std::os::raw::c_void,
4043 arg2: *const ::std::os::raw::c_char,
4044 arg3: sqlite_uint64,
4045 ),
4046 >,
4047 arg3: *mut ::std::os::raw::c_void,
4048 ) -> *mut ::std::os::raw::c_void,
4049 >,
4050 pub progress_handler: ::std::option::Option<
4051 unsafe extern "C" fn(
4052 arg1: *mut sqlite3,
4053 arg2: ::std::os::raw::c_int,
4054 arg3: ::std::option::Option<
4055 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
4056 >,
4057 arg4: *mut ::std::os::raw::c_void,
4058 ),
4059 >,
4060 pub realloc: ::std::option::Option<
4061 unsafe extern "C" fn(
4062 arg1: *mut ::std::os::raw::c_void,
4063 arg2: ::std::os::raw::c_int,
4064 ) -> *mut ::std::os::raw::c_void,
4065 >,
4066 pub reset: ::std::option::Option<
4067 unsafe extern "C" fn(pStmt: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
4068 >,
4069 pub result_blob: ::std::option::Option<
4070 unsafe extern "C" fn(
4071 arg1: *mut sqlite3_context,
4072 arg2: *const ::std::os::raw::c_void,
4073 arg3: ::std::os::raw::c_int,
4074 arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4075 ),
4076 >,
4077 pub result_double:
4078 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: f64)>,
4079 pub result_error: ::std::option::Option<
4080 unsafe extern "C" fn(
4081 arg1: *mut sqlite3_context,
4082 arg2: *const ::std::os::raw::c_char,
4083 arg3: ::std::os::raw::c_int,
4084 ),
4085 >,
4086 pub result_error16: ::std::option::Option<
4087 unsafe extern "C" fn(
4088 arg1: *mut sqlite3_context,
4089 arg2: *const ::std::os::raw::c_void,
4090 arg3: ::std::os::raw::c_int,
4091 ),
4092 >,
4093 pub result_int: ::std::option::Option<
4094 unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int),
4095 >,
4096 pub result_int64:
4097 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: sqlite_int64)>,
4098 pub result_null: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
4099 pub result_text: ::std::option::Option<
4100 unsafe extern "C" fn(
4101 arg1: *mut sqlite3_context,
4102 arg2: *const ::std::os::raw::c_char,
4103 arg3: ::std::os::raw::c_int,
4104 arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4105 ),
4106 >,
4107 pub result_text16: ::std::option::Option<
4108 unsafe extern "C" fn(
4109 arg1: *mut sqlite3_context,
4110 arg2: *const ::std::os::raw::c_void,
4111 arg3: ::std::os::raw::c_int,
4112 arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4113 ),
4114 >,
4115 pub result_text16be: ::std::option::Option<
4116 unsafe extern "C" fn(
4117 arg1: *mut sqlite3_context,
4118 arg2: *const ::std::os::raw::c_void,
4119 arg3: ::std::os::raw::c_int,
4120 arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4121 ),
4122 >,
4123 pub result_text16le: ::std::option::Option<
4124 unsafe extern "C" fn(
4125 arg1: *mut sqlite3_context,
4126 arg2: *const ::std::os::raw::c_void,
4127 arg3: ::std::os::raw::c_int,
4128 arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4129 ),
4130 >,
4131 pub result_value: ::std::option::Option<
4132 unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: *mut sqlite3_value),
4133 >,
4134 pub rollback_hook: ::std::option::Option<
4135 unsafe extern "C" fn(
4136 arg1: *mut sqlite3,
4137 arg2: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4138 arg3: *mut ::std::os::raw::c_void,
4139 ) -> *mut ::std::os::raw::c_void,
4140 >,
4141 pub set_authorizer: ::std::option::Option<
4142 unsafe extern "C" fn(
4143 arg1: *mut sqlite3,
4144 arg2: ::std::option::Option<
4145 unsafe extern "C" fn(
4146 arg1: *mut ::std::os::raw::c_void,
4147 arg2: ::std::os::raw::c_int,
4148 arg3: *const ::std::os::raw::c_char,
4149 arg4: *const ::std::os::raw::c_char,
4150 arg5: *const ::std::os::raw::c_char,
4151 arg6: *const ::std::os::raw::c_char,
4152 ) -> ::std::os::raw::c_int,
4153 >,
4154 arg3: *mut ::std::os::raw::c_void,
4155 ) -> ::std::os::raw::c_int,
4156 >,
4157 pub set_auxdata: ::std::option::Option<
4158 unsafe extern "C" fn(
4159 arg1: *mut sqlite3_context,
4160 arg2: ::std::os::raw::c_int,
4161 arg3: *mut ::std::os::raw::c_void,
4162 arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4163 ),
4164 >,
4165 pub xsnprintf: ::std::option::Option<
4166 unsafe extern "C" fn(
4167 arg1: ::std::os::raw::c_int,
4168 arg2: *mut ::std::os::raw::c_char,
4169 arg3: *const ::std::os::raw::c_char,
4170 ...
4171 ) -> *mut ::std::os::raw::c_char,
4172 >,
4173 pub step: ::std::option::Option<
4174 unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
4175 >,
4176 pub table_column_metadata: ::std::option::Option<
4177 unsafe extern "C" fn(
4178 arg1: *mut sqlite3,
4179 arg2: *const ::std::os::raw::c_char,
4180 arg3: *const ::std::os::raw::c_char,
4181 arg4: *const ::std::os::raw::c_char,
4182 arg5: *mut *const ::std::os::raw::c_char,
4183 arg6: *mut *const ::std::os::raw::c_char,
4184 arg7: *mut ::std::os::raw::c_int,
4185 arg8: *mut ::std::os::raw::c_int,
4186 arg9: *mut ::std::os::raw::c_int,
4187 ) -> ::std::os::raw::c_int,
4188 >,
4189 pub thread_cleanup: ::std::option::Option<unsafe extern "C" fn()>,
4190 pub total_changes:
4191 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
4192 pub trace: ::std::option::Option<
4193 unsafe extern "C" fn(
4194 arg1: *mut sqlite3,
4195 xTrace: ::std::option::Option<
4196 unsafe extern "C" fn(
4197 arg1: *mut ::std::os::raw::c_void,
4198 arg2: *const ::std::os::raw::c_char,
4199 ),
4200 >,
4201 arg2: *mut ::std::os::raw::c_void,
4202 ) -> *mut ::std::os::raw::c_void,
4203 >,
4204 pub transfer_bindings: ::std::option::Option<
4205 unsafe extern "C" fn(
4206 arg1: *mut sqlite3_stmt,
4207 arg2: *mut sqlite3_stmt,
4208 ) -> ::std::os::raw::c_int,
4209 >,
4210 pub update_hook: ::std::option::Option<
4211 unsafe extern "C" fn(
4212 arg1: *mut sqlite3,
4213 arg2: ::std::option::Option<
4214 unsafe extern "C" fn(
4215 arg1: *mut ::std::os::raw::c_void,
4216 arg2: ::std::os::raw::c_int,
4217 arg3: *const ::std::os::raw::c_char,
4218 arg4: *const ::std::os::raw::c_char,
4219 arg5: sqlite_int64,
4220 ),
4221 >,
4222 arg3: *mut ::std::os::raw::c_void,
4223 ) -> *mut ::std::os::raw::c_void,
4224 >,
4225 pub user_data: ::std::option::Option<
4226 unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut ::std::os::raw::c_void,
4227 >,
4228 pub value_blob: ::std::option::Option<
4229 unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void,
4230 >,
4231 pub value_bytes: ::std::option::Option<
4232 unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int,
4233 >,
4234 pub value_bytes16: ::std::option::Option<
4235 unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int,
4236 >,
4237 pub value_double: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_value) -> f64>,
4238 pub value_int: ::std::option::Option<
4239 unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int,
4240 >,
4241 pub value_int64:
4242 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_value) -> sqlite_int64>,
4243 pub value_numeric_type: ::std::option::Option<
4244 unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int,
4245 >,
4246 pub value_text: ::std::option::Option<
4247 unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_uchar,
4248 >,
4249 pub value_text16: ::std::option::Option<
4250 unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void,
4251 >,
4252 pub value_text16be: ::std::option::Option<
4253 unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void,
4254 >,
4255 pub value_text16le: ::std::option::Option<
4256 unsafe extern "C" fn(arg1: *mut sqlite3_value) -> *const ::std::os::raw::c_void,
4257 >,
4258 pub value_type: ::std::option::Option<
4259 unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int,
4260 >,
4261 pub vmprintf: ::std::option::Option<
4262 unsafe extern "C" fn(
4263 arg1: *const ::std::os::raw::c_char,
4264 arg2: va_list,
4265 ) -> *mut ::std::os::raw::c_char,
4266 >,
4267 pub overload_function: ::std::option::Option<
4268 unsafe extern "C" fn(
4269 arg1: *mut sqlite3,
4270 zFuncName: *const ::std::os::raw::c_char,
4271 nArg: ::std::os::raw::c_int,
4272 ) -> ::std::os::raw::c_int,
4273 >,
4274 pub prepare_v2: ::std::option::Option<
4275 unsafe extern "C" fn(
4276 arg1: *mut sqlite3,
4277 arg2: *const ::std::os::raw::c_char,
4278 arg3: ::std::os::raw::c_int,
4279 arg4: *mut *mut sqlite3_stmt,
4280 arg5: *mut *const ::std::os::raw::c_char,
4281 ) -> ::std::os::raw::c_int,
4282 >,
4283 pub prepare16_v2: ::std::option::Option<
4284 unsafe extern "C" fn(
4285 arg1: *mut sqlite3,
4286 arg2: *const ::std::os::raw::c_void,
4287 arg3: ::std::os::raw::c_int,
4288 arg4: *mut *mut sqlite3_stmt,
4289 arg5: *mut *const ::std::os::raw::c_void,
4290 ) -> ::std::os::raw::c_int,
4291 >,
4292 pub clear_bindings: ::std::option::Option<
4293 unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
4294 >,
4295 pub create_module_v2: ::std::option::Option<
4296 unsafe extern "C" fn(
4297 arg1: *mut sqlite3,
4298 arg2: *const ::std::os::raw::c_char,
4299 arg3: *const sqlite3_module,
4300 arg4: *mut ::std::os::raw::c_void,
4301 xDestroy: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4302 ) -> ::std::os::raw::c_int,
4303 >,
4304 pub bind_zeroblob: ::std::option::Option<
4305 unsafe extern "C" fn(
4306 arg1: *mut sqlite3_stmt,
4307 arg2: ::std::os::raw::c_int,
4308 arg3: ::std::os::raw::c_int,
4309 ) -> ::std::os::raw::c_int,
4310 >,
4311 pub blob_bytes: ::std::option::Option<
4312 unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int,
4313 >,
4314 pub blob_close: ::std::option::Option<
4315 unsafe extern "C" fn(arg1: *mut sqlite3_blob) -> ::std::os::raw::c_int,
4316 >,
4317 pub blob_open: ::std::option::Option<
4318 unsafe extern "C" fn(
4319 arg1: *mut sqlite3,
4320 arg2: *const ::std::os::raw::c_char,
4321 arg3: *const ::std::os::raw::c_char,
4322 arg4: *const ::std::os::raw::c_char,
4323 arg5: sqlite3_int64,
4324 arg6: ::std::os::raw::c_int,
4325 arg7: *mut *mut sqlite3_blob,
4326 ) -> ::std::os::raw::c_int,
4327 >,
4328 pub blob_read: ::std::option::Option<
4329 unsafe extern "C" fn(
4330 arg1: *mut sqlite3_blob,
4331 arg2: *mut ::std::os::raw::c_void,
4332 arg3: ::std::os::raw::c_int,
4333 arg4: ::std::os::raw::c_int,
4334 ) -> ::std::os::raw::c_int,
4335 >,
4336 pub blob_write: ::std::option::Option<
4337 unsafe extern "C" fn(
4338 arg1: *mut sqlite3_blob,
4339 arg2: *const ::std::os::raw::c_void,
4340 arg3: ::std::os::raw::c_int,
4341 arg4: ::std::os::raw::c_int,
4342 ) -> ::std::os::raw::c_int,
4343 >,
4344 pub create_collation_v2: ::std::option::Option<
4345 unsafe extern "C" fn(
4346 arg1: *mut sqlite3,
4347 arg2: *const ::std::os::raw::c_char,
4348 arg3: ::std::os::raw::c_int,
4349 arg4: *mut ::std::os::raw::c_void,
4350 arg5: ::std::option::Option<
4351 unsafe extern "C" fn(
4352 arg1: *mut ::std::os::raw::c_void,
4353 arg2: ::std::os::raw::c_int,
4354 arg3: *const ::std::os::raw::c_void,
4355 arg4: ::std::os::raw::c_int,
4356 arg5: *const ::std::os::raw::c_void,
4357 ) -> ::std::os::raw::c_int,
4358 >,
4359 arg6: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4360 ) -> ::std::os::raw::c_int,
4361 >,
4362 pub file_control: ::std::option::Option<
4363 unsafe extern "C" fn(
4364 arg1: *mut sqlite3,
4365 arg2: *const ::std::os::raw::c_char,
4366 arg3: ::std::os::raw::c_int,
4367 arg4: *mut ::std::os::raw::c_void,
4368 ) -> ::std::os::raw::c_int,
4369 >,
4370 pub memory_highwater:
4371 ::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> sqlite3_int64>,
4372 pub memory_used: ::std::option::Option<unsafe extern "C" fn() -> sqlite3_int64>,
4373 pub mutex_alloc: ::std::option::Option<
4374 unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *mut sqlite3_mutex,
4375 >,
4376 pub mutex_enter: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_mutex)>,
4377 pub mutex_free: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_mutex)>,
4378 pub mutex_leave: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_mutex)>,
4379 pub mutex_try: ::std::option::Option<
4380 unsafe extern "C" fn(arg1: *mut sqlite3_mutex) -> ::std::os::raw::c_int,
4381 >,
4382 pub open_v2: ::std::option::Option<
4383 unsafe extern "C" fn(
4384 arg1: *const ::std::os::raw::c_char,
4385 arg2: *mut *mut sqlite3,
4386 arg3: ::std::os::raw::c_int,
4387 arg4: *const ::std::os::raw::c_char,
4388 ) -> ::std::os::raw::c_int,
4389 >,
4390 pub release_memory: ::std::option::Option<
4391 unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
4392 >,
4393 pub result_error_nomem: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
4394 pub result_error_toobig:
4395 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
4396 pub sleep: ::std::option::Option<
4397 unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> ::std::os::raw::c_int,
4398 >,
4399 pub soft_heap_limit: ::std::option::Option<unsafe extern "C" fn(arg1: ::std::os::raw::c_int)>,
4400 pub vfs_find: ::std::option::Option<
4401 unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_vfs,
4402 >,
4403 pub vfs_register: ::std::option::Option<
4404 unsafe extern "C" fn(
4405 arg1: *mut sqlite3_vfs,
4406 arg2: ::std::os::raw::c_int,
4407 ) -> ::std::os::raw::c_int,
4408 >,
4409 pub vfs_unregister: ::std::option::Option<
4410 unsafe extern "C" fn(arg1: *mut sqlite3_vfs) -> ::std::os::raw::c_int,
4411 >,
4412 pub xthreadsafe: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
4413 pub result_zeroblob: ::std::option::Option<
4414 unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int),
4415 >,
4416 pub result_error_code: ::std::option::Option<
4417 unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_int),
4418 >,
4419 pub test_control: ::std::option::Option<
4420 unsafe extern "C" fn(arg1: ::std::os::raw::c_int, ...) -> ::std::os::raw::c_int,
4421 >,
4422 pub randomness: ::std::option::Option<
4423 unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *mut ::std::os::raw::c_void),
4424 >,
4425 pub context_db_handle:
4426 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context) -> *mut sqlite3>,
4427 pub extended_result_codes: ::std::option::Option<
4428 unsafe extern "C" fn(
4429 arg1: *mut sqlite3,
4430 arg2: ::std::os::raw::c_int,
4431 ) -> ::std::os::raw::c_int,
4432 >,
4433 pub limit: ::std::option::Option<
4434 unsafe extern "C" fn(
4435 arg1: *mut sqlite3,
4436 arg2: ::std::os::raw::c_int,
4437 arg3: ::std::os::raw::c_int,
4438 ) -> ::std::os::raw::c_int,
4439 >,
4440 pub next_stmt: ::std::option::Option<
4441 unsafe extern "C" fn(arg1: *mut sqlite3, arg2: *mut sqlite3_stmt) -> *mut sqlite3_stmt,
4442 >,
4443 pub sql: ::std::option::Option<
4444 unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char,
4445 >,
4446 pub status: ::std::option::Option<
4447 unsafe extern "C" fn(
4448 arg1: ::std::os::raw::c_int,
4449 arg2: *mut ::std::os::raw::c_int,
4450 arg3: *mut ::std::os::raw::c_int,
4451 arg4: ::std::os::raw::c_int,
4452 ) -> ::std::os::raw::c_int,
4453 >,
4454 pub backup_finish: ::std::option::Option<
4455 unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int,
4456 >,
4457 pub backup_init: ::std::option::Option<
4458 unsafe extern "C" fn(
4459 arg1: *mut sqlite3,
4460 arg2: *const ::std::os::raw::c_char,
4461 arg3: *mut sqlite3,
4462 arg4: *const ::std::os::raw::c_char,
4463 ) -> *mut sqlite3_backup,
4464 >,
4465 pub backup_pagecount: ::std::option::Option<
4466 unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int,
4467 >,
4468 pub backup_remaining: ::std::option::Option<
4469 unsafe extern "C" fn(arg1: *mut sqlite3_backup) -> ::std::os::raw::c_int,
4470 >,
4471 pub backup_step: ::std::option::Option<
4472 unsafe extern "C" fn(
4473 arg1: *mut sqlite3_backup,
4474 arg2: ::std::os::raw::c_int,
4475 ) -> ::std::os::raw::c_int,
4476 >,
4477 pub compileoption_get: ::std::option::Option<
4478 unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char,
4479 >,
4480 pub compileoption_used: ::std::option::Option<
4481 unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int,
4482 >,
4483 pub create_function_v2: ::std::option::Option<
4484 unsafe extern "C" fn(
4485 arg1: *mut sqlite3,
4486 arg2: *const ::std::os::raw::c_char,
4487 arg3: ::std::os::raw::c_int,
4488 arg4: ::std::os::raw::c_int,
4489 arg5: *mut ::std::os::raw::c_void,
4490 xFunc: ::std::option::Option<
4491 unsafe extern "C" fn(
4492 arg1: *mut sqlite3_context,
4493 arg2: ::std::os::raw::c_int,
4494 arg3: *mut *mut sqlite3_value,
4495 ),
4496 >,
4497 xStep: ::std::option::Option<
4498 unsafe extern "C" fn(
4499 arg1: *mut sqlite3_context,
4500 arg2: ::std::os::raw::c_int,
4501 arg3: *mut *mut sqlite3_value,
4502 ),
4503 >,
4504 xFinal: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
4505 xDestroy: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4506 ) -> ::std::os::raw::c_int,
4507 >,
4508 pub db_config: ::std::option::Option<
4509 unsafe extern "C" fn(
4510 arg1: *mut sqlite3,
4511 arg2: ::std::os::raw::c_int,
4512 ...
4513 ) -> ::std::os::raw::c_int,
4514 >,
4515 pub db_mutex:
4516 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> *mut sqlite3_mutex>,
4517 pub db_status: ::std::option::Option<
4518 unsafe extern "C" fn(
4519 arg1: *mut sqlite3,
4520 arg2: ::std::os::raw::c_int,
4521 arg3: *mut ::std::os::raw::c_int,
4522 arg4: *mut ::std::os::raw::c_int,
4523 arg5: ::std::os::raw::c_int,
4524 ) -> ::std::os::raw::c_int,
4525 >,
4526 pub extended_errcode:
4527 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
4528 pub log: ::std::option::Option<
4529 unsafe extern "C" fn(arg1: ::std::os::raw::c_int, arg2: *const ::std::os::raw::c_char, ...),
4530 >,
4531 pub soft_heap_limit64:
4532 ::std::option::Option<unsafe extern "C" fn(arg1: sqlite3_int64) -> sqlite3_int64>,
4533 pub sourceid: ::std::option::Option<unsafe extern "C" fn() -> *const ::std::os::raw::c_char>,
4534 pub stmt_status: ::std::option::Option<
4535 unsafe extern "C" fn(
4536 arg1: *mut sqlite3_stmt,
4537 arg2: ::std::os::raw::c_int,
4538 arg3: ::std::os::raw::c_int,
4539 ) -> ::std::os::raw::c_int,
4540 >,
4541 pub strnicmp: ::std::option::Option<
4542 unsafe extern "C" fn(
4543 arg1: *const ::std::os::raw::c_char,
4544 arg2: *const ::std::os::raw::c_char,
4545 arg3: ::std::os::raw::c_int,
4546 ) -> ::std::os::raw::c_int,
4547 >,
4548 pub unlock_notify: ::std::option::Option<
4549 unsafe extern "C" fn(
4550 arg1: *mut sqlite3,
4551 arg2: ::std::option::Option<
4552 unsafe extern "C" fn(
4553 arg1: *mut *mut ::std::os::raw::c_void,
4554 arg2: ::std::os::raw::c_int,
4555 ),
4556 >,
4557 arg3: *mut ::std::os::raw::c_void,
4558 ) -> ::std::os::raw::c_int,
4559 >,
4560 pub wal_autocheckpoint: ::std::option::Option<
4561 unsafe extern "C" fn(
4562 arg1: *mut sqlite3,
4563 arg2: ::std::os::raw::c_int,
4564 ) -> ::std::os::raw::c_int,
4565 >,
4566 pub wal_checkpoint: ::std::option::Option<
4567 unsafe extern "C" fn(
4568 arg1: *mut sqlite3,
4569 arg2: *const ::std::os::raw::c_char,
4570 ) -> ::std::os::raw::c_int,
4571 >,
4572 pub wal_hook: ::std::option::Option<
4573 unsafe extern "C" fn(
4574 arg1: *mut sqlite3,
4575 arg2: ::std::option::Option<
4576 unsafe extern "C" fn(
4577 arg1: *mut ::std::os::raw::c_void,
4578 arg2: *mut sqlite3,
4579 arg3: *const ::std::os::raw::c_char,
4580 arg4: ::std::os::raw::c_int,
4581 ) -> ::std::os::raw::c_int,
4582 >,
4583 arg3: *mut ::std::os::raw::c_void,
4584 ) -> *mut ::std::os::raw::c_void,
4585 >,
4586 pub blob_reopen: ::std::option::Option<
4587 unsafe extern "C" fn(arg1: *mut sqlite3_blob, arg2: sqlite3_int64) -> ::std::os::raw::c_int,
4588 >,
4589 pub vtab_config: ::std::option::Option<
4590 unsafe extern "C" fn(
4591 arg1: *mut sqlite3,
4592 op: ::std::os::raw::c_int,
4593 ...
4594 ) -> ::std::os::raw::c_int,
4595 >,
4596 pub vtab_on_conflict:
4597 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
4598 pub close_v2:
4599 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
4600 pub db_filename: ::std::option::Option<
4601 unsafe extern "C" fn(
4602 arg1: *mut sqlite3,
4603 arg2: *const ::std::os::raw::c_char,
4604 ) -> *const ::std::os::raw::c_char,
4605 >,
4606 pub db_readonly: ::std::option::Option<
4607 unsafe extern "C" fn(
4608 arg1: *mut sqlite3,
4609 arg2: *const ::std::os::raw::c_char,
4610 ) -> ::std::os::raw::c_int,
4611 >,
4612 pub db_release_memory:
4613 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
4614 pub errstr: ::std::option::Option<
4615 unsafe extern "C" fn(arg1: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char,
4616 >,
4617 pub stmt_busy: ::std::option::Option<
4618 unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
4619 >,
4620 pub stmt_readonly: ::std::option::Option<
4621 unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
4622 >,
4623 pub stricmp: ::std::option::Option<
4624 unsafe extern "C" fn(
4625 arg1: *const ::std::os::raw::c_char,
4626 arg2: *const ::std::os::raw::c_char,
4627 ) -> ::std::os::raw::c_int,
4628 >,
4629 pub uri_boolean: ::std::option::Option<
4630 unsafe extern "C" fn(
4631 arg1: *const ::std::os::raw::c_char,
4632 arg2: *const ::std::os::raw::c_char,
4633 arg3: ::std::os::raw::c_int,
4634 ) -> ::std::os::raw::c_int,
4635 >,
4636 pub uri_int64: ::std::option::Option<
4637 unsafe extern "C" fn(
4638 arg1: *const ::std::os::raw::c_char,
4639 arg2: *const ::std::os::raw::c_char,
4640 arg3: sqlite3_int64,
4641 ) -> sqlite3_int64,
4642 >,
4643 pub uri_parameter: ::std::option::Option<
4644 unsafe extern "C" fn(
4645 arg1: *const ::std::os::raw::c_char,
4646 arg2: *const ::std::os::raw::c_char,
4647 ) -> *const ::std::os::raw::c_char,
4648 >,
4649 pub xvsnprintf: ::std::option::Option<
4650 unsafe extern "C" fn(
4651 arg1: ::std::os::raw::c_int,
4652 arg2: *mut ::std::os::raw::c_char,
4653 arg3: *const ::std::os::raw::c_char,
4654 arg4: va_list,
4655 ) -> *mut ::std::os::raw::c_char,
4656 >,
4657 pub wal_checkpoint_v2: ::std::option::Option<
4658 unsafe extern "C" fn(
4659 arg1: *mut sqlite3,
4660 arg2: *const ::std::os::raw::c_char,
4661 arg3: ::std::os::raw::c_int,
4662 arg4: *mut ::std::os::raw::c_int,
4663 arg5: *mut ::std::os::raw::c_int,
4664 ) -> ::std::os::raw::c_int,
4665 >,
4666 pub auto_extension: ::std::option::Option<
4667 unsafe extern "C" fn(
4668 arg1: ::std::option::Option<unsafe extern "C" fn()>,
4669 ) -> ::std::os::raw::c_int,
4670 >,
4671 pub bind_blob64: ::std::option::Option<
4672 unsafe extern "C" fn(
4673 arg1: *mut sqlite3_stmt,
4674 arg2: ::std::os::raw::c_int,
4675 arg3: *const ::std::os::raw::c_void,
4676 arg4: sqlite3_uint64,
4677 arg5: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4678 ) -> ::std::os::raw::c_int,
4679 >,
4680 pub bind_text64: ::std::option::Option<
4681 unsafe extern "C" fn(
4682 arg1: *mut sqlite3_stmt,
4683 arg2: ::std::os::raw::c_int,
4684 arg3: *const ::std::os::raw::c_char,
4685 arg4: sqlite3_uint64,
4686 arg5: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4687 arg6: ::std::os::raw::c_uchar,
4688 ) -> ::std::os::raw::c_int,
4689 >,
4690 pub cancel_auto_extension: ::std::option::Option<
4691 unsafe extern "C" fn(
4692 arg1: ::std::option::Option<unsafe extern "C" fn()>,
4693 ) -> ::std::os::raw::c_int,
4694 >,
4695 pub load_extension: ::std::option::Option<
4696 unsafe extern "C" fn(
4697 arg1: *mut sqlite3,
4698 arg2: *const ::std::os::raw::c_char,
4699 arg3: *const ::std::os::raw::c_char,
4700 arg4: *mut *mut ::std::os::raw::c_char,
4701 ) -> ::std::os::raw::c_int,
4702 >,
4703 pub malloc64: ::std::option::Option<
4704 unsafe extern "C" fn(arg1: sqlite3_uint64) -> *mut ::std::os::raw::c_void,
4705 >,
4706 pub msize: ::std::option::Option<
4707 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> sqlite3_uint64,
4708 >,
4709 pub realloc64: ::std::option::Option<
4710 unsafe extern "C" fn(
4711 arg1: *mut ::std::os::raw::c_void,
4712 arg2: sqlite3_uint64,
4713 ) -> *mut ::std::os::raw::c_void,
4714 >,
4715 pub reset_auto_extension: ::std::option::Option<unsafe extern "C" fn()>,
4716 pub result_blob64: ::std::option::Option<
4717 unsafe extern "C" fn(
4718 arg1: *mut sqlite3_context,
4719 arg2: *const ::std::os::raw::c_void,
4720 arg3: sqlite3_uint64,
4721 arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4722 ),
4723 >,
4724 pub result_text64: ::std::option::Option<
4725 unsafe extern "C" fn(
4726 arg1: *mut sqlite3_context,
4727 arg2: *const ::std::os::raw::c_char,
4728 arg3: sqlite3_uint64,
4729 arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4730 arg5: ::std::os::raw::c_uchar,
4731 ),
4732 >,
4733 pub strglob: ::std::option::Option<
4734 unsafe extern "C" fn(
4735 arg1: *const ::std::os::raw::c_char,
4736 arg2: *const ::std::os::raw::c_char,
4737 ) -> ::std::os::raw::c_int,
4738 >,
4739 pub value_dup: ::std::option::Option<
4740 unsafe extern "C" fn(arg1: *const sqlite3_value) -> *mut sqlite3_value,
4741 >,
4742 pub value_free: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_value)>,
4743 pub result_zeroblob64: ::std::option::Option<
4744 unsafe extern "C" fn(
4745 arg1: *mut sqlite3_context,
4746 arg2: sqlite3_uint64,
4747 ) -> ::std::os::raw::c_int,
4748 >,
4749 pub bind_zeroblob64: ::std::option::Option<
4750 unsafe extern "C" fn(
4751 arg1: *mut sqlite3_stmt,
4752 arg2: ::std::os::raw::c_int,
4753 arg3: sqlite3_uint64,
4754 ) -> ::std::os::raw::c_int,
4755 >,
4756 pub value_subtype: ::std::option::Option<
4757 unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_uint,
4758 >,
4759 pub result_subtype: ::std::option::Option<
4760 unsafe extern "C" fn(arg1: *mut sqlite3_context, arg2: ::std::os::raw::c_uint),
4761 >,
4762 pub status64: ::std::option::Option<
4763 unsafe extern "C" fn(
4764 arg1: ::std::os::raw::c_int,
4765 arg2: *mut sqlite3_int64,
4766 arg3: *mut sqlite3_int64,
4767 arg4: ::std::os::raw::c_int,
4768 ) -> ::std::os::raw::c_int,
4769 >,
4770 pub strlike: ::std::option::Option<
4771 unsafe extern "C" fn(
4772 arg1: *const ::std::os::raw::c_char,
4773 arg2: *const ::std::os::raw::c_char,
4774 arg3: ::std::os::raw::c_uint,
4775 ) -> ::std::os::raw::c_int,
4776 >,
4777 pub db_cacheflush:
4778 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
4779 pub system_errno:
4780 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
4781 pub trace_v2: ::std::option::Option<
4782 unsafe extern "C" fn(
4783 arg1: *mut sqlite3,
4784 arg2: ::std::os::raw::c_uint,
4785 arg3: ::std::option::Option<
4786 unsafe extern "C" fn(
4787 arg1: ::std::os::raw::c_uint,
4788 arg2: *mut ::std::os::raw::c_void,
4789 arg3: *mut ::std::os::raw::c_void,
4790 arg4: *mut ::std::os::raw::c_void,
4791 ) -> ::std::os::raw::c_int,
4792 >,
4793 arg4: *mut ::std::os::raw::c_void,
4794 ) -> ::std::os::raw::c_int,
4795 >,
4796 pub expanded_sql: ::std::option::Option<
4797 unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *mut ::std::os::raw::c_char,
4798 >,
4799 pub set_last_insert_rowid:
4800 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3, arg2: sqlite3_int64)>,
4801 pub prepare_v3: ::std::option::Option<
4802 unsafe extern "C" fn(
4803 arg1: *mut sqlite3,
4804 arg2: *const ::std::os::raw::c_char,
4805 arg3: ::std::os::raw::c_int,
4806 arg4: ::std::os::raw::c_uint,
4807 arg5: *mut *mut sqlite3_stmt,
4808 arg6: *mut *const ::std::os::raw::c_char,
4809 ) -> ::std::os::raw::c_int,
4810 >,
4811 pub prepare16_v3: ::std::option::Option<
4812 unsafe extern "C" fn(
4813 arg1: *mut sqlite3,
4814 arg2: *const ::std::os::raw::c_void,
4815 arg3: ::std::os::raw::c_int,
4816 arg4: ::std::os::raw::c_uint,
4817 arg5: *mut *mut sqlite3_stmt,
4818 arg6: *mut *const ::std::os::raw::c_void,
4819 ) -> ::std::os::raw::c_int,
4820 >,
4821 pub bind_pointer: ::std::option::Option<
4822 unsafe extern "C" fn(
4823 arg1: *mut sqlite3_stmt,
4824 arg2: ::std::os::raw::c_int,
4825 arg3: *mut ::std::os::raw::c_void,
4826 arg4: *const ::std::os::raw::c_char,
4827 arg5: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4828 ) -> ::std::os::raw::c_int,
4829 >,
4830 pub result_pointer: ::std::option::Option<
4831 unsafe extern "C" fn(
4832 arg1: *mut sqlite3_context,
4833 arg2: *mut ::std::os::raw::c_void,
4834 arg3: *const ::std::os::raw::c_char,
4835 arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4836 ),
4837 >,
4838 pub value_pointer: ::std::option::Option<
4839 unsafe extern "C" fn(
4840 arg1: *mut sqlite3_value,
4841 arg2: *const ::std::os::raw::c_char,
4842 ) -> *mut ::std::os::raw::c_void,
4843 >,
4844 pub vtab_nochange: ::std::option::Option<
4845 unsafe extern "C" fn(arg1: *mut sqlite3_context) -> ::std::os::raw::c_int,
4846 >,
4847 pub value_nochange: ::std::option::Option<
4848 unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int,
4849 >,
4850 pub vtab_collation: ::std::option::Option<
4851 unsafe extern "C" fn(
4852 arg1: *mut sqlite3_index_info,
4853 arg2: ::std::os::raw::c_int,
4854 ) -> *const ::std::os::raw::c_char,
4855 >,
4856 pub keyword_count: ::std::option::Option<unsafe extern "C" fn() -> ::std::os::raw::c_int>,
4857 pub keyword_name: ::std::option::Option<
4858 unsafe extern "C" fn(
4859 arg1: ::std::os::raw::c_int,
4860 arg2: *mut *const ::std::os::raw::c_char,
4861 arg3: *mut ::std::os::raw::c_int,
4862 ) -> ::std::os::raw::c_int,
4863 >,
4864 pub keyword_check: ::std::option::Option<
4865 unsafe extern "C" fn(
4866 arg1: *const ::std::os::raw::c_char,
4867 arg2: ::std::os::raw::c_int,
4868 ) -> ::std::os::raw::c_int,
4869 >,
4870 pub str_new:
4871 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> *mut sqlite3_str>,
4872 pub str_finish: ::std::option::Option<
4873 unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char,
4874 >,
4875 pub str_appendf: ::std::option::Option<
4876 unsafe extern "C" fn(arg1: *mut sqlite3_str, zFormat: *const ::std::os::raw::c_char, ...),
4877 >,
4878 pub str_vappendf: ::std::option::Option<
4879 unsafe extern "C" fn(
4880 arg1: *mut sqlite3_str,
4881 zFormat: *const ::std::os::raw::c_char,
4882 arg2: va_list,
4883 ),
4884 >,
4885 pub str_append: ::std::option::Option<
4886 unsafe extern "C" fn(
4887 arg1: *mut sqlite3_str,
4888 zIn: *const ::std::os::raw::c_char,
4889 N: ::std::os::raw::c_int,
4890 ),
4891 >,
4892 pub str_appendall: ::std::option::Option<
4893 unsafe extern "C" fn(arg1: *mut sqlite3_str, zIn: *const ::std::os::raw::c_char),
4894 >,
4895 pub str_appendchar: ::std::option::Option<
4896 unsafe extern "C" fn(
4897 arg1: *mut sqlite3_str,
4898 N: ::std::os::raw::c_int,
4899 C: ::std::os::raw::c_char,
4900 ),
4901 >,
4902 pub str_reset: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_str)>,
4903 pub str_errcode: ::std::option::Option<
4904 unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int,
4905 >,
4906 pub str_length: ::std::option::Option<
4907 unsafe extern "C" fn(arg1: *mut sqlite3_str) -> ::std::os::raw::c_int,
4908 >,
4909 pub str_value: ::std::option::Option<
4910 unsafe extern "C" fn(arg1: *mut sqlite3_str) -> *mut ::std::os::raw::c_char,
4911 >,
4912 pub create_window_function: ::std::option::Option<
4913 unsafe extern "C" fn(
4914 arg1: *mut sqlite3,
4915 arg2: *const ::std::os::raw::c_char,
4916 arg3: ::std::os::raw::c_int,
4917 arg4: ::std::os::raw::c_int,
4918 arg5: *mut ::std::os::raw::c_void,
4919 xStep: ::std::option::Option<
4920 unsafe extern "C" fn(
4921 arg1: *mut sqlite3_context,
4922 arg2: ::std::os::raw::c_int,
4923 arg3: *mut *mut sqlite3_value,
4924 ),
4925 >,
4926 xFinal: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
4927 xValue: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3_context)>,
4928 xInv: ::std::option::Option<
4929 unsafe extern "C" fn(
4930 arg1: *mut sqlite3_context,
4931 arg2: ::std::os::raw::c_int,
4932 arg3: *mut *mut sqlite3_value,
4933 ),
4934 >,
4935 xDestroy: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
4936 ) -> ::std::os::raw::c_int,
4937 >,
4938 pub normalized_sql: ::std::option::Option<
4939 unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> *const ::std::os::raw::c_char,
4940 >,
4941 pub stmt_isexplain: ::std::option::Option<
4942 unsafe extern "C" fn(arg1: *mut sqlite3_stmt) -> ::std::os::raw::c_int,
4943 >,
4944 pub value_frombind: ::std::option::Option<
4945 unsafe extern "C" fn(arg1: *mut sqlite3_value) -> ::std::os::raw::c_int,
4946 >,
4947 pub drop_modules: ::std::option::Option<
4948 unsafe extern "C" fn(
4949 arg1: *mut sqlite3,
4950 arg2: *mut *const ::std::os::raw::c_char,
4951 ) -> ::std::os::raw::c_int,
4952 >,
4953 pub hard_heap_limit64:
4954 ::std::option::Option<unsafe extern "C" fn(arg1: sqlite3_int64) -> sqlite3_int64>,
4955 pub uri_key: ::std::option::Option<
4956 unsafe extern "C" fn(
4957 arg1: *const ::std::os::raw::c_char,
4958 arg2: ::std::os::raw::c_int,
4959 ) -> *const ::std::os::raw::c_char,
4960 >,
4961 pub filename_database: ::std::option::Option<
4962 unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char,
4963 >,
4964 pub filename_journal: ::std::option::Option<
4965 unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char,
4966 >,
4967 pub filename_wal: ::std::option::Option<
4968 unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *const ::std::os::raw::c_char,
4969 >,
4970 pub create_filename: ::std::option::Option<
4971 unsafe extern "C" fn(
4972 arg1: *const ::std::os::raw::c_char,
4973 arg2: *const ::std::os::raw::c_char,
4974 arg3: *const ::std::os::raw::c_char,
4975 arg4: ::std::os::raw::c_int,
4976 arg5: *mut *const ::std::os::raw::c_char,
4977 ) -> *mut ::std::os::raw::c_char,
4978 >,
4979 pub free_filename:
4980 ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_char)>,
4981 pub database_file_object: ::std::option::Option<
4982 unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char) -> *mut sqlite3_file,
4983 >,
4984 pub txn_state: ::std::option::Option<
4985 unsafe extern "C" fn(
4986 arg1: *mut sqlite3,
4987 arg2: *const ::std::os::raw::c_char,
4988 ) -> ::std::os::raw::c_int,
4989 >,
4990 pub changes64: ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> sqlite3_int64>,
4991 pub total_changes64:
4992 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> sqlite3_int64>,
4993 pub autovacuum_pages: ::std::option::Option<
4994 unsafe extern "C" fn(
4995 arg1: *mut sqlite3,
4996 arg2: ::std::option::Option<
4997 unsafe extern "C" fn(
4998 arg1: *mut ::std::os::raw::c_void,
4999 arg2: *const ::std::os::raw::c_char,
5000 arg3: ::std::os::raw::c_uint,
5001 arg4: ::std::os::raw::c_uint,
5002 arg5: ::std::os::raw::c_uint,
5003 ) -> ::std::os::raw::c_uint,
5004 >,
5005 arg3: *mut ::std::os::raw::c_void,
5006 arg4: ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>,
5007 ) -> ::std::os::raw::c_int,
5008 >,
5009 pub error_offset:
5010 ::std::option::Option<unsafe extern "C" fn(arg1: *mut sqlite3) -> ::std::os::raw::c_int>,
5011 pub vtab_rhs_value: ::std::option::Option<
5012 unsafe extern "C" fn(
5013 arg1: *mut sqlite3_index_info,
5014 arg2: ::std::os::raw::c_int,
5015 arg3: *mut *mut sqlite3_value,
5016 ) -> ::std::os::raw::c_int,
5017 >,
5018 pub vtab_distinct: ::std::option::Option<
5019 unsafe extern "C" fn(arg1: *mut sqlite3_index_info) -> ::std::os::raw::c_int,
5020 >,
5021 pub vtab_in: ::std::option::Option<
5022 unsafe extern "C" fn(
5023 arg1: *mut sqlite3_index_info,
5024 arg2: ::std::os::raw::c_int,
5025 arg3: ::std::os::raw::c_int,
5026 ) -> ::std::os::raw::c_int,
5027 >,
5028 pub vtab_in_first: ::std::option::Option<
5029 unsafe extern "C" fn(
5030 arg1: *mut sqlite3_value,
5031 arg2: *mut *mut sqlite3_value,
5032 ) -> ::std::os::raw::c_int,
5033 >,
5034 pub vtab_in_next: ::std::option::Option<
5035 unsafe extern "C" fn(
5036 arg1: *mut sqlite3_value,
5037 arg2: *mut *mut sqlite3_value,
5038 ) -> ::std::os::raw::c_int,
5039 >,
5040}
5041#[test]
5042fn bindgen_test_layout_sqlite3_api_routines() {
5043 const UNINIT: ::std::mem::MaybeUninit<sqlite3_api_routines> = ::std::mem::MaybeUninit::uninit();
5044 let ptr = UNINIT.as_ptr();
5045 assert_eq!(
5046 ::std::mem::size_of::<sqlite3_api_routines>(),
5047 2096usize,
5048 concat!("Size of: ", stringify!(sqlite3_api_routines))
5049 );
5050 assert_eq!(
5051 ::std::mem::align_of::<sqlite3_api_routines>(),
5052 8usize,
5053 concat!("Alignment of ", stringify!(sqlite3_api_routines))
5054 );
5055 assert_eq!(
5056 unsafe { ::std::ptr::addr_of!((*ptr).aggregate_context) as usize - ptr as usize },
5057 0usize,
5058 concat!(
5059 "Offset of field: ",
5060 stringify!(sqlite3_api_routines),
5061 "::",
5062 stringify!(aggregate_context)
5063 )
5064 );
5065 assert_eq!(
5066 unsafe { ::std::ptr::addr_of!((*ptr).aggregate_count) as usize - ptr as usize },
5067 8usize,
5068 concat!(
5069 "Offset of field: ",
5070 stringify!(sqlite3_api_routines),
5071 "::",
5072 stringify!(aggregate_count)
5073 )
5074 );
5075 assert_eq!(
5076 unsafe { ::std::ptr::addr_of!((*ptr).bind_blob) as usize - ptr as usize },
5077 16usize,
5078 concat!(
5079 "Offset of field: ",
5080 stringify!(sqlite3_api_routines),
5081 "::",
5082 stringify!(bind_blob)
5083 )
5084 );
5085 assert_eq!(
5086 unsafe { ::std::ptr::addr_of!((*ptr).bind_double) as usize - ptr as usize },
5087 24usize,
5088 concat!(
5089 "Offset of field: ",
5090 stringify!(sqlite3_api_routines),
5091 "::",
5092 stringify!(bind_double)
5093 )
5094 );
5095 assert_eq!(
5096 unsafe { ::std::ptr::addr_of!((*ptr).bind_int) as usize - ptr as usize },
5097 32usize,
5098 concat!(
5099 "Offset of field: ",
5100 stringify!(sqlite3_api_routines),
5101 "::",
5102 stringify!(bind_int)
5103 )
5104 );
5105 assert_eq!(
5106 unsafe { ::std::ptr::addr_of!((*ptr).bind_int64) as usize - ptr as usize },
5107 40usize,
5108 concat!(
5109 "Offset of field: ",
5110 stringify!(sqlite3_api_routines),
5111 "::",
5112 stringify!(bind_int64)
5113 )
5114 );
5115 assert_eq!(
5116 unsafe { ::std::ptr::addr_of!((*ptr).bind_null) as usize - ptr as usize },
5117 48usize,
5118 concat!(
5119 "Offset of field: ",
5120 stringify!(sqlite3_api_routines),
5121 "::",
5122 stringify!(bind_null)
5123 )
5124 );
5125 assert_eq!(
5126 unsafe { ::std::ptr::addr_of!((*ptr).bind_parameter_count) as usize - ptr as usize },
5127 56usize,
5128 concat!(
5129 "Offset of field: ",
5130 stringify!(sqlite3_api_routines),
5131 "::",
5132 stringify!(bind_parameter_count)
5133 )
5134 );
5135 assert_eq!(
5136 unsafe { ::std::ptr::addr_of!((*ptr).bind_parameter_index) as usize - ptr as usize },
5137 64usize,
5138 concat!(
5139 "Offset of field: ",
5140 stringify!(sqlite3_api_routines),
5141 "::",
5142 stringify!(bind_parameter_index)
5143 )
5144 );
5145 assert_eq!(
5146 unsafe { ::std::ptr::addr_of!((*ptr).bind_parameter_name) as usize - ptr as usize },
5147 72usize,
5148 concat!(
5149 "Offset of field: ",
5150 stringify!(sqlite3_api_routines),
5151 "::",
5152 stringify!(bind_parameter_name)
5153 )
5154 );
5155 assert_eq!(
5156 unsafe { ::std::ptr::addr_of!((*ptr).bind_text) as usize - ptr as usize },
5157 80usize,
5158 concat!(
5159 "Offset of field: ",
5160 stringify!(sqlite3_api_routines),
5161 "::",
5162 stringify!(bind_text)
5163 )
5164 );
5165 assert_eq!(
5166 unsafe { ::std::ptr::addr_of!((*ptr).bind_text16) as usize - ptr as usize },
5167 88usize,
5168 concat!(
5169 "Offset of field: ",
5170 stringify!(sqlite3_api_routines),
5171 "::",
5172 stringify!(bind_text16)
5173 )
5174 );
5175 assert_eq!(
5176 unsafe { ::std::ptr::addr_of!((*ptr).bind_value) as usize - ptr as usize },
5177 96usize,
5178 concat!(
5179 "Offset of field: ",
5180 stringify!(sqlite3_api_routines),
5181 "::",
5182 stringify!(bind_value)
5183 )
5184 );
5185 assert_eq!(
5186 unsafe { ::std::ptr::addr_of!((*ptr).busy_handler) as usize - ptr as usize },
5187 104usize,
5188 concat!(
5189 "Offset of field: ",
5190 stringify!(sqlite3_api_routines),
5191 "::",
5192 stringify!(busy_handler)
5193 )
5194 );
5195 assert_eq!(
5196 unsafe { ::std::ptr::addr_of!((*ptr).busy_timeout) as usize - ptr as usize },
5197 112usize,
5198 concat!(
5199 "Offset of field: ",
5200 stringify!(sqlite3_api_routines),
5201 "::",
5202 stringify!(busy_timeout)
5203 )
5204 );
5205 assert_eq!(
5206 unsafe { ::std::ptr::addr_of!((*ptr).changes) as usize - ptr as usize },
5207 120usize,
5208 concat!(
5209 "Offset of field: ",
5210 stringify!(sqlite3_api_routines),
5211 "::",
5212 stringify!(changes)
5213 )
5214 );
5215 assert_eq!(
5216 unsafe { ::std::ptr::addr_of!((*ptr).close) as usize - ptr as usize },
5217 128usize,
5218 concat!(
5219 "Offset of field: ",
5220 stringify!(sqlite3_api_routines),
5221 "::",
5222 stringify!(close)
5223 )
5224 );
5225 assert_eq!(
5226 unsafe { ::std::ptr::addr_of!((*ptr).collation_needed) as usize - ptr as usize },
5227 136usize,
5228 concat!(
5229 "Offset of field: ",
5230 stringify!(sqlite3_api_routines),
5231 "::",
5232 stringify!(collation_needed)
5233 )
5234 );
5235 assert_eq!(
5236 unsafe { ::std::ptr::addr_of!((*ptr).collation_needed16) as usize - ptr as usize },
5237 144usize,
5238 concat!(
5239 "Offset of field: ",
5240 stringify!(sqlite3_api_routines),
5241 "::",
5242 stringify!(collation_needed16)
5243 )
5244 );
5245 assert_eq!(
5246 unsafe { ::std::ptr::addr_of!((*ptr).column_blob) as usize - ptr as usize },
5247 152usize,
5248 concat!(
5249 "Offset of field: ",
5250 stringify!(sqlite3_api_routines),
5251 "::",
5252 stringify!(column_blob)
5253 )
5254 );
5255 assert_eq!(
5256 unsafe { ::std::ptr::addr_of!((*ptr).column_bytes) as usize - ptr as usize },
5257 160usize,
5258 concat!(
5259 "Offset of field: ",
5260 stringify!(sqlite3_api_routines),
5261 "::",
5262 stringify!(column_bytes)
5263 )
5264 );
5265 assert_eq!(
5266 unsafe { ::std::ptr::addr_of!((*ptr).column_bytes16) as usize - ptr as usize },
5267 168usize,
5268 concat!(
5269 "Offset of field: ",
5270 stringify!(sqlite3_api_routines),
5271 "::",
5272 stringify!(column_bytes16)
5273 )
5274 );
5275 assert_eq!(
5276 unsafe { ::std::ptr::addr_of!((*ptr).column_count) as usize - ptr as usize },
5277 176usize,
5278 concat!(
5279 "Offset of field: ",
5280 stringify!(sqlite3_api_routines),
5281 "::",
5282 stringify!(column_count)
5283 )
5284 );
5285 assert_eq!(
5286 unsafe { ::std::ptr::addr_of!((*ptr).column_database_name) as usize - ptr as usize },
5287 184usize,
5288 concat!(
5289 "Offset of field: ",
5290 stringify!(sqlite3_api_routines),
5291 "::",
5292 stringify!(column_database_name)
5293 )
5294 );
5295 assert_eq!(
5296 unsafe { ::std::ptr::addr_of!((*ptr).column_database_name16) as usize - ptr as usize },
5297 192usize,
5298 concat!(
5299 "Offset of field: ",
5300 stringify!(sqlite3_api_routines),
5301 "::",
5302 stringify!(column_database_name16)
5303 )
5304 );
5305 assert_eq!(
5306 unsafe { ::std::ptr::addr_of!((*ptr).column_decltype) as usize - ptr as usize },
5307 200usize,
5308 concat!(
5309 "Offset of field: ",
5310 stringify!(sqlite3_api_routines),
5311 "::",
5312 stringify!(column_decltype)
5313 )
5314 );
5315 assert_eq!(
5316 unsafe { ::std::ptr::addr_of!((*ptr).column_decltype16) as usize - ptr as usize },
5317 208usize,
5318 concat!(
5319 "Offset of field: ",
5320 stringify!(sqlite3_api_routines),
5321 "::",
5322 stringify!(column_decltype16)
5323 )
5324 );
5325 assert_eq!(
5326 unsafe { ::std::ptr::addr_of!((*ptr).column_double) as usize - ptr as usize },
5327 216usize,
5328 concat!(
5329 "Offset of field: ",
5330 stringify!(sqlite3_api_routines),
5331 "::",
5332 stringify!(column_double)
5333 )
5334 );
5335 assert_eq!(
5336 unsafe { ::std::ptr::addr_of!((*ptr).column_int) as usize - ptr as usize },
5337 224usize,
5338 concat!(
5339 "Offset of field: ",
5340 stringify!(sqlite3_api_routines),
5341 "::",
5342 stringify!(column_int)
5343 )
5344 );
5345 assert_eq!(
5346 unsafe { ::std::ptr::addr_of!((*ptr).column_int64) as usize - ptr as usize },
5347 232usize,
5348 concat!(
5349 "Offset of field: ",
5350 stringify!(sqlite3_api_routines),
5351 "::",
5352 stringify!(column_int64)
5353 )
5354 );
5355 assert_eq!(
5356 unsafe { ::std::ptr::addr_of!((*ptr).column_name) as usize - ptr as usize },
5357 240usize,
5358 concat!(
5359 "Offset of field: ",
5360 stringify!(sqlite3_api_routines),
5361 "::",
5362 stringify!(column_name)
5363 )
5364 );
5365 assert_eq!(
5366 unsafe { ::std::ptr::addr_of!((*ptr).column_name16) as usize - ptr as usize },
5367 248usize,
5368 concat!(
5369 "Offset of field: ",
5370 stringify!(sqlite3_api_routines),
5371 "::",
5372 stringify!(column_name16)
5373 )
5374 );
5375 assert_eq!(
5376 unsafe { ::std::ptr::addr_of!((*ptr).column_origin_name) as usize - ptr as usize },
5377 256usize,
5378 concat!(
5379 "Offset of field: ",
5380 stringify!(sqlite3_api_routines),
5381 "::",
5382 stringify!(column_origin_name)
5383 )
5384 );
5385 assert_eq!(
5386 unsafe { ::std::ptr::addr_of!((*ptr).column_origin_name16) as usize - ptr as usize },
5387 264usize,
5388 concat!(
5389 "Offset of field: ",
5390 stringify!(sqlite3_api_routines),
5391 "::",
5392 stringify!(column_origin_name16)
5393 )
5394 );
5395 assert_eq!(
5396 unsafe { ::std::ptr::addr_of!((*ptr).column_table_name) as usize - ptr as usize },
5397 272usize,
5398 concat!(
5399 "Offset of field: ",
5400 stringify!(sqlite3_api_routines),
5401 "::",
5402 stringify!(column_table_name)
5403 )
5404 );
5405 assert_eq!(
5406 unsafe { ::std::ptr::addr_of!((*ptr).column_table_name16) as usize - ptr as usize },
5407 280usize,
5408 concat!(
5409 "Offset of field: ",
5410 stringify!(sqlite3_api_routines),
5411 "::",
5412 stringify!(column_table_name16)
5413 )
5414 );
5415 assert_eq!(
5416 unsafe { ::std::ptr::addr_of!((*ptr).column_text) as usize - ptr as usize },
5417 288usize,
5418 concat!(
5419 "Offset of field: ",
5420 stringify!(sqlite3_api_routines),
5421 "::",
5422 stringify!(column_text)
5423 )
5424 );
5425 assert_eq!(
5426 unsafe { ::std::ptr::addr_of!((*ptr).column_text16) as usize - ptr as usize },
5427 296usize,
5428 concat!(
5429 "Offset of field: ",
5430 stringify!(sqlite3_api_routines),
5431 "::",
5432 stringify!(column_text16)
5433 )
5434 );
5435 assert_eq!(
5436 unsafe { ::std::ptr::addr_of!((*ptr).column_type) as usize - ptr as usize },
5437 304usize,
5438 concat!(
5439 "Offset of field: ",
5440 stringify!(sqlite3_api_routines),
5441 "::",
5442 stringify!(column_type)
5443 )
5444 );
5445 assert_eq!(
5446 unsafe { ::std::ptr::addr_of!((*ptr).column_value) as usize - ptr as usize },
5447 312usize,
5448 concat!(
5449 "Offset of field: ",
5450 stringify!(sqlite3_api_routines),
5451 "::",
5452 stringify!(column_value)
5453 )
5454 );
5455 assert_eq!(
5456 unsafe { ::std::ptr::addr_of!((*ptr).commit_hook) as usize - ptr as usize },
5457 320usize,
5458 concat!(
5459 "Offset of field: ",
5460 stringify!(sqlite3_api_routines),
5461 "::",
5462 stringify!(commit_hook)
5463 )
5464 );
5465 assert_eq!(
5466 unsafe { ::std::ptr::addr_of!((*ptr).complete) as usize - ptr as usize },
5467 328usize,
5468 concat!(
5469 "Offset of field: ",
5470 stringify!(sqlite3_api_routines),
5471 "::",
5472 stringify!(complete)
5473 )
5474 );
5475 assert_eq!(
5476 unsafe { ::std::ptr::addr_of!((*ptr).complete16) as usize - ptr as usize },
5477 336usize,
5478 concat!(
5479 "Offset of field: ",
5480 stringify!(sqlite3_api_routines),
5481 "::",
5482 stringify!(complete16)
5483 )
5484 );
5485 assert_eq!(
5486 unsafe { ::std::ptr::addr_of!((*ptr).create_collation) as usize - ptr as usize },
5487 344usize,
5488 concat!(
5489 "Offset of field: ",
5490 stringify!(sqlite3_api_routines),
5491 "::",
5492 stringify!(create_collation)
5493 )
5494 );
5495 assert_eq!(
5496 unsafe { ::std::ptr::addr_of!((*ptr).create_collation16) as usize - ptr as usize },
5497 352usize,
5498 concat!(
5499 "Offset of field: ",
5500 stringify!(sqlite3_api_routines),
5501 "::",
5502 stringify!(create_collation16)
5503 )
5504 );
5505 assert_eq!(
5506 unsafe { ::std::ptr::addr_of!((*ptr).create_function) as usize - ptr as usize },
5507 360usize,
5508 concat!(
5509 "Offset of field: ",
5510 stringify!(sqlite3_api_routines),
5511 "::",
5512 stringify!(create_function)
5513 )
5514 );
5515 assert_eq!(
5516 unsafe { ::std::ptr::addr_of!((*ptr).create_function16) as usize - ptr as usize },
5517 368usize,
5518 concat!(
5519 "Offset of field: ",
5520 stringify!(sqlite3_api_routines),
5521 "::",
5522 stringify!(create_function16)
5523 )
5524 );
5525 assert_eq!(
5526 unsafe { ::std::ptr::addr_of!((*ptr).create_module) as usize - ptr as usize },
5527 376usize,
5528 concat!(
5529 "Offset of field: ",
5530 stringify!(sqlite3_api_routines),
5531 "::",
5532 stringify!(create_module)
5533 )
5534 );
5535 assert_eq!(
5536 unsafe { ::std::ptr::addr_of!((*ptr).data_count) as usize - ptr as usize },
5537 384usize,
5538 concat!(
5539 "Offset of field: ",
5540 stringify!(sqlite3_api_routines),
5541 "::",
5542 stringify!(data_count)
5543 )
5544 );
5545 assert_eq!(
5546 unsafe { ::std::ptr::addr_of!((*ptr).db_handle) as usize - ptr as usize },
5547 392usize,
5548 concat!(
5549 "Offset of field: ",
5550 stringify!(sqlite3_api_routines),
5551 "::",
5552 stringify!(db_handle)
5553 )
5554 );
5555 assert_eq!(
5556 unsafe { ::std::ptr::addr_of!((*ptr).declare_vtab) as usize - ptr as usize },
5557 400usize,
5558 concat!(
5559 "Offset of field: ",
5560 stringify!(sqlite3_api_routines),
5561 "::",
5562 stringify!(declare_vtab)
5563 )
5564 );
5565 assert_eq!(
5566 unsafe { ::std::ptr::addr_of!((*ptr).enable_shared_cache) as usize - ptr as usize },
5567 408usize,
5568 concat!(
5569 "Offset of field: ",
5570 stringify!(sqlite3_api_routines),
5571 "::",
5572 stringify!(enable_shared_cache)
5573 )
5574 );
5575 assert_eq!(
5576 unsafe { ::std::ptr::addr_of!((*ptr).errcode) as usize - ptr as usize },
5577 416usize,
5578 concat!(
5579 "Offset of field: ",
5580 stringify!(sqlite3_api_routines),
5581 "::",
5582 stringify!(errcode)
5583 )
5584 );
5585 assert_eq!(
5586 unsafe { ::std::ptr::addr_of!((*ptr).errmsg) as usize - ptr as usize },
5587 424usize,
5588 concat!(
5589 "Offset of field: ",
5590 stringify!(sqlite3_api_routines),
5591 "::",
5592 stringify!(errmsg)
5593 )
5594 );
5595 assert_eq!(
5596 unsafe { ::std::ptr::addr_of!((*ptr).errmsg16) as usize - ptr as usize },
5597 432usize,
5598 concat!(
5599 "Offset of field: ",
5600 stringify!(sqlite3_api_routines),
5601 "::",
5602 stringify!(errmsg16)
5603 )
5604 );
5605 assert_eq!(
5606 unsafe { ::std::ptr::addr_of!((*ptr).exec) as usize - ptr as usize },
5607 440usize,
5608 concat!(
5609 "Offset of field: ",
5610 stringify!(sqlite3_api_routines),
5611 "::",
5612 stringify!(exec)
5613 )
5614 );
5615 assert_eq!(
5616 unsafe { ::std::ptr::addr_of!((*ptr).expired) as usize - ptr as usize },
5617 448usize,
5618 concat!(
5619 "Offset of field: ",
5620 stringify!(sqlite3_api_routines),
5621 "::",
5622 stringify!(expired)
5623 )
5624 );
5625 assert_eq!(
5626 unsafe { ::std::ptr::addr_of!((*ptr).finalize) as usize - ptr as usize },
5627 456usize,
5628 concat!(
5629 "Offset of field: ",
5630 stringify!(sqlite3_api_routines),
5631 "::",
5632 stringify!(finalize)
5633 )
5634 );
5635 assert_eq!(
5636 unsafe { ::std::ptr::addr_of!((*ptr).free) as usize - ptr as usize },
5637 464usize,
5638 concat!(
5639 "Offset of field: ",
5640 stringify!(sqlite3_api_routines),
5641 "::",
5642 stringify!(free)
5643 )
5644 );
5645 assert_eq!(
5646 unsafe { ::std::ptr::addr_of!((*ptr).free_table) as usize - ptr as usize },
5647 472usize,
5648 concat!(
5649 "Offset of field: ",
5650 stringify!(sqlite3_api_routines),
5651 "::",
5652 stringify!(free_table)
5653 )
5654 );
5655 assert_eq!(
5656 unsafe { ::std::ptr::addr_of!((*ptr).get_autocommit) as usize - ptr as usize },
5657 480usize,
5658 concat!(
5659 "Offset of field: ",
5660 stringify!(sqlite3_api_routines),
5661 "::",
5662 stringify!(get_autocommit)
5663 )
5664 );
5665 assert_eq!(
5666 unsafe { ::std::ptr::addr_of!((*ptr).get_auxdata) as usize - ptr as usize },
5667 488usize,
5668 concat!(
5669 "Offset of field: ",
5670 stringify!(sqlite3_api_routines),
5671 "::",
5672 stringify!(get_auxdata)
5673 )
5674 );
5675 assert_eq!(
5676 unsafe { ::std::ptr::addr_of!((*ptr).get_table) as usize - ptr as usize },
5677 496usize,
5678 concat!(
5679 "Offset of field: ",
5680 stringify!(sqlite3_api_routines),
5681 "::",
5682 stringify!(get_table)
5683 )
5684 );
5685 assert_eq!(
5686 unsafe { ::std::ptr::addr_of!((*ptr).global_recover) as usize - ptr as usize },
5687 504usize,
5688 concat!(
5689 "Offset of field: ",
5690 stringify!(sqlite3_api_routines),
5691 "::",
5692 stringify!(global_recover)
5693 )
5694 );
5695 assert_eq!(
5696 unsafe { ::std::ptr::addr_of!((*ptr).interruptx) as usize - ptr as usize },
5697 512usize,
5698 concat!(
5699 "Offset of field: ",
5700 stringify!(sqlite3_api_routines),
5701 "::",
5702 stringify!(interruptx)
5703 )
5704 );
5705 assert_eq!(
5706 unsafe { ::std::ptr::addr_of!((*ptr).last_insert_rowid) as usize - ptr as usize },
5707 520usize,
5708 concat!(
5709 "Offset of field: ",
5710 stringify!(sqlite3_api_routines),
5711 "::",
5712 stringify!(last_insert_rowid)
5713 )
5714 );
5715 assert_eq!(
5716 unsafe { ::std::ptr::addr_of!((*ptr).libversion) as usize - ptr as usize },
5717 528usize,
5718 concat!(
5719 "Offset of field: ",
5720 stringify!(sqlite3_api_routines),
5721 "::",
5722 stringify!(libversion)
5723 )
5724 );
5725 assert_eq!(
5726 unsafe { ::std::ptr::addr_of!((*ptr).libversion_number) as usize - ptr as usize },
5727 536usize,
5728 concat!(
5729 "Offset of field: ",
5730 stringify!(sqlite3_api_routines),
5731 "::",
5732 stringify!(libversion_number)
5733 )
5734 );
5735 assert_eq!(
5736 unsafe { ::std::ptr::addr_of!((*ptr).malloc) as usize - ptr as usize },
5737 544usize,
5738 concat!(
5739 "Offset of field: ",
5740 stringify!(sqlite3_api_routines),
5741 "::",
5742 stringify!(malloc)
5743 )
5744 );
5745 assert_eq!(
5746 unsafe { ::std::ptr::addr_of!((*ptr).mprintf) as usize - ptr as usize },
5747 552usize,
5748 concat!(
5749 "Offset of field: ",
5750 stringify!(sqlite3_api_routines),
5751 "::",
5752 stringify!(mprintf)
5753 )
5754 );
5755 assert_eq!(
5756 unsafe { ::std::ptr::addr_of!((*ptr).open) as usize - ptr as usize },
5757 560usize,
5758 concat!(
5759 "Offset of field: ",
5760 stringify!(sqlite3_api_routines),
5761 "::",
5762 stringify!(open)
5763 )
5764 );
5765 assert_eq!(
5766 unsafe { ::std::ptr::addr_of!((*ptr).open16) as usize - ptr as usize },
5767 568usize,
5768 concat!(
5769 "Offset of field: ",
5770 stringify!(sqlite3_api_routines),
5771 "::",
5772 stringify!(open16)
5773 )
5774 );
5775 assert_eq!(
5776 unsafe { ::std::ptr::addr_of!((*ptr).prepare) as usize - ptr as usize },
5777 576usize,
5778 concat!(
5779 "Offset of field: ",
5780 stringify!(sqlite3_api_routines),
5781 "::",
5782 stringify!(prepare)
5783 )
5784 );
5785 assert_eq!(
5786 unsafe { ::std::ptr::addr_of!((*ptr).prepare16) as usize - ptr as usize },
5787 584usize,
5788 concat!(
5789 "Offset of field: ",
5790 stringify!(sqlite3_api_routines),
5791 "::",
5792 stringify!(prepare16)
5793 )
5794 );
5795 assert_eq!(
5796 unsafe { ::std::ptr::addr_of!((*ptr).profile) as usize - ptr as usize },
5797 592usize,
5798 concat!(
5799 "Offset of field: ",
5800 stringify!(sqlite3_api_routines),
5801 "::",
5802 stringify!(profile)
5803 )
5804 );
5805 assert_eq!(
5806 unsafe { ::std::ptr::addr_of!((*ptr).progress_handler) as usize - ptr as usize },
5807 600usize,
5808 concat!(
5809 "Offset of field: ",
5810 stringify!(sqlite3_api_routines),
5811 "::",
5812 stringify!(progress_handler)
5813 )
5814 );
5815 assert_eq!(
5816 unsafe { ::std::ptr::addr_of!((*ptr).realloc) as usize - ptr as usize },
5817 608usize,
5818 concat!(
5819 "Offset of field: ",
5820 stringify!(sqlite3_api_routines),
5821 "::",
5822 stringify!(realloc)
5823 )
5824 );
5825 assert_eq!(
5826 unsafe { ::std::ptr::addr_of!((*ptr).reset) as usize - ptr as usize },
5827 616usize,
5828 concat!(
5829 "Offset of field: ",
5830 stringify!(sqlite3_api_routines),
5831 "::",
5832 stringify!(reset)
5833 )
5834 );
5835 assert_eq!(
5836 unsafe { ::std::ptr::addr_of!((*ptr).result_blob) as usize - ptr as usize },
5837 624usize,
5838 concat!(
5839 "Offset of field: ",
5840 stringify!(sqlite3_api_routines),
5841 "::",
5842 stringify!(result_blob)
5843 )
5844 );
5845 assert_eq!(
5846 unsafe { ::std::ptr::addr_of!((*ptr).result_double) as usize - ptr as usize },
5847 632usize,
5848 concat!(
5849 "Offset of field: ",
5850 stringify!(sqlite3_api_routines),
5851 "::",
5852 stringify!(result_double)
5853 )
5854 );
5855 assert_eq!(
5856 unsafe { ::std::ptr::addr_of!((*ptr).result_error) as usize - ptr as usize },
5857 640usize,
5858 concat!(
5859 "Offset of field: ",
5860 stringify!(sqlite3_api_routines),
5861 "::",
5862 stringify!(result_error)
5863 )
5864 );
5865 assert_eq!(
5866 unsafe { ::std::ptr::addr_of!((*ptr).result_error16) as usize - ptr as usize },
5867 648usize,
5868 concat!(
5869 "Offset of field: ",
5870 stringify!(sqlite3_api_routines),
5871 "::",
5872 stringify!(result_error16)
5873 )
5874 );
5875 assert_eq!(
5876 unsafe { ::std::ptr::addr_of!((*ptr).result_int) as usize - ptr as usize },
5877 656usize,
5878 concat!(
5879 "Offset of field: ",
5880 stringify!(sqlite3_api_routines),
5881 "::",
5882 stringify!(result_int)
5883 )
5884 );
5885 assert_eq!(
5886 unsafe { ::std::ptr::addr_of!((*ptr).result_int64) as usize - ptr as usize },
5887 664usize,
5888 concat!(
5889 "Offset of field: ",
5890 stringify!(sqlite3_api_routines),
5891 "::",
5892 stringify!(result_int64)
5893 )
5894 );
5895 assert_eq!(
5896 unsafe { ::std::ptr::addr_of!((*ptr).result_null) as usize - ptr as usize },
5897 672usize,
5898 concat!(
5899 "Offset of field: ",
5900 stringify!(sqlite3_api_routines),
5901 "::",
5902 stringify!(result_null)
5903 )
5904 );
5905 assert_eq!(
5906 unsafe { ::std::ptr::addr_of!((*ptr).result_text) as usize - ptr as usize },
5907 680usize,
5908 concat!(
5909 "Offset of field: ",
5910 stringify!(sqlite3_api_routines),
5911 "::",
5912 stringify!(result_text)
5913 )
5914 );
5915 assert_eq!(
5916 unsafe { ::std::ptr::addr_of!((*ptr).result_text16) as usize - ptr as usize },
5917 688usize,
5918 concat!(
5919 "Offset of field: ",
5920 stringify!(sqlite3_api_routines),
5921 "::",
5922 stringify!(result_text16)
5923 )
5924 );
5925 assert_eq!(
5926 unsafe { ::std::ptr::addr_of!((*ptr).result_text16be) as usize - ptr as usize },
5927 696usize,
5928 concat!(
5929 "Offset of field: ",
5930 stringify!(sqlite3_api_routines),
5931 "::",
5932 stringify!(result_text16be)
5933 )
5934 );
5935 assert_eq!(
5936 unsafe { ::std::ptr::addr_of!((*ptr).result_text16le) as usize - ptr as usize },
5937 704usize,
5938 concat!(
5939 "Offset of field: ",
5940 stringify!(sqlite3_api_routines),
5941 "::",
5942 stringify!(result_text16le)
5943 )
5944 );
5945 assert_eq!(
5946 unsafe { ::std::ptr::addr_of!((*ptr).result_value) as usize - ptr as usize },
5947 712usize,
5948 concat!(
5949 "Offset of field: ",
5950 stringify!(sqlite3_api_routines),
5951 "::",
5952 stringify!(result_value)
5953 )
5954 );
5955 assert_eq!(
5956 unsafe { ::std::ptr::addr_of!((*ptr).rollback_hook) as usize - ptr as usize },
5957 720usize,
5958 concat!(
5959 "Offset of field: ",
5960 stringify!(sqlite3_api_routines),
5961 "::",
5962 stringify!(rollback_hook)
5963 )
5964 );
5965 assert_eq!(
5966 unsafe { ::std::ptr::addr_of!((*ptr).set_authorizer) as usize - ptr as usize },
5967 728usize,
5968 concat!(
5969 "Offset of field: ",
5970 stringify!(sqlite3_api_routines),
5971 "::",
5972 stringify!(set_authorizer)
5973 )
5974 );
5975 assert_eq!(
5976 unsafe { ::std::ptr::addr_of!((*ptr).set_auxdata) as usize - ptr as usize },
5977 736usize,
5978 concat!(
5979 "Offset of field: ",
5980 stringify!(sqlite3_api_routines),
5981 "::",
5982 stringify!(set_auxdata)
5983 )
5984 );
5985 assert_eq!(
5986 unsafe { ::std::ptr::addr_of!((*ptr).xsnprintf) as usize - ptr as usize },
5987 744usize,
5988 concat!(
5989 "Offset of field: ",
5990 stringify!(sqlite3_api_routines),
5991 "::",
5992 stringify!(xsnprintf)
5993 )
5994 );
5995 assert_eq!(
5996 unsafe { ::std::ptr::addr_of!((*ptr).step) as usize - ptr as usize },
5997 752usize,
5998 concat!(
5999 "Offset of field: ",
6000 stringify!(sqlite3_api_routines),
6001 "::",
6002 stringify!(step)
6003 )
6004 );
6005 assert_eq!(
6006 unsafe { ::std::ptr::addr_of!((*ptr).table_column_metadata) as usize - ptr as usize },
6007 760usize,
6008 concat!(
6009 "Offset of field: ",
6010 stringify!(sqlite3_api_routines),
6011 "::",
6012 stringify!(table_column_metadata)
6013 )
6014 );
6015 assert_eq!(
6016 unsafe { ::std::ptr::addr_of!((*ptr).thread_cleanup) as usize - ptr as usize },
6017 768usize,
6018 concat!(
6019 "Offset of field: ",
6020 stringify!(sqlite3_api_routines),
6021 "::",
6022 stringify!(thread_cleanup)
6023 )
6024 );
6025 assert_eq!(
6026 unsafe { ::std::ptr::addr_of!((*ptr).total_changes) as usize - ptr as usize },
6027 776usize,
6028 concat!(
6029 "Offset of field: ",
6030 stringify!(sqlite3_api_routines),
6031 "::",
6032 stringify!(total_changes)
6033 )
6034 );
6035 assert_eq!(
6036 unsafe { ::std::ptr::addr_of!((*ptr).trace) as usize - ptr as usize },
6037 784usize,
6038 concat!(
6039 "Offset of field: ",
6040 stringify!(sqlite3_api_routines),
6041 "::",
6042 stringify!(trace)
6043 )
6044 );
6045 assert_eq!(
6046 unsafe { ::std::ptr::addr_of!((*ptr).transfer_bindings) as usize - ptr as usize },
6047 792usize,
6048 concat!(
6049 "Offset of field: ",
6050 stringify!(sqlite3_api_routines),
6051 "::",
6052 stringify!(transfer_bindings)
6053 )
6054 );
6055 assert_eq!(
6056 unsafe { ::std::ptr::addr_of!((*ptr).update_hook) as usize - ptr as usize },
6057 800usize,
6058 concat!(
6059 "Offset of field: ",
6060 stringify!(sqlite3_api_routines),
6061 "::",
6062 stringify!(update_hook)
6063 )
6064 );
6065 assert_eq!(
6066 unsafe { ::std::ptr::addr_of!((*ptr).user_data) as usize - ptr as usize },
6067 808usize,
6068 concat!(
6069 "Offset of field: ",
6070 stringify!(sqlite3_api_routines),
6071 "::",
6072 stringify!(user_data)
6073 )
6074 );
6075 assert_eq!(
6076 unsafe { ::std::ptr::addr_of!((*ptr).value_blob) as usize - ptr as usize },
6077 816usize,
6078 concat!(
6079 "Offset of field: ",
6080 stringify!(sqlite3_api_routines),
6081 "::",
6082 stringify!(value_blob)
6083 )
6084 );
6085 assert_eq!(
6086 unsafe { ::std::ptr::addr_of!((*ptr).value_bytes) as usize - ptr as usize },
6087 824usize,
6088 concat!(
6089 "Offset of field: ",
6090 stringify!(sqlite3_api_routines),
6091 "::",
6092 stringify!(value_bytes)
6093 )
6094 );
6095 assert_eq!(
6096 unsafe { ::std::ptr::addr_of!((*ptr).value_bytes16) as usize - ptr as usize },
6097 832usize,
6098 concat!(
6099 "Offset of field: ",
6100 stringify!(sqlite3_api_routines),
6101 "::",
6102 stringify!(value_bytes16)
6103 )
6104 );
6105 assert_eq!(
6106 unsafe { ::std::ptr::addr_of!((*ptr).value_double) as usize - ptr as usize },
6107 840usize,
6108 concat!(
6109 "Offset of field: ",
6110 stringify!(sqlite3_api_routines),
6111 "::",
6112 stringify!(value_double)
6113 )
6114 );
6115 assert_eq!(
6116 unsafe { ::std::ptr::addr_of!((*ptr).value_int) as usize - ptr as usize },
6117 848usize,
6118 concat!(
6119 "Offset of field: ",
6120 stringify!(sqlite3_api_routines),
6121 "::",
6122 stringify!(value_int)
6123 )
6124 );
6125 assert_eq!(
6126 unsafe { ::std::ptr::addr_of!((*ptr).value_int64) as usize - ptr as usize },
6127 856usize,
6128 concat!(
6129 "Offset of field: ",
6130 stringify!(sqlite3_api_routines),
6131 "::",
6132 stringify!(value_int64)
6133 )
6134 );
6135 assert_eq!(
6136 unsafe { ::std::ptr::addr_of!((*ptr).value_numeric_type) as usize - ptr as usize },
6137 864usize,
6138 concat!(
6139 "Offset of field: ",
6140 stringify!(sqlite3_api_routines),
6141 "::",
6142 stringify!(value_numeric_type)
6143 )
6144 );
6145 assert_eq!(
6146 unsafe { ::std::ptr::addr_of!((*ptr).value_text) as usize - ptr as usize },
6147 872usize,
6148 concat!(
6149 "Offset of field: ",
6150 stringify!(sqlite3_api_routines),
6151 "::",
6152 stringify!(value_text)
6153 )
6154 );
6155 assert_eq!(
6156 unsafe { ::std::ptr::addr_of!((*ptr).value_text16) as usize - ptr as usize },
6157 880usize,
6158 concat!(
6159 "Offset of field: ",
6160 stringify!(sqlite3_api_routines),
6161 "::",
6162 stringify!(value_text16)
6163 )
6164 );
6165 assert_eq!(
6166 unsafe { ::std::ptr::addr_of!((*ptr).value_text16be) as usize - ptr as usize },
6167 888usize,
6168 concat!(
6169 "Offset of field: ",
6170 stringify!(sqlite3_api_routines),
6171 "::",
6172 stringify!(value_text16be)
6173 )
6174 );
6175 assert_eq!(
6176 unsafe { ::std::ptr::addr_of!((*ptr).value_text16le) as usize - ptr as usize },
6177 896usize,
6178 concat!(
6179 "Offset of field: ",
6180 stringify!(sqlite3_api_routines),
6181 "::",
6182 stringify!(value_text16le)
6183 )
6184 );
6185 assert_eq!(
6186 unsafe { ::std::ptr::addr_of!((*ptr).value_type) as usize - ptr as usize },
6187 904usize,
6188 concat!(
6189 "Offset of field: ",
6190 stringify!(sqlite3_api_routines),
6191 "::",
6192 stringify!(value_type)
6193 )
6194 );
6195 assert_eq!(
6196 unsafe { ::std::ptr::addr_of!((*ptr).vmprintf) as usize - ptr as usize },
6197 912usize,
6198 concat!(
6199 "Offset of field: ",
6200 stringify!(sqlite3_api_routines),
6201 "::",
6202 stringify!(vmprintf)
6203 )
6204 );
6205 assert_eq!(
6206 unsafe { ::std::ptr::addr_of!((*ptr).overload_function) as usize - ptr as usize },
6207 920usize,
6208 concat!(
6209 "Offset of field: ",
6210 stringify!(sqlite3_api_routines),
6211 "::",
6212 stringify!(overload_function)
6213 )
6214 );
6215 assert_eq!(
6216 unsafe { ::std::ptr::addr_of!((*ptr).prepare_v2) as usize - ptr as usize },
6217 928usize,
6218 concat!(
6219 "Offset of field: ",
6220 stringify!(sqlite3_api_routines),
6221 "::",
6222 stringify!(prepare_v2)
6223 )
6224 );
6225 assert_eq!(
6226 unsafe { ::std::ptr::addr_of!((*ptr).prepare16_v2) as usize - ptr as usize },
6227 936usize,
6228 concat!(
6229 "Offset of field: ",
6230 stringify!(sqlite3_api_routines),
6231 "::",
6232 stringify!(prepare16_v2)
6233 )
6234 );
6235 assert_eq!(
6236 unsafe { ::std::ptr::addr_of!((*ptr).clear_bindings) as usize - ptr as usize },
6237 944usize,
6238 concat!(
6239 "Offset of field: ",
6240 stringify!(sqlite3_api_routines),
6241 "::",
6242 stringify!(clear_bindings)
6243 )
6244 );
6245 assert_eq!(
6246 unsafe { ::std::ptr::addr_of!((*ptr).create_module_v2) as usize - ptr as usize },
6247 952usize,
6248 concat!(
6249 "Offset of field: ",
6250 stringify!(sqlite3_api_routines),
6251 "::",
6252 stringify!(create_module_v2)
6253 )
6254 );
6255 assert_eq!(
6256 unsafe { ::std::ptr::addr_of!((*ptr).bind_zeroblob) as usize - ptr as usize },
6257 960usize,
6258 concat!(
6259 "Offset of field: ",
6260 stringify!(sqlite3_api_routines),
6261 "::",
6262 stringify!(bind_zeroblob)
6263 )
6264 );
6265 assert_eq!(
6266 unsafe { ::std::ptr::addr_of!((*ptr).blob_bytes) as usize - ptr as usize },
6267 968usize,
6268 concat!(
6269 "Offset of field: ",
6270 stringify!(sqlite3_api_routines),
6271 "::",
6272 stringify!(blob_bytes)
6273 )
6274 );
6275 assert_eq!(
6276 unsafe { ::std::ptr::addr_of!((*ptr).blob_close) as usize - ptr as usize },
6277 976usize,
6278 concat!(
6279 "Offset of field: ",
6280 stringify!(sqlite3_api_routines),
6281 "::",
6282 stringify!(blob_close)
6283 )
6284 );
6285 assert_eq!(
6286 unsafe { ::std::ptr::addr_of!((*ptr).blob_open) as usize - ptr as usize },
6287 984usize,
6288 concat!(
6289 "Offset of field: ",
6290 stringify!(sqlite3_api_routines),
6291 "::",
6292 stringify!(blob_open)
6293 )
6294 );
6295 assert_eq!(
6296 unsafe { ::std::ptr::addr_of!((*ptr).blob_read) as usize - ptr as usize },
6297 992usize,
6298 concat!(
6299 "Offset of field: ",
6300 stringify!(sqlite3_api_routines),
6301 "::",
6302 stringify!(blob_read)
6303 )
6304 );
6305 assert_eq!(
6306 unsafe { ::std::ptr::addr_of!((*ptr).blob_write) as usize - ptr as usize },
6307 1000usize,
6308 concat!(
6309 "Offset of field: ",
6310 stringify!(sqlite3_api_routines),
6311 "::",
6312 stringify!(blob_write)
6313 )
6314 );
6315 assert_eq!(
6316 unsafe { ::std::ptr::addr_of!((*ptr).create_collation_v2) as usize - ptr as usize },
6317 1008usize,
6318 concat!(
6319 "Offset of field: ",
6320 stringify!(sqlite3_api_routines),
6321 "::",
6322 stringify!(create_collation_v2)
6323 )
6324 );
6325 assert_eq!(
6326 unsafe { ::std::ptr::addr_of!((*ptr).file_control) as usize - ptr as usize },
6327 1016usize,
6328 concat!(
6329 "Offset of field: ",
6330 stringify!(sqlite3_api_routines),
6331 "::",
6332 stringify!(file_control)
6333 )
6334 );
6335 assert_eq!(
6336 unsafe { ::std::ptr::addr_of!((*ptr).memory_highwater) as usize - ptr as usize },
6337 1024usize,
6338 concat!(
6339 "Offset of field: ",
6340 stringify!(sqlite3_api_routines),
6341 "::",
6342 stringify!(memory_highwater)
6343 )
6344 );
6345 assert_eq!(
6346 unsafe { ::std::ptr::addr_of!((*ptr).memory_used) as usize - ptr as usize },
6347 1032usize,
6348 concat!(
6349 "Offset of field: ",
6350 stringify!(sqlite3_api_routines),
6351 "::",
6352 stringify!(memory_used)
6353 )
6354 );
6355 assert_eq!(
6356 unsafe { ::std::ptr::addr_of!((*ptr).mutex_alloc) as usize - ptr as usize },
6357 1040usize,
6358 concat!(
6359 "Offset of field: ",
6360 stringify!(sqlite3_api_routines),
6361 "::",
6362 stringify!(mutex_alloc)
6363 )
6364 );
6365 assert_eq!(
6366 unsafe { ::std::ptr::addr_of!((*ptr).mutex_enter) as usize - ptr as usize },
6367 1048usize,
6368 concat!(
6369 "Offset of field: ",
6370 stringify!(sqlite3_api_routines),
6371 "::",
6372 stringify!(mutex_enter)
6373 )
6374 );
6375 assert_eq!(
6376 unsafe { ::std::ptr::addr_of!((*ptr).mutex_free) as usize - ptr as usize },
6377 1056usize,
6378 concat!(
6379 "Offset of field: ",
6380 stringify!(sqlite3_api_routines),
6381 "::",
6382 stringify!(mutex_free)
6383 )
6384 );
6385 assert_eq!(
6386 unsafe { ::std::ptr::addr_of!((*ptr).mutex_leave) as usize - ptr as usize },
6387 1064usize,
6388 concat!(
6389 "Offset of field: ",
6390 stringify!(sqlite3_api_routines),
6391 "::",
6392 stringify!(mutex_leave)
6393 )
6394 );
6395 assert_eq!(
6396 unsafe { ::std::ptr::addr_of!((*ptr).mutex_try) as usize - ptr as usize },
6397 1072usize,
6398 concat!(
6399 "Offset of field: ",
6400 stringify!(sqlite3_api_routines),
6401 "::",
6402 stringify!(mutex_try)
6403 )
6404 );
6405 assert_eq!(
6406 unsafe { ::std::ptr::addr_of!((*ptr).open_v2) as usize - ptr as usize },
6407 1080usize,
6408 concat!(
6409 "Offset of field: ",
6410 stringify!(sqlite3_api_routines),
6411 "::",
6412 stringify!(open_v2)
6413 )
6414 );
6415 assert_eq!(
6416 unsafe { ::std::ptr::addr_of!((*ptr).release_memory) as usize - ptr as usize },
6417 1088usize,
6418 concat!(
6419 "Offset of field: ",
6420 stringify!(sqlite3_api_routines),
6421 "::",
6422 stringify!(release_memory)
6423 )
6424 );
6425 assert_eq!(
6426 unsafe { ::std::ptr::addr_of!((*ptr).result_error_nomem) as usize - ptr as usize },
6427 1096usize,
6428 concat!(
6429 "Offset of field: ",
6430 stringify!(sqlite3_api_routines),
6431 "::",
6432 stringify!(result_error_nomem)
6433 )
6434 );
6435 assert_eq!(
6436 unsafe { ::std::ptr::addr_of!((*ptr).result_error_toobig) as usize - ptr as usize },
6437 1104usize,
6438 concat!(
6439 "Offset of field: ",
6440 stringify!(sqlite3_api_routines),
6441 "::",
6442 stringify!(result_error_toobig)
6443 )
6444 );
6445 assert_eq!(
6446 unsafe { ::std::ptr::addr_of!((*ptr).sleep) as usize - ptr as usize },
6447 1112usize,
6448 concat!(
6449 "Offset of field: ",
6450 stringify!(sqlite3_api_routines),
6451 "::",
6452 stringify!(sleep)
6453 )
6454 );
6455 assert_eq!(
6456 unsafe { ::std::ptr::addr_of!((*ptr).soft_heap_limit) as usize - ptr as usize },
6457 1120usize,
6458 concat!(
6459 "Offset of field: ",
6460 stringify!(sqlite3_api_routines),
6461 "::",
6462 stringify!(soft_heap_limit)
6463 )
6464 );
6465 assert_eq!(
6466 unsafe { ::std::ptr::addr_of!((*ptr).vfs_find) as usize - ptr as usize },
6467 1128usize,
6468 concat!(
6469 "Offset of field: ",
6470 stringify!(sqlite3_api_routines),
6471 "::",
6472 stringify!(vfs_find)
6473 )
6474 );
6475 assert_eq!(
6476 unsafe { ::std::ptr::addr_of!((*ptr).vfs_register) as usize - ptr as usize },
6477 1136usize,
6478 concat!(
6479 "Offset of field: ",
6480 stringify!(sqlite3_api_routines),
6481 "::",
6482 stringify!(vfs_register)
6483 )
6484 );
6485 assert_eq!(
6486 unsafe { ::std::ptr::addr_of!((*ptr).vfs_unregister) as usize - ptr as usize },
6487 1144usize,
6488 concat!(
6489 "Offset of field: ",
6490 stringify!(sqlite3_api_routines),
6491 "::",
6492 stringify!(vfs_unregister)
6493 )
6494 );
6495 assert_eq!(
6496 unsafe { ::std::ptr::addr_of!((*ptr).xthreadsafe) as usize - ptr as usize },
6497 1152usize,
6498 concat!(
6499 "Offset of field: ",
6500 stringify!(sqlite3_api_routines),
6501 "::",
6502 stringify!(xthreadsafe)
6503 )
6504 );
6505 assert_eq!(
6506 unsafe { ::std::ptr::addr_of!((*ptr).result_zeroblob) as usize - ptr as usize },
6507 1160usize,
6508 concat!(
6509 "Offset of field: ",
6510 stringify!(sqlite3_api_routines),
6511 "::",
6512 stringify!(result_zeroblob)
6513 )
6514 );
6515 assert_eq!(
6516 unsafe { ::std::ptr::addr_of!((*ptr).result_error_code) as usize - ptr as usize },
6517 1168usize,
6518 concat!(
6519 "Offset of field: ",
6520 stringify!(sqlite3_api_routines),
6521 "::",
6522 stringify!(result_error_code)
6523 )
6524 );
6525 assert_eq!(
6526 unsafe { ::std::ptr::addr_of!((*ptr).test_control) as usize - ptr as usize },
6527 1176usize,
6528 concat!(
6529 "Offset of field: ",
6530 stringify!(sqlite3_api_routines),
6531 "::",
6532 stringify!(test_control)
6533 )
6534 );
6535 assert_eq!(
6536 unsafe { ::std::ptr::addr_of!((*ptr).randomness) as usize - ptr as usize },
6537 1184usize,
6538 concat!(
6539 "Offset of field: ",
6540 stringify!(sqlite3_api_routines),
6541 "::",
6542 stringify!(randomness)
6543 )
6544 );
6545 assert_eq!(
6546 unsafe { ::std::ptr::addr_of!((*ptr).context_db_handle) as usize - ptr as usize },
6547 1192usize,
6548 concat!(
6549 "Offset of field: ",
6550 stringify!(sqlite3_api_routines),
6551 "::",
6552 stringify!(context_db_handle)
6553 )
6554 );
6555 assert_eq!(
6556 unsafe { ::std::ptr::addr_of!((*ptr).extended_result_codes) as usize - ptr as usize },
6557 1200usize,
6558 concat!(
6559 "Offset of field: ",
6560 stringify!(sqlite3_api_routines),
6561 "::",
6562 stringify!(extended_result_codes)
6563 )
6564 );
6565 assert_eq!(
6566 unsafe { ::std::ptr::addr_of!((*ptr).limit) as usize - ptr as usize },
6567 1208usize,
6568 concat!(
6569 "Offset of field: ",
6570 stringify!(sqlite3_api_routines),
6571 "::",
6572 stringify!(limit)
6573 )
6574 );
6575 assert_eq!(
6576 unsafe { ::std::ptr::addr_of!((*ptr).next_stmt) as usize - ptr as usize },
6577 1216usize,
6578 concat!(
6579 "Offset of field: ",
6580 stringify!(sqlite3_api_routines),
6581 "::",
6582 stringify!(next_stmt)
6583 )
6584 );
6585 assert_eq!(
6586 unsafe { ::std::ptr::addr_of!((*ptr).sql) as usize - ptr as usize },
6587 1224usize,
6588 concat!(
6589 "Offset of field: ",
6590 stringify!(sqlite3_api_routines),
6591 "::",
6592 stringify!(sql)
6593 )
6594 );
6595 assert_eq!(
6596 unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
6597 1232usize,
6598 concat!(
6599 "Offset of field: ",
6600 stringify!(sqlite3_api_routines),
6601 "::",
6602 stringify!(status)
6603 )
6604 );
6605 assert_eq!(
6606 unsafe { ::std::ptr::addr_of!((*ptr).backup_finish) as usize - ptr as usize },
6607 1240usize,
6608 concat!(
6609 "Offset of field: ",
6610 stringify!(sqlite3_api_routines),
6611 "::",
6612 stringify!(backup_finish)
6613 )
6614 );
6615 assert_eq!(
6616 unsafe { ::std::ptr::addr_of!((*ptr).backup_init) as usize - ptr as usize },
6617 1248usize,
6618 concat!(
6619 "Offset of field: ",
6620 stringify!(sqlite3_api_routines),
6621 "::",
6622 stringify!(backup_init)
6623 )
6624 );
6625 assert_eq!(
6626 unsafe { ::std::ptr::addr_of!((*ptr).backup_pagecount) as usize - ptr as usize },
6627 1256usize,
6628 concat!(
6629 "Offset of field: ",
6630 stringify!(sqlite3_api_routines),
6631 "::",
6632 stringify!(backup_pagecount)
6633 )
6634 );
6635 assert_eq!(
6636 unsafe { ::std::ptr::addr_of!((*ptr).backup_remaining) as usize - ptr as usize },
6637 1264usize,
6638 concat!(
6639 "Offset of field: ",
6640 stringify!(sqlite3_api_routines),
6641 "::",
6642 stringify!(backup_remaining)
6643 )
6644 );
6645 assert_eq!(
6646 unsafe { ::std::ptr::addr_of!((*ptr).backup_step) as usize - ptr as usize },
6647 1272usize,
6648 concat!(
6649 "Offset of field: ",
6650 stringify!(sqlite3_api_routines),
6651 "::",
6652 stringify!(backup_step)
6653 )
6654 );
6655 assert_eq!(
6656 unsafe { ::std::ptr::addr_of!((*ptr).compileoption_get) as usize - ptr as usize },
6657 1280usize,
6658 concat!(
6659 "Offset of field: ",
6660 stringify!(sqlite3_api_routines),
6661 "::",
6662 stringify!(compileoption_get)
6663 )
6664 );
6665 assert_eq!(
6666 unsafe { ::std::ptr::addr_of!((*ptr).compileoption_used) as usize - ptr as usize },
6667 1288usize,
6668 concat!(
6669 "Offset of field: ",
6670 stringify!(sqlite3_api_routines),
6671 "::",
6672 stringify!(compileoption_used)
6673 )
6674 );
6675 assert_eq!(
6676 unsafe { ::std::ptr::addr_of!((*ptr).create_function_v2) as usize - ptr as usize },
6677 1296usize,
6678 concat!(
6679 "Offset of field: ",
6680 stringify!(sqlite3_api_routines),
6681 "::",
6682 stringify!(create_function_v2)
6683 )
6684 );
6685 assert_eq!(
6686 unsafe { ::std::ptr::addr_of!((*ptr).db_config) as usize - ptr as usize },
6687 1304usize,
6688 concat!(
6689 "Offset of field: ",
6690 stringify!(sqlite3_api_routines),
6691 "::",
6692 stringify!(db_config)
6693 )
6694 );
6695 assert_eq!(
6696 unsafe { ::std::ptr::addr_of!((*ptr).db_mutex) as usize - ptr as usize },
6697 1312usize,
6698 concat!(
6699 "Offset of field: ",
6700 stringify!(sqlite3_api_routines),
6701 "::",
6702 stringify!(db_mutex)
6703 )
6704 );
6705 assert_eq!(
6706 unsafe { ::std::ptr::addr_of!((*ptr).db_status) as usize - ptr as usize },
6707 1320usize,
6708 concat!(
6709 "Offset of field: ",
6710 stringify!(sqlite3_api_routines),
6711 "::",
6712 stringify!(db_status)
6713 )
6714 );
6715 assert_eq!(
6716 unsafe { ::std::ptr::addr_of!((*ptr).extended_errcode) as usize - ptr as usize },
6717 1328usize,
6718 concat!(
6719 "Offset of field: ",
6720 stringify!(sqlite3_api_routines),
6721 "::",
6722 stringify!(extended_errcode)
6723 )
6724 );
6725 assert_eq!(
6726 unsafe { ::std::ptr::addr_of!((*ptr).log) as usize - ptr as usize },
6727 1336usize,
6728 concat!(
6729 "Offset of field: ",
6730 stringify!(sqlite3_api_routines),
6731 "::",
6732 stringify!(log)
6733 )
6734 );
6735 assert_eq!(
6736 unsafe { ::std::ptr::addr_of!((*ptr).soft_heap_limit64) as usize - ptr as usize },
6737 1344usize,
6738 concat!(
6739 "Offset of field: ",
6740 stringify!(sqlite3_api_routines),
6741 "::",
6742 stringify!(soft_heap_limit64)
6743 )
6744 );
6745 assert_eq!(
6746 unsafe { ::std::ptr::addr_of!((*ptr).sourceid) as usize - ptr as usize },
6747 1352usize,
6748 concat!(
6749 "Offset of field: ",
6750 stringify!(sqlite3_api_routines),
6751 "::",
6752 stringify!(sourceid)
6753 )
6754 );
6755 assert_eq!(
6756 unsafe { ::std::ptr::addr_of!((*ptr).stmt_status) as usize - ptr as usize },
6757 1360usize,
6758 concat!(
6759 "Offset of field: ",
6760 stringify!(sqlite3_api_routines),
6761 "::",
6762 stringify!(stmt_status)
6763 )
6764 );
6765 assert_eq!(
6766 unsafe { ::std::ptr::addr_of!((*ptr).strnicmp) as usize - ptr as usize },
6767 1368usize,
6768 concat!(
6769 "Offset of field: ",
6770 stringify!(sqlite3_api_routines),
6771 "::",
6772 stringify!(strnicmp)
6773 )
6774 );
6775 assert_eq!(
6776 unsafe { ::std::ptr::addr_of!((*ptr).unlock_notify) as usize - ptr as usize },
6777 1376usize,
6778 concat!(
6779 "Offset of field: ",
6780 stringify!(sqlite3_api_routines),
6781 "::",
6782 stringify!(unlock_notify)
6783 )
6784 );
6785 assert_eq!(
6786 unsafe { ::std::ptr::addr_of!((*ptr).wal_autocheckpoint) as usize - ptr as usize },
6787 1384usize,
6788 concat!(
6789 "Offset of field: ",
6790 stringify!(sqlite3_api_routines),
6791 "::",
6792 stringify!(wal_autocheckpoint)
6793 )
6794 );
6795 assert_eq!(
6796 unsafe { ::std::ptr::addr_of!((*ptr).wal_checkpoint) as usize - ptr as usize },
6797 1392usize,
6798 concat!(
6799 "Offset of field: ",
6800 stringify!(sqlite3_api_routines),
6801 "::",
6802 stringify!(wal_checkpoint)
6803 )
6804 );
6805 assert_eq!(
6806 unsafe { ::std::ptr::addr_of!((*ptr).wal_hook) as usize - ptr as usize },
6807 1400usize,
6808 concat!(
6809 "Offset of field: ",
6810 stringify!(sqlite3_api_routines),
6811 "::",
6812 stringify!(wal_hook)
6813 )
6814 );
6815 assert_eq!(
6816 unsafe { ::std::ptr::addr_of!((*ptr).blob_reopen) as usize - ptr as usize },
6817 1408usize,
6818 concat!(
6819 "Offset of field: ",
6820 stringify!(sqlite3_api_routines),
6821 "::",
6822 stringify!(blob_reopen)
6823 )
6824 );
6825 assert_eq!(
6826 unsafe { ::std::ptr::addr_of!((*ptr).vtab_config) as usize - ptr as usize },
6827 1416usize,
6828 concat!(
6829 "Offset of field: ",
6830 stringify!(sqlite3_api_routines),
6831 "::",
6832 stringify!(vtab_config)
6833 )
6834 );
6835 assert_eq!(
6836 unsafe { ::std::ptr::addr_of!((*ptr).vtab_on_conflict) as usize - ptr as usize },
6837 1424usize,
6838 concat!(
6839 "Offset of field: ",
6840 stringify!(sqlite3_api_routines),
6841 "::",
6842 stringify!(vtab_on_conflict)
6843 )
6844 );
6845 assert_eq!(
6846 unsafe { ::std::ptr::addr_of!((*ptr).close_v2) as usize - ptr as usize },
6847 1432usize,
6848 concat!(
6849 "Offset of field: ",
6850 stringify!(sqlite3_api_routines),
6851 "::",
6852 stringify!(close_v2)
6853 )
6854 );
6855 assert_eq!(
6856 unsafe { ::std::ptr::addr_of!((*ptr).db_filename) as usize - ptr as usize },
6857 1440usize,
6858 concat!(
6859 "Offset of field: ",
6860 stringify!(sqlite3_api_routines),
6861 "::",
6862 stringify!(db_filename)
6863 )
6864 );
6865 assert_eq!(
6866 unsafe { ::std::ptr::addr_of!((*ptr).db_readonly) as usize - ptr as usize },
6867 1448usize,
6868 concat!(
6869 "Offset of field: ",
6870 stringify!(sqlite3_api_routines),
6871 "::",
6872 stringify!(db_readonly)
6873 )
6874 );
6875 assert_eq!(
6876 unsafe { ::std::ptr::addr_of!((*ptr).db_release_memory) as usize - ptr as usize },
6877 1456usize,
6878 concat!(
6879 "Offset of field: ",
6880 stringify!(sqlite3_api_routines),
6881 "::",
6882 stringify!(db_release_memory)
6883 )
6884 );
6885 assert_eq!(
6886 unsafe { ::std::ptr::addr_of!((*ptr).errstr) as usize - ptr as usize },
6887 1464usize,
6888 concat!(
6889 "Offset of field: ",
6890 stringify!(sqlite3_api_routines),
6891 "::",
6892 stringify!(errstr)
6893 )
6894 );
6895 assert_eq!(
6896 unsafe { ::std::ptr::addr_of!((*ptr).stmt_busy) as usize - ptr as usize },
6897 1472usize,
6898 concat!(
6899 "Offset of field: ",
6900 stringify!(sqlite3_api_routines),
6901 "::",
6902 stringify!(stmt_busy)
6903 )
6904 );
6905 assert_eq!(
6906 unsafe { ::std::ptr::addr_of!((*ptr).stmt_readonly) as usize - ptr as usize },
6907 1480usize,
6908 concat!(
6909 "Offset of field: ",
6910 stringify!(sqlite3_api_routines),
6911 "::",
6912 stringify!(stmt_readonly)
6913 )
6914 );
6915 assert_eq!(
6916 unsafe { ::std::ptr::addr_of!((*ptr).stricmp) as usize - ptr as usize },
6917 1488usize,
6918 concat!(
6919 "Offset of field: ",
6920 stringify!(sqlite3_api_routines),
6921 "::",
6922 stringify!(stricmp)
6923 )
6924 );
6925 assert_eq!(
6926 unsafe { ::std::ptr::addr_of!((*ptr).uri_boolean) as usize - ptr as usize },
6927 1496usize,
6928 concat!(
6929 "Offset of field: ",
6930 stringify!(sqlite3_api_routines),
6931 "::",
6932 stringify!(uri_boolean)
6933 )
6934 );
6935 assert_eq!(
6936 unsafe { ::std::ptr::addr_of!((*ptr).uri_int64) as usize - ptr as usize },
6937 1504usize,
6938 concat!(
6939 "Offset of field: ",
6940 stringify!(sqlite3_api_routines),
6941 "::",
6942 stringify!(uri_int64)
6943 )
6944 );
6945 assert_eq!(
6946 unsafe { ::std::ptr::addr_of!((*ptr).uri_parameter) as usize - ptr as usize },
6947 1512usize,
6948 concat!(
6949 "Offset of field: ",
6950 stringify!(sqlite3_api_routines),
6951 "::",
6952 stringify!(uri_parameter)
6953 )
6954 );
6955 assert_eq!(
6956 unsafe { ::std::ptr::addr_of!((*ptr).xvsnprintf) as usize - ptr as usize },
6957 1520usize,
6958 concat!(
6959 "Offset of field: ",
6960 stringify!(sqlite3_api_routines),
6961 "::",
6962 stringify!(xvsnprintf)
6963 )
6964 );
6965 assert_eq!(
6966 unsafe { ::std::ptr::addr_of!((*ptr).wal_checkpoint_v2) as usize - ptr as usize },
6967 1528usize,
6968 concat!(
6969 "Offset of field: ",
6970 stringify!(sqlite3_api_routines),
6971 "::",
6972 stringify!(wal_checkpoint_v2)
6973 )
6974 );
6975 assert_eq!(
6976 unsafe { ::std::ptr::addr_of!((*ptr).auto_extension) as usize - ptr as usize },
6977 1536usize,
6978 concat!(
6979 "Offset of field: ",
6980 stringify!(sqlite3_api_routines),
6981 "::",
6982 stringify!(auto_extension)
6983 )
6984 );
6985 assert_eq!(
6986 unsafe { ::std::ptr::addr_of!((*ptr).bind_blob64) as usize - ptr as usize },
6987 1544usize,
6988 concat!(
6989 "Offset of field: ",
6990 stringify!(sqlite3_api_routines),
6991 "::",
6992 stringify!(bind_blob64)
6993 )
6994 );
6995 assert_eq!(
6996 unsafe { ::std::ptr::addr_of!((*ptr).bind_text64) as usize - ptr as usize },
6997 1552usize,
6998 concat!(
6999 "Offset of field: ",
7000 stringify!(sqlite3_api_routines),
7001 "::",
7002 stringify!(bind_text64)
7003 )
7004 );
7005 assert_eq!(
7006 unsafe { ::std::ptr::addr_of!((*ptr).cancel_auto_extension) as usize - ptr as usize },
7007 1560usize,
7008 concat!(
7009 "Offset of field: ",
7010 stringify!(sqlite3_api_routines),
7011 "::",
7012 stringify!(cancel_auto_extension)
7013 )
7014 );
7015 assert_eq!(
7016 unsafe { ::std::ptr::addr_of!((*ptr).load_extension) as usize - ptr as usize },
7017 1568usize,
7018 concat!(
7019 "Offset of field: ",
7020 stringify!(sqlite3_api_routines),
7021 "::",
7022 stringify!(load_extension)
7023 )
7024 );
7025 assert_eq!(
7026 unsafe { ::std::ptr::addr_of!((*ptr).malloc64) as usize - ptr as usize },
7027 1576usize,
7028 concat!(
7029 "Offset of field: ",
7030 stringify!(sqlite3_api_routines),
7031 "::",
7032 stringify!(malloc64)
7033 )
7034 );
7035 assert_eq!(
7036 unsafe { ::std::ptr::addr_of!((*ptr).msize) as usize - ptr as usize },
7037 1584usize,
7038 concat!(
7039 "Offset of field: ",
7040 stringify!(sqlite3_api_routines),
7041 "::",
7042 stringify!(msize)
7043 )
7044 );
7045 assert_eq!(
7046 unsafe { ::std::ptr::addr_of!((*ptr).realloc64) as usize - ptr as usize },
7047 1592usize,
7048 concat!(
7049 "Offset of field: ",
7050 stringify!(sqlite3_api_routines),
7051 "::",
7052 stringify!(realloc64)
7053 )
7054 );
7055 assert_eq!(
7056 unsafe { ::std::ptr::addr_of!((*ptr).reset_auto_extension) as usize - ptr as usize },
7057 1600usize,
7058 concat!(
7059 "Offset of field: ",
7060 stringify!(sqlite3_api_routines),
7061 "::",
7062 stringify!(reset_auto_extension)
7063 )
7064 );
7065 assert_eq!(
7066 unsafe { ::std::ptr::addr_of!((*ptr).result_blob64) as usize - ptr as usize },
7067 1608usize,
7068 concat!(
7069 "Offset of field: ",
7070 stringify!(sqlite3_api_routines),
7071 "::",
7072 stringify!(result_blob64)
7073 )
7074 );
7075 assert_eq!(
7076 unsafe { ::std::ptr::addr_of!((*ptr).result_text64) as usize - ptr as usize },
7077 1616usize,
7078 concat!(
7079 "Offset of field: ",
7080 stringify!(sqlite3_api_routines),
7081 "::",
7082 stringify!(result_text64)
7083 )
7084 );
7085 assert_eq!(
7086 unsafe { ::std::ptr::addr_of!((*ptr).strglob) as usize - ptr as usize },
7087 1624usize,
7088 concat!(
7089 "Offset of field: ",
7090 stringify!(sqlite3_api_routines),
7091 "::",
7092 stringify!(strglob)
7093 )
7094 );
7095 assert_eq!(
7096 unsafe { ::std::ptr::addr_of!((*ptr).value_dup) as usize - ptr as usize },
7097 1632usize,
7098 concat!(
7099 "Offset of field: ",
7100 stringify!(sqlite3_api_routines),
7101 "::",
7102 stringify!(value_dup)
7103 )
7104 );
7105 assert_eq!(
7106 unsafe { ::std::ptr::addr_of!((*ptr).value_free) as usize - ptr as usize },
7107 1640usize,
7108 concat!(
7109 "Offset of field: ",
7110 stringify!(sqlite3_api_routines),
7111 "::",
7112 stringify!(value_free)
7113 )
7114 );
7115 assert_eq!(
7116 unsafe { ::std::ptr::addr_of!((*ptr).result_zeroblob64) as usize - ptr as usize },
7117 1648usize,
7118 concat!(
7119 "Offset of field: ",
7120 stringify!(sqlite3_api_routines),
7121 "::",
7122 stringify!(result_zeroblob64)
7123 )
7124 );
7125 assert_eq!(
7126 unsafe { ::std::ptr::addr_of!((*ptr).bind_zeroblob64) as usize - ptr as usize },
7127 1656usize,
7128 concat!(
7129 "Offset of field: ",
7130 stringify!(sqlite3_api_routines),
7131 "::",
7132 stringify!(bind_zeroblob64)
7133 )
7134 );
7135 assert_eq!(
7136 unsafe { ::std::ptr::addr_of!((*ptr).value_subtype) as usize - ptr as usize },
7137 1664usize,
7138 concat!(
7139 "Offset of field: ",
7140 stringify!(sqlite3_api_routines),
7141 "::",
7142 stringify!(value_subtype)
7143 )
7144 );
7145 assert_eq!(
7146 unsafe { ::std::ptr::addr_of!((*ptr).result_subtype) as usize - ptr as usize },
7147 1672usize,
7148 concat!(
7149 "Offset of field: ",
7150 stringify!(sqlite3_api_routines),
7151 "::",
7152 stringify!(result_subtype)
7153 )
7154 );
7155 assert_eq!(
7156 unsafe { ::std::ptr::addr_of!((*ptr).status64) as usize - ptr as usize },
7157 1680usize,
7158 concat!(
7159 "Offset of field: ",
7160 stringify!(sqlite3_api_routines),
7161 "::",
7162 stringify!(status64)
7163 )
7164 );
7165 assert_eq!(
7166 unsafe { ::std::ptr::addr_of!((*ptr).strlike) as usize - ptr as usize },
7167 1688usize,
7168 concat!(
7169 "Offset of field: ",
7170 stringify!(sqlite3_api_routines),
7171 "::",
7172 stringify!(strlike)
7173 )
7174 );
7175 assert_eq!(
7176 unsafe { ::std::ptr::addr_of!((*ptr).db_cacheflush) as usize - ptr as usize },
7177 1696usize,
7178 concat!(
7179 "Offset of field: ",
7180 stringify!(sqlite3_api_routines),
7181 "::",
7182 stringify!(db_cacheflush)
7183 )
7184 );
7185 assert_eq!(
7186 unsafe { ::std::ptr::addr_of!((*ptr).system_errno) as usize - ptr as usize },
7187 1704usize,
7188 concat!(
7189 "Offset of field: ",
7190 stringify!(sqlite3_api_routines),
7191 "::",
7192 stringify!(system_errno)
7193 )
7194 );
7195 assert_eq!(
7196 unsafe { ::std::ptr::addr_of!((*ptr).trace_v2) as usize - ptr as usize },
7197 1712usize,
7198 concat!(
7199 "Offset of field: ",
7200 stringify!(sqlite3_api_routines),
7201 "::",
7202 stringify!(trace_v2)
7203 )
7204 );
7205 assert_eq!(
7206 unsafe { ::std::ptr::addr_of!((*ptr).expanded_sql) as usize - ptr as usize },
7207 1720usize,
7208 concat!(
7209 "Offset of field: ",
7210 stringify!(sqlite3_api_routines),
7211 "::",
7212 stringify!(expanded_sql)
7213 )
7214 );
7215 assert_eq!(
7216 unsafe { ::std::ptr::addr_of!((*ptr).set_last_insert_rowid) as usize - ptr as usize },
7217 1728usize,
7218 concat!(
7219 "Offset of field: ",
7220 stringify!(sqlite3_api_routines),
7221 "::",
7222 stringify!(set_last_insert_rowid)
7223 )
7224 );
7225 assert_eq!(
7226 unsafe { ::std::ptr::addr_of!((*ptr).prepare_v3) as usize - ptr as usize },
7227 1736usize,
7228 concat!(
7229 "Offset of field: ",
7230 stringify!(sqlite3_api_routines),
7231 "::",
7232 stringify!(prepare_v3)
7233 )
7234 );
7235 assert_eq!(
7236 unsafe { ::std::ptr::addr_of!((*ptr).prepare16_v3) as usize - ptr as usize },
7237 1744usize,
7238 concat!(
7239 "Offset of field: ",
7240 stringify!(sqlite3_api_routines),
7241 "::",
7242 stringify!(prepare16_v3)
7243 )
7244 );
7245 assert_eq!(
7246 unsafe { ::std::ptr::addr_of!((*ptr).bind_pointer) as usize - ptr as usize },
7247 1752usize,
7248 concat!(
7249 "Offset of field: ",
7250 stringify!(sqlite3_api_routines),
7251 "::",
7252 stringify!(bind_pointer)
7253 )
7254 );
7255 assert_eq!(
7256 unsafe { ::std::ptr::addr_of!((*ptr).result_pointer) as usize - ptr as usize },
7257 1760usize,
7258 concat!(
7259 "Offset of field: ",
7260 stringify!(sqlite3_api_routines),
7261 "::",
7262 stringify!(result_pointer)
7263 )
7264 );
7265 assert_eq!(
7266 unsafe { ::std::ptr::addr_of!((*ptr).value_pointer) as usize - ptr as usize },
7267 1768usize,
7268 concat!(
7269 "Offset of field: ",
7270 stringify!(sqlite3_api_routines),
7271 "::",
7272 stringify!(value_pointer)
7273 )
7274 );
7275 assert_eq!(
7276 unsafe { ::std::ptr::addr_of!((*ptr).vtab_nochange) as usize - ptr as usize },
7277 1776usize,
7278 concat!(
7279 "Offset of field: ",
7280 stringify!(sqlite3_api_routines),
7281 "::",
7282 stringify!(vtab_nochange)
7283 )
7284 );
7285 assert_eq!(
7286 unsafe { ::std::ptr::addr_of!((*ptr).value_nochange) as usize - ptr as usize },
7287 1784usize,
7288 concat!(
7289 "Offset of field: ",
7290 stringify!(sqlite3_api_routines),
7291 "::",
7292 stringify!(value_nochange)
7293 )
7294 );
7295 assert_eq!(
7296 unsafe { ::std::ptr::addr_of!((*ptr).vtab_collation) as usize - ptr as usize },
7297 1792usize,
7298 concat!(
7299 "Offset of field: ",
7300 stringify!(sqlite3_api_routines),
7301 "::",
7302 stringify!(vtab_collation)
7303 )
7304 );
7305 assert_eq!(
7306 unsafe { ::std::ptr::addr_of!((*ptr).keyword_count) as usize - ptr as usize },
7307 1800usize,
7308 concat!(
7309 "Offset of field: ",
7310 stringify!(sqlite3_api_routines),
7311 "::",
7312 stringify!(keyword_count)
7313 )
7314 );
7315 assert_eq!(
7316 unsafe { ::std::ptr::addr_of!((*ptr).keyword_name) as usize - ptr as usize },
7317 1808usize,
7318 concat!(
7319 "Offset of field: ",
7320 stringify!(sqlite3_api_routines),
7321 "::",
7322 stringify!(keyword_name)
7323 )
7324 );
7325 assert_eq!(
7326 unsafe { ::std::ptr::addr_of!((*ptr).keyword_check) as usize - ptr as usize },
7327 1816usize,
7328 concat!(
7329 "Offset of field: ",
7330 stringify!(sqlite3_api_routines),
7331 "::",
7332 stringify!(keyword_check)
7333 )
7334 );
7335 assert_eq!(
7336 unsafe { ::std::ptr::addr_of!((*ptr).str_new) as usize - ptr as usize },
7337 1824usize,
7338 concat!(
7339 "Offset of field: ",
7340 stringify!(sqlite3_api_routines),
7341 "::",
7342 stringify!(str_new)
7343 )
7344 );
7345 assert_eq!(
7346 unsafe { ::std::ptr::addr_of!((*ptr).str_finish) as usize - ptr as usize },
7347 1832usize,
7348 concat!(
7349 "Offset of field: ",
7350 stringify!(sqlite3_api_routines),
7351 "::",
7352 stringify!(str_finish)
7353 )
7354 );
7355 assert_eq!(
7356 unsafe { ::std::ptr::addr_of!((*ptr).str_appendf) as usize - ptr as usize },
7357 1840usize,
7358 concat!(
7359 "Offset of field: ",
7360 stringify!(sqlite3_api_routines),
7361 "::",
7362 stringify!(str_appendf)
7363 )
7364 );
7365 assert_eq!(
7366 unsafe { ::std::ptr::addr_of!((*ptr).str_vappendf) as usize - ptr as usize },
7367 1848usize,
7368 concat!(
7369 "Offset of field: ",
7370 stringify!(sqlite3_api_routines),
7371 "::",
7372 stringify!(str_vappendf)
7373 )
7374 );
7375 assert_eq!(
7376 unsafe { ::std::ptr::addr_of!((*ptr).str_append) as usize - ptr as usize },
7377 1856usize,
7378 concat!(
7379 "Offset of field: ",
7380 stringify!(sqlite3_api_routines),
7381 "::",
7382 stringify!(str_append)
7383 )
7384 );
7385 assert_eq!(
7386 unsafe { ::std::ptr::addr_of!((*ptr).str_appendall) as usize - ptr as usize },
7387 1864usize,
7388 concat!(
7389 "Offset of field: ",
7390 stringify!(sqlite3_api_routines),
7391 "::",
7392 stringify!(str_appendall)
7393 )
7394 );
7395 assert_eq!(
7396 unsafe { ::std::ptr::addr_of!((*ptr).str_appendchar) as usize - ptr as usize },
7397 1872usize,
7398 concat!(
7399 "Offset of field: ",
7400 stringify!(sqlite3_api_routines),
7401 "::",
7402 stringify!(str_appendchar)
7403 )
7404 );
7405 assert_eq!(
7406 unsafe { ::std::ptr::addr_of!((*ptr).str_reset) as usize - ptr as usize },
7407 1880usize,
7408 concat!(
7409 "Offset of field: ",
7410 stringify!(sqlite3_api_routines),
7411 "::",
7412 stringify!(str_reset)
7413 )
7414 );
7415 assert_eq!(
7416 unsafe { ::std::ptr::addr_of!((*ptr).str_errcode) as usize - ptr as usize },
7417 1888usize,
7418 concat!(
7419 "Offset of field: ",
7420 stringify!(sqlite3_api_routines),
7421 "::",
7422 stringify!(str_errcode)
7423 )
7424 );
7425 assert_eq!(
7426 unsafe { ::std::ptr::addr_of!((*ptr).str_length) as usize - ptr as usize },
7427 1896usize,
7428 concat!(
7429 "Offset of field: ",
7430 stringify!(sqlite3_api_routines),
7431 "::",
7432 stringify!(str_length)
7433 )
7434 );
7435 assert_eq!(
7436 unsafe { ::std::ptr::addr_of!((*ptr).str_value) as usize - ptr as usize },
7437 1904usize,
7438 concat!(
7439 "Offset of field: ",
7440 stringify!(sqlite3_api_routines),
7441 "::",
7442 stringify!(str_value)
7443 )
7444 );
7445 assert_eq!(
7446 unsafe { ::std::ptr::addr_of!((*ptr).create_window_function) as usize - ptr as usize },
7447 1912usize,
7448 concat!(
7449 "Offset of field: ",
7450 stringify!(sqlite3_api_routines),
7451 "::",
7452 stringify!(create_window_function)
7453 )
7454 );
7455 assert_eq!(
7456 unsafe { ::std::ptr::addr_of!((*ptr).normalized_sql) as usize - ptr as usize },
7457 1920usize,
7458 concat!(
7459 "Offset of field: ",
7460 stringify!(sqlite3_api_routines),
7461 "::",
7462 stringify!(normalized_sql)
7463 )
7464 );
7465 assert_eq!(
7466 unsafe { ::std::ptr::addr_of!((*ptr).stmt_isexplain) as usize - ptr as usize },
7467 1928usize,
7468 concat!(
7469 "Offset of field: ",
7470 stringify!(sqlite3_api_routines),
7471 "::",
7472 stringify!(stmt_isexplain)
7473 )
7474 );
7475 assert_eq!(
7476 unsafe { ::std::ptr::addr_of!((*ptr).value_frombind) as usize - ptr as usize },
7477 1936usize,
7478 concat!(
7479 "Offset of field: ",
7480 stringify!(sqlite3_api_routines),
7481 "::",
7482 stringify!(value_frombind)
7483 )
7484 );
7485 assert_eq!(
7486 unsafe { ::std::ptr::addr_of!((*ptr).drop_modules) as usize - ptr as usize },
7487 1944usize,
7488 concat!(
7489 "Offset of field: ",
7490 stringify!(sqlite3_api_routines),
7491 "::",
7492 stringify!(drop_modules)
7493 )
7494 );
7495 assert_eq!(
7496 unsafe { ::std::ptr::addr_of!((*ptr).hard_heap_limit64) as usize - ptr as usize },
7497 1952usize,
7498 concat!(
7499 "Offset of field: ",
7500 stringify!(sqlite3_api_routines),
7501 "::",
7502 stringify!(hard_heap_limit64)
7503 )
7504 );
7505 assert_eq!(
7506 unsafe { ::std::ptr::addr_of!((*ptr).uri_key) as usize - ptr as usize },
7507 1960usize,
7508 concat!(
7509 "Offset of field: ",
7510 stringify!(sqlite3_api_routines),
7511 "::",
7512 stringify!(uri_key)
7513 )
7514 );
7515 assert_eq!(
7516 unsafe { ::std::ptr::addr_of!((*ptr).filename_database) as usize - ptr as usize },
7517 1968usize,
7518 concat!(
7519 "Offset of field: ",
7520 stringify!(sqlite3_api_routines),
7521 "::",
7522 stringify!(filename_database)
7523 )
7524 );
7525 assert_eq!(
7526 unsafe { ::std::ptr::addr_of!((*ptr).filename_journal) as usize - ptr as usize },
7527 1976usize,
7528 concat!(
7529 "Offset of field: ",
7530 stringify!(sqlite3_api_routines),
7531 "::",
7532 stringify!(filename_journal)
7533 )
7534 );
7535 assert_eq!(
7536 unsafe { ::std::ptr::addr_of!((*ptr).filename_wal) as usize - ptr as usize },
7537 1984usize,
7538 concat!(
7539 "Offset of field: ",
7540 stringify!(sqlite3_api_routines),
7541 "::",
7542 stringify!(filename_wal)
7543 )
7544 );
7545 assert_eq!(
7546 unsafe { ::std::ptr::addr_of!((*ptr).create_filename) as usize - ptr as usize },
7547 1992usize,
7548 concat!(
7549 "Offset of field: ",
7550 stringify!(sqlite3_api_routines),
7551 "::",
7552 stringify!(create_filename)
7553 )
7554 );
7555 assert_eq!(
7556 unsafe { ::std::ptr::addr_of!((*ptr).free_filename) as usize - ptr as usize },
7557 2000usize,
7558 concat!(
7559 "Offset of field: ",
7560 stringify!(sqlite3_api_routines),
7561 "::",
7562 stringify!(free_filename)
7563 )
7564 );
7565 assert_eq!(
7566 unsafe { ::std::ptr::addr_of!((*ptr).database_file_object) as usize - ptr as usize },
7567 2008usize,
7568 concat!(
7569 "Offset of field: ",
7570 stringify!(sqlite3_api_routines),
7571 "::",
7572 stringify!(database_file_object)
7573 )
7574 );
7575 assert_eq!(
7576 unsafe { ::std::ptr::addr_of!((*ptr).txn_state) as usize - ptr as usize },
7577 2016usize,
7578 concat!(
7579 "Offset of field: ",
7580 stringify!(sqlite3_api_routines),
7581 "::",
7582 stringify!(txn_state)
7583 )
7584 );
7585 assert_eq!(
7586 unsafe { ::std::ptr::addr_of!((*ptr).changes64) as usize - ptr as usize },
7587 2024usize,
7588 concat!(
7589 "Offset of field: ",
7590 stringify!(sqlite3_api_routines),
7591 "::",
7592 stringify!(changes64)
7593 )
7594 );
7595 assert_eq!(
7596 unsafe { ::std::ptr::addr_of!((*ptr).total_changes64) as usize - ptr as usize },
7597 2032usize,
7598 concat!(
7599 "Offset of field: ",
7600 stringify!(sqlite3_api_routines),
7601 "::",
7602 stringify!(total_changes64)
7603 )
7604 );
7605 assert_eq!(
7606 unsafe { ::std::ptr::addr_of!((*ptr).autovacuum_pages) as usize - ptr as usize },
7607 2040usize,
7608 concat!(
7609 "Offset of field: ",
7610 stringify!(sqlite3_api_routines),
7611 "::",
7612 stringify!(autovacuum_pages)
7613 )
7614 );
7615 assert_eq!(
7616 unsafe { ::std::ptr::addr_of!((*ptr).error_offset) as usize - ptr as usize },
7617 2048usize,
7618 concat!(
7619 "Offset of field: ",
7620 stringify!(sqlite3_api_routines),
7621 "::",
7622 stringify!(error_offset)
7623 )
7624 );
7625 assert_eq!(
7626 unsafe { ::std::ptr::addr_of!((*ptr).vtab_rhs_value) as usize - ptr as usize },
7627 2056usize,
7628 concat!(
7629 "Offset of field: ",
7630 stringify!(sqlite3_api_routines),
7631 "::",
7632 stringify!(vtab_rhs_value)
7633 )
7634 );
7635 assert_eq!(
7636 unsafe { ::std::ptr::addr_of!((*ptr).vtab_distinct) as usize - ptr as usize },
7637 2064usize,
7638 concat!(
7639 "Offset of field: ",
7640 stringify!(sqlite3_api_routines),
7641 "::",
7642 stringify!(vtab_distinct)
7643 )
7644 );
7645 assert_eq!(
7646 unsafe { ::std::ptr::addr_of!((*ptr).vtab_in) as usize - ptr as usize },
7647 2072usize,
7648 concat!(
7649 "Offset of field: ",
7650 stringify!(sqlite3_api_routines),
7651 "::",
7652 stringify!(vtab_in)
7653 )
7654 );
7655 assert_eq!(
7656 unsafe { ::std::ptr::addr_of!((*ptr).vtab_in_first) as usize - ptr as usize },
7657 2080usize,
7658 concat!(
7659 "Offset of field: ",
7660 stringify!(sqlite3_api_routines),
7661 "::",
7662 stringify!(vtab_in_first)
7663 )
7664 );
7665 assert_eq!(
7666 unsafe { ::std::ptr::addr_of!((*ptr).vtab_in_next) as usize - ptr as usize },
7667 2088usize,
7668 concat!(
7669 "Offset of field: ",
7670 stringify!(sqlite3_api_routines),
7671 "::",
7672 stringify!(vtab_in_next)
7673 )
7674 );
7675}
7676pub type sqlite3_loadext_entry = ::std::option::Option<
7677 unsafe extern "C" fn(
7678 db: *mut sqlite3,
7679 pzErrMsg: *mut *mut ::std::os::raw::c_char,
7680 pThunk: *const sqlite3_api_routines,
7681 ) -> ::std::os::raw::c_int,
7682>;
7683pub type __builtin_va_list = *mut ::std::os::raw::c_char;