Tarantool development patches archive
 help / color / mirror / Atom feed
* [tarantool-patches] [PATCH 0/4] Cleanup SQL memory and threading subsystems
@ 2018-03-26 15:56 Kirill Yukhin
  2018-03-26 15:56 ` [tarantool-patches] [PATCH 1/4] sql: Remove all references to sqlite3.h Kirill Yukhin
                   ` (4 more replies)
  0 siblings, 5 replies; 6+ messages in thread
From: Kirill Yukhin @ 2018-03-26 15:56 UTC (permalink / raw)
  To: v.shpilevoy; +Cc: tarantool-patches, Kirill Yukhin

This patcheset perform a cleanup of SQL frontend by removing
dead memory allocators and their APIs and by getting rid of
all mutex-related code.

Issue: https://github.com/tarantool/tarantool/issues/3192
Branch: https://github.com/tarantool/tarantool/tree/kyukhin/gh-3192-remove-sqlite3


Kirill Yukhin (4):
  sql: Remove all references to sqlite3.h
  sql: remove mutexes around the code
  sql: remove dead memory allocation systems
  sql: Remove dead defines from sqliteInt.h

 src/box/execute.c          |    2 +-
 src/box/lua/sql.c          |    2 +-
 src/box/sql.c              |    2 -
 src/box/sql/CMakeLists.txt |    9 -
 src/box/sql/date.c         |    7 -
 src/box/sql/func.c         |    2 -
 src/box/sql/global.c       |    8 -
 src/box/sql/legacy.c       |    2 -
 src/box/sql/main.c         |  337 +--
 src/box/sql/malloc.c       |  195 +-
 src/box/sql/mem0.c         |  116 -
 src/box/sql/mem1.c         |  314 ---
 src/box/sql/mem2.c         |  602 ----
 src/box/sql/mem3.c         |  767 -----
 src/box/sql/mem5.c         |  648 -----
 src/box/sql/mutex.c        |  211 --
 src/box/sql/mutex.h        |   82 -
 src/box/sql/mutex_noop.c   |  300 --
 src/box/sql/mutex_unix.c   |  442 ---
 src/box/sql/os.c           |   23 +-
 src/box/sql/os_unix.c      |  180 +-
 src/box/sql/parse.c        |  143 +-
 src/box/sql/prepare.c      |    8 -
 src/box/sql/printf.c       |    6 -
 src/box/sql/random.c       |   11 -
 src/box/sql/sqlite3.h      | 6728 --------------------------------------------
 src/box/sql/sqliteInt.h    |  778 ++++-
 src/box/sql/status.c       |   12 +-
 src/box/sql/tokenize.c     |    2 -
 src/box/sql/vdbe.c         |    5 +-
 src/box/sql/vdbeapi.c      |   54 -
 src/box/sql/vdbeaux.c      |    2 -
 src/box/sql/vdbemem.c      |   17 -
 src/box/sql/vdbesort.c     |    6 +-
 34 files changed, 887 insertions(+), 11136 deletions(-)
 delete mode 100644 src/box/sql/mem0.c
 delete mode 100644 src/box/sql/mem1.c
 delete mode 100644 src/box/sql/mem2.c
 delete mode 100644 src/box/sql/mem3.c
 delete mode 100644 src/box/sql/mem5.c
 delete mode 100644 src/box/sql/mutex.c
 delete mode 100644 src/box/sql/mutex.h
 delete mode 100644 src/box/sql/mutex_noop.c
 delete mode 100644 src/box/sql/mutex_unix.c
 delete mode 100644 src/box/sql/sqlite3.h

-- 
2.11.0

^ permalink raw reply	[flat|nested] 6+ messages in thread

* [tarantool-patches] [PATCH 1/4] sql: Remove all references to sqlite3.h
  2018-03-26 15:56 [tarantool-patches] [PATCH 0/4] Cleanup SQL memory and threading subsystems Kirill Yukhin
@ 2018-03-26 15:56 ` Kirill Yukhin
  2018-03-26 15:56 ` [tarantool-patches] [PATCH 2/4] sql: remove mutexes around the code Kirill Yukhin
                   ` (3 subsequent siblings)
  4 siblings, 0 replies; 6+ messages in thread
From: Kirill Yukhin @ 2018-03-26 15:56 UTC (permalink / raw)
  To: v.shpilevoy; +Cc: tarantool-patches, Kirill Yukhin

Legacy SQL have dedicated SQL API, which became useless
after integration into Tarantool. Remove this file, copy-pating
all necessary structures to sqliteInt.h header.

Next patches, should perform actual clean-up and remove dead code.
---
 src/box/execute.c       |   2 +-
 src/box/lua/sql.c       |   2 +-
 src/box/sql.c           |   2 -
 src/box/sql/parse.c     | 143 ++++-----
 src/box/sql/sqliteInt.h | 780 +++++++++++++++++++++++++++++++++++++++++++++++-
 5 files changed, 850 insertions(+), 79 deletions(-)

diff --git a/src/box/execute.c b/src/box/execute.c
index 48d166b5..c6a0bf2 100644
--- a/src/box/execute.c
+++ b/src/box/execute.c
@@ -31,7 +31,7 @@
 #include "execute.h"
 
 #include "iproto_constants.h"
-#include "sql/sqlite3.h"
+#include "sql/sqliteInt.h"
 #include "sql/sqliteLimit.h"
 #include "errcode.h"
 #include "small/region.h"
diff --git a/src/box/lua/sql.c b/src/box/lua/sql.c
index 16bf2ac..12b8138 100644
--- a/src/box/lua/sql.c
+++ b/src/box/lua/sql.c
@@ -1,7 +1,7 @@
 #include "sql.h"
 #include "box/sql.h"
 
-#include "box/sql/sqlite3.h"
+#include "box/sql/sqliteInt.h"
 #include "box/info.h"
 #include "lua/utils.h"
 #include "info.h"
diff --git a/src/box/sql.c b/src/box/sql.c
index 2247471..e6521b9 100644
--- a/src/box/sql.c
+++ b/src/box/sql.c
@@ -31,8 +31,6 @@
 #include <assert.h>
 #include "field_def.h"
 #include "sql.h"
-#include "sql/sqlite3.h"
-
 /*
  * Both Tarantool and SQLite codebases declare Index, hence the
  * workaround below.
diff --git a/src/box/sql/parse.c b/src/box/sql/parse.c
index f938a9a..0f79fdb 100644
--- a/src/box/sql/parse.c
+++ b/src/box/sql/parse.c
@@ -1512,7 +1512,7 @@ sqlite3SrcListDelete(pParse->db, (yypminor->yy387));
     case 184: /* with */
     case 229: /* wqlist */
 {
-#line 1511 "parse.y"
+#line 1512 "parse.y"
 sqlite3WithDelete(pParse->db, (yypminor->yy151));
 #line 1518 "parse.c"
 }
@@ -1541,14 +1541,14 @@ sqlite3IdListDelete(pParse->db, (yypminor->yy40));
     case 221: /* trigger_cmd_list */
     case 226: /* trigger_cmd */
 {
-#line 1385 "parse.y"
+#line 1386 "parse.y"
 sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy427));
 #line 1547 "parse.c"
 }
       break;
     case 223: /* trigger_event */
 {
-#line 1371 "parse.y"
+#line 1372 "parse.y"
 sqlite3IdListDelete(pParse->db, (yypminor->yy10).b);
 #line 1554 "parse.c"
 }
@@ -3506,119 +3506,120 @@ static void yy_reduce(
       case 221: /* trigger_decl ::= TRIGGER ifnotexists nm trigger_time trigger_event ON fullname foreach_clause when_clause */
 #line 1359 "parse.y"
 {
+  pParse->initiateTTrans = false;
   sqlite3BeginTrigger(pParse, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy52, yymsp[-4].minor.yy10.a, yymsp[-4].minor.yy10.b, yymsp[-2].minor.yy387, yymsp[0].minor.yy362, yymsp[-7].minor.yy52);
   yymsp[-8].minor.yy0 = yymsp[-6].minor.yy0; /*yymsp[-8].minor.yy0-overwrites-T*/
 }
-#line 3513 "parse.c"
+#line 3514 "parse.c"
         break;
       case 222: /* trigger_time ::= BEFORE */
-#line 1365 "parse.y"
+#line 1366 "parse.y"
 { yymsp[0].minor.yy52 = TK_BEFORE; }
-#line 3518 "parse.c"
+#line 3519 "parse.c"
         break;
       case 223: /* trigger_time ::= AFTER */
-#line 1366 "parse.y"
+#line 1367 "parse.y"
 { yymsp[0].minor.yy52 = TK_AFTER;  }
-#line 3523 "parse.c"
+#line 3524 "parse.c"
         break;
       case 224: /* trigger_time ::= INSTEAD OF */
-#line 1367 "parse.y"
+#line 1368 "parse.y"
 { yymsp[-1].minor.yy52 = TK_INSTEAD;}
-#line 3528 "parse.c"
+#line 3529 "parse.c"
         break;
       case 225: /* trigger_time ::= */
-#line 1368 "parse.y"
+#line 1369 "parse.y"
 { yymsp[1].minor.yy52 = TK_BEFORE; }
-#line 3533 "parse.c"
+#line 3534 "parse.c"
         break;
       case 226: /* trigger_event ::= DELETE|INSERT */
       case 227: /* trigger_event ::= UPDATE */ yytestcase(yyruleno==227);
-#line 1372 "parse.y"
+#line 1373 "parse.y"
 {yymsp[0].minor.yy10.a = yymsp[0].major; /*A-overwrites-X*/ yymsp[0].minor.yy10.b = 0;}
-#line 3539 "parse.c"
+#line 3540 "parse.c"
         break;
       case 228: /* trigger_event ::= UPDATE OF idlist */
-#line 1374 "parse.y"
+#line 1375 "parse.y"
 {yymsp[-2].minor.yy10.a = TK_UPDATE; yymsp[-2].minor.yy10.b = yymsp[0].minor.yy40;}
-#line 3544 "parse.c"
+#line 3545 "parse.c"
         break;
       case 229: /* when_clause ::= */
-#line 1381 "parse.y"
+#line 1382 "parse.y"
 { yymsp[1].minor.yy362 = 0; }
-#line 3549 "parse.c"
+#line 3550 "parse.c"
         break;
       case 230: /* when_clause ::= WHEN expr */
-#line 1382 "parse.y"
+#line 1383 "parse.y"
 { yymsp[-1].minor.yy362 = yymsp[0].minor.yy162.pExpr; }
-#line 3554 "parse.c"
+#line 3555 "parse.c"
         break;
       case 231: /* trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI */
-#line 1386 "parse.y"
+#line 1387 "parse.y"
 {
   assert( yymsp[-2].minor.yy427!=0 );
   yymsp[-2].minor.yy427->pLast->pNext = yymsp[-1].minor.yy427;
   yymsp[-2].minor.yy427->pLast = yymsp[-1].minor.yy427;
 }
-#line 3563 "parse.c"
+#line 3564 "parse.c"
         break;
       case 232: /* trigger_cmd_list ::= trigger_cmd SEMI */
-#line 1391 "parse.y"
+#line 1392 "parse.y"
 { 
   assert( yymsp[-1].minor.yy427!=0 );
   yymsp[-1].minor.yy427->pLast = yymsp[-1].minor.yy427;
 }
-#line 3571 "parse.c"
+#line 3572 "parse.c"
         break;
       case 233: /* trnm ::= nm DOT nm */
-#line 1402 "parse.y"
+#line 1403 "parse.y"
 {
   yymsp[-2].minor.yy0 = yymsp[0].minor.yy0;
   sqlite3ErrorMsg(pParse, 
         "qualified table names are not allowed on INSERT, UPDATE, and DELETE "
         "statements within triggers");
 }
-#line 3581 "parse.c"
+#line 3582 "parse.c"
         break;
       case 234: /* tridxby ::= INDEXED BY nm */
-#line 1414 "parse.y"
+#line 1415 "parse.y"
 {
   sqlite3ErrorMsg(pParse,
         "the INDEXED BY clause is not allowed on UPDATE or DELETE statements "
         "within triggers");
 }
-#line 3590 "parse.c"
+#line 3591 "parse.c"
         break;
       case 235: /* tridxby ::= NOT INDEXED */
-#line 1419 "parse.y"
+#line 1420 "parse.y"
 {
   sqlite3ErrorMsg(pParse,
         "the NOT INDEXED clause is not allowed on UPDATE or DELETE statements "
         "within triggers");
 }
-#line 3599 "parse.c"
+#line 3600 "parse.c"
         break;
       case 236: /* trigger_cmd ::= UPDATE orconf trnm tridxby SET setlist where_opt */
-#line 1432 "parse.y"
+#line 1433 "parse.y"
 {yymsp[-6].minor.yy427 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy382, yymsp[0].minor.yy362, yymsp[-5].minor.yy52);}
-#line 3604 "parse.c"
+#line 3605 "parse.c"
         break;
       case 237: /* trigger_cmd ::= insert_cmd INTO trnm idlist_opt select */
-#line 1436 "parse.y"
+#line 1437 "parse.y"
 {yymsp[-4].minor.yy427 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy40, yymsp[0].minor.yy279, yymsp[-4].minor.yy52);/*A-overwrites-R*/}
-#line 3609 "parse.c"
+#line 3610 "parse.c"
         break;
       case 238: /* trigger_cmd ::= DELETE FROM trnm tridxby where_opt */
-#line 1440 "parse.y"
+#line 1441 "parse.y"
 {yymsp[-4].minor.yy427 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy362);}
-#line 3614 "parse.c"
+#line 3615 "parse.c"
         break;
       case 239: /* trigger_cmd ::= select */
-#line 1444 "parse.y"
+#line 1445 "parse.y"
 {yymsp[0].minor.yy427 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy279); /*A-overwrites-X*/}
-#line 3619 "parse.c"
+#line 3620 "parse.c"
         break;
       case 240: /* expr ::= RAISE LP IGNORE RP */
-#line 1447 "parse.y"
+#line 1448 "parse.y"
 {
   spanSet(&yymsp[-3].minor.yy162,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0);  /*A-overwrites-X*/
   yymsp[-3].minor.yy162.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0); 
@@ -3626,10 +3627,10 @@ static void yy_reduce(
     yymsp[-3].minor.yy162.pExpr->affinity = ON_CONFLICT_ACTION_IGNORE;
   }
 }
-#line 3630 "parse.c"
+#line 3631 "parse.c"
         break;
       case 241: /* expr ::= RAISE LP raisetype COMMA STRING RP */
-#line 1454 "parse.y"
+#line 1455 "parse.y"
 {
   spanSet(&yymsp[-5].minor.yy162,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0);  /*A-overwrites-X*/
   yymsp[-5].minor.yy162.pExpr = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1); 
@@ -3637,85 +3638,85 @@ static void yy_reduce(
     yymsp[-5].minor.yy162.pExpr->affinity = (char)yymsp[-3].minor.yy52;
   }
 }
-#line 3641 "parse.c"
+#line 3642 "parse.c"
         break;
       case 242: /* raisetype ::= ROLLBACK */
-#line 1464 "parse.y"
+#line 1465 "parse.y"
 {yymsp[0].minor.yy52 = ON_CONFLICT_ACTION_ROLLBACK;}
-#line 3646 "parse.c"
+#line 3647 "parse.c"
         break;
       case 244: /* raisetype ::= FAIL */
-#line 1466 "parse.y"
+#line 1467 "parse.y"
 {yymsp[0].minor.yy52 = ON_CONFLICT_ACTION_FAIL;}
-#line 3651 "parse.c"
+#line 3652 "parse.c"
         break;
       case 245: /* cmd ::= DROP TRIGGER ifexists fullname */
-#line 1471 "parse.y"
+#line 1472 "parse.y"
 {
   sqlite3DropTrigger(pParse,yymsp[0].minor.yy387,yymsp[-1].minor.yy52);
 }
-#line 3658 "parse.c"
+#line 3659 "parse.c"
         break;
       case 246: /* cmd ::= REINDEX */
-#line 1478 "parse.y"
+#line 1479 "parse.y"
 {sqlite3Reindex(pParse, 0, 0);}
-#line 3663 "parse.c"
+#line 3664 "parse.c"
         break;
       case 247: /* cmd ::= REINDEX nm */
-#line 1479 "parse.y"
+#line 1480 "parse.y"
 {sqlite3Reindex(pParse, &yymsp[0].minor.yy0, 0);}
-#line 3668 "parse.c"
+#line 3669 "parse.c"
         break;
       case 248: /* cmd ::= REINDEX nm ON nm */
-#line 1480 "parse.y"
+#line 1481 "parse.y"
 {sqlite3Reindex(pParse, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
-#line 3673 "parse.c"
+#line 3674 "parse.c"
         break;
       case 249: /* cmd ::= ANALYZE */
-#line 1485 "parse.y"
+#line 1486 "parse.y"
 {sqlite3Analyze(pParse, 0);}
-#line 3678 "parse.c"
+#line 3679 "parse.c"
         break;
       case 250: /* cmd ::= ANALYZE nm */
-#line 1486 "parse.y"
+#line 1487 "parse.y"
 {sqlite3Analyze(pParse, &yymsp[0].minor.yy0);}
-#line 3683 "parse.c"
+#line 3684 "parse.c"
         break;
       case 251: /* cmd ::= ALTER TABLE fullname RENAME TO nm */
-#line 1491 "parse.y"
+#line 1492 "parse.y"
 {
   sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy387,&yymsp[0].minor.yy0);
 }
-#line 3690 "parse.c"
+#line 3691 "parse.c"
         break;
       case 252: /* with ::= */
-#line 1514 "parse.y"
+#line 1515 "parse.y"
 {yymsp[1].minor.yy151 = 0;}
-#line 3695 "parse.c"
+#line 3696 "parse.c"
         break;
       case 253: /* with ::= WITH wqlist */
-#line 1516 "parse.y"
+#line 1517 "parse.y"
 { yymsp[-1].minor.yy151 = yymsp[0].minor.yy151; }
-#line 3700 "parse.c"
+#line 3701 "parse.c"
         break;
       case 254: /* with ::= WITH RECURSIVE wqlist */
-#line 1517 "parse.y"
+#line 1518 "parse.y"
 { yymsp[-2].minor.yy151 = yymsp[0].minor.yy151; }
-#line 3705 "parse.c"
+#line 3706 "parse.c"
         break;
       case 255: /* wqlist ::= nm eidlist_opt AS LP select RP */
-#line 1519 "parse.y"
+#line 1520 "parse.y"
 {
   yymsp[-5].minor.yy151 = sqlite3WithAdd(pParse, 0, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy382, yymsp[-1].minor.yy279); /*A-overwrites-X*/
 }
-#line 3712 "parse.c"
+#line 3713 "parse.c"
         break;
       case 256: /* wqlist ::= wqlist COMMA nm eidlist_opt AS LP select RP */
-#line 1522 "parse.y"
+#line 1523 "parse.y"
 {
   yymsp[-7].minor.yy151 = sqlite3WithAdd(pParse, yymsp[-7].minor.yy151, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy382, yymsp[-1].minor.yy279);
 }
-#line 3719 "parse.c"
+#line 3720 "parse.c"
         break;
       default:
       /* (257) input ::= ecmd */ yytestcase(yyruleno==257);
@@ -3826,7 +3827,7 @@ static void yy_syntax_error(
   } else {
     sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);
   }
-#line 3830 "parse.c"
+#line 3831 "parse.c"
 /************ End %syntax_error code ******************************************/
   sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */
 }
diff --git a/src/box/sql/sqliteInt.h b/src/box/sql/sqliteInt.h
index 0856bc7..50dadf4 100644
--- a/src/box/sql/sqliteInt.h
+++ b/src/box/sql/sqliteInt.h
@@ -121,9 +121,6 @@
 #define _GNU_SOURCE
 #endif
 
-/* The public SQLite interface. */
-#include "sqlite3.h"
-
 #include "sqliteLimit.h"
 
 /* Disable nuisance warnings on Borland compilers */
@@ -390,6 +387,781 @@ void sqlite3Coverage(int);
 #include <assert.h>
 #include <stddef.h>
 
+typedef long long int sqlite_int64;
+typedef unsigned long long int sqlite_uint64;
+typedef sqlite_int64 sqlite3_int64;
+typedef sqlite_uint64 sqlite3_uint64;
+typedef struct sqlite3_stmt sqlite3_stmt;
+
+typedef struct sqlite3_context sqlite3_context;
+typedef struct sqlite3 sqlite3;
+typedef struct Mem sqlite3_value;
+typedef struct sqlite3_file sqlite3_file;
+struct sqlite3_file {
+	const struct sqlite3_io_methods *pMethods;	/* Methods for an open file */
+};
+
+typedef int (*sqlite3_callback) (void *, int, char **, char **);
+
+typedef struct sqlite3_vfs sqlite3_vfs;
+typedef void (*sqlite3_syscall_ptr) (void);
+struct sqlite3_vfs {
+	int iVersion;	/* Structure version number (currently 3) */
+	int szOsFile;	/* Size of subclassed sqlite3_file */
+	int mxPathname;	/* Maximum file pathname length */
+	sqlite3_vfs *pNext;	/* Next registered VFS */
+	const char *zName;	/* Name of this virtual file system */
+	void *pAppData;	/* Pointer to application-specific data */
+	int (*xOpen) (sqlite3_vfs *, const char *zName, sqlite3_file *,
+		      int flags, int *pOutFlags);
+	int (*xDelete) (sqlite3_vfs *, const char *zName, int syncDir);
+	int (*xAccess) (sqlite3_vfs *, const char *zName, int flags,
+			int *pResOut);
+	int (*xFullPathname) (sqlite3_vfs *, const char *zName,
+			      int nOut, char *zOut);
+	void *(*xDlOpen) (sqlite3_vfs *, const char *zFilename);
+	void (*xDlError) (sqlite3_vfs *, int nByte, char *zErrMsg);
+	void (*(*xDlSym) (sqlite3_vfs *, void *, const char *zSymbol))
+	(void);
+	void (*xDlClose) (sqlite3_vfs *, void *);
+	int (*xRandomness) (sqlite3_vfs *, int nByte, char *zOut);
+	int (*xSleep) (sqlite3_vfs *, int microseconds);
+	int (*xCurrentTime) (sqlite3_vfs *, double *);
+	int (*xGetLastError) (sqlite3_vfs *, int, char *);
+	/*
+	** The methods above are in version 1 of the sqlite_vfs object
+	** definition.  Those that follow are added in version 2 or later
+	*/
+	int (*xCurrentTimeInt64) (sqlite3_vfs *, sqlite3_int64 *);
+	/*
+	** The methods above are in versions 1 and 2 of the sqlite_vfs object.
+	** Those below are for version 3 and greater.
+	*/
+	int (*xSetSystemCall) (sqlite3_vfs *, const char *zName,
+			       sqlite3_syscall_ptr);
+	sqlite3_syscall_ptr(*xGetSystemCall) (sqlite3_vfs *,
+					      const char *zName);
+	const char *(*xNextSystemCall) (sqlite3_vfs *,
+					const char *zName);
+	/*
+	** The methods above are in versions 1 through 3 of the sqlite_vfs object.
+	** New fields may be appended in future versions.  The iVersion
+	** value will increment whenever this happens.
+	*/
+};
+
+typedef struct sqlite3_mutex sqlite3_mutex;
+typedef struct sqlite3_mutex_methods sqlite3_mutex_methods;
+struct sqlite3_mutex_methods {
+	int (*xMutexInit) (void);
+	int (*xMutexEnd) (void);
+	sqlite3_mutex *(*xMutexAlloc) (int);
+	void (*xMutexFree) (sqlite3_mutex *);
+	void (*xMutexEnter) (sqlite3_mutex *);
+	int (*xMutexTry) (sqlite3_mutex *);
+	void (*xMutexLeave) (sqlite3_mutex *);
+	int (*xMutexHeld) (sqlite3_mutex *);
+	int (*xMutexNotheld) (sqlite3_mutex *);
+};
+
+#define SQLITE_LIMIT_LENGTH                    0
+#define SQLITE_LIMIT_SQL_LENGTH                1
+#define SQLITE_LIMIT_COLUMN                    2
+#define SQLITE_LIMIT_EXPR_DEPTH                3
+#define SQLITE_LIMIT_COMPOUND_SELECT           4
+#define SQLITE_LIMIT_VDBE_OP                   5
+#define SQLITE_LIMIT_FUNCTION_ARG              6
+#define SQLITE_LIMIT_ATTACHED                  7
+#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH       8
+#define SQLITE_LIMIT_TRIGGER_DEPTH             9
+#define SQLITE_LIMIT_WORKER_THREADS           10
+
+typedef struct sqlite3_mem_methods sqlite3_mem_methods;
+struct sqlite3_mem_methods {
+	void *(*xMalloc) (int);	/* Memory allocation function */
+	void (*xFree) (void *);	/* Free a prior allocation */
+	void *(*xRealloc) (void *, int);	/* Resize an allocation */
+	int (*xSize) (void *);	/* Return the size of an allocation */
+	int (*xRoundup) (int);	/* Round up request size to allocation size */
+	int (*xInit) (void *);	/* Initialize the memory allocator */
+	void (*xShutdown) (void *);	/* Deinitialize the memory allocator */
+	void *pAppData;	/* Argument to xInit() and xShutdown() */
+};
+
+typedef struct sqlite3_pcache sqlite3_pcache;
+
+typedef struct sqlite3_pcache_page sqlite3_pcache_page;
+struct sqlite3_pcache_page {
+	void *pBuf;	/* The content of the page */
+	void *pExtra;	/* Extra information associated with the page */
+};
+
+typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2;
+struct sqlite3_pcache_methods2 {
+	int iVersion;
+	void *pArg;
+	int (*xInit) (void *);
+	void (*xShutdown) (void *);
+	sqlite3_pcache *(*xCreate) (int szPage, int szExtra,
+				    int bPurgeable);
+	void (*xCachesize) (sqlite3_pcache *, int nCachesize);
+	int (*xPagecount) (sqlite3_pcache *);
+	sqlite3_pcache_page *(*xFetch) (sqlite3_pcache *, unsigned key,
+					int createFlag);
+	void (*xUnpin) (sqlite3_pcache *, sqlite3_pcache_page *,
+			int discard);
+	void (*xRekey) (sqlite3_pcache *, sqlite3_pcache_page *,
+			unsigned oldKey, unsigned newKey);
+	void (*xTruncate) (sqlite3_pcache *, unsigned iLimit);
+	void (*xDestroy) (sqlite3_pcache *);
+	void (*xShrink) (sqlite3_pcache *);
+};
+
+
+#define SQLITE_OK           0	/* Successful result */
+/* beginning-of-error-codes */
+#define SQLITE_ERROR        1	/* SQL error or missing database */
+#define SQLITE_INTERNAL     2	/* Internal logic error in SQLite */
+#define SQLITE_PERM         3	/* Access permission denied */
+#define SQLITE_ABORT        4	/* Callback routine requested an abort */
+#define SQLITE_BUSY         5	/* The database file is locked */
+#define SQLITE_LOCKED       6	/* A table in the database is locked */
+#define SQLITE_NOMEM        7	/* A malloc() failed */
+#define SQLITE_READONLY     8	/* Attempt to write a readonly database */
+#define SQLITE_INTERRUPT    9	/* Operation terminated by sqlite3_interrupt() */
+#define SQLITE_IOERR       10	/* Some kind of disk I/O error occurred */
+#define SQLITE_CORRUPT     11	/* The database disk image is malformed */
+#define SQLITE_NOTFOUND    12	/* Unknown opcode in sqlite3_file_control() */
+#define SQLITE_FULL        13	/* Insertion failed because database is full */
+#define SQLITE_CANTOPEN    14	/* Unable to open the database file */
+#define SQLITE_PROTOCOL    15	/* Database lock protocol error */
+#define SQLITE_EMPTY       16	/* Database is empty */
+#define SQLITE_SCHEMA      17	/* The database schema changed */
+#define SQLITE_TOOBIG      18	/* String or BLOB exceeds size limit */
+#define SQLITE_CONSTRAINT  19	/* Abort due to constraint violation */
+#define SQLITE_MISMATCH    20	/* Data type mismatch */
+#define SQLITE_MISUSE      21	/* Library used incorrectly */
+#define SQLITE_NOLFS       22	/* Uses OS features not supported on host */
+#define SQLITE_FORMAT      23	/* Auxiliary database format error */
+#define SQLITE_RANGE       24	/* 2nd parameter to sqlite3_bind out of range */
+#define SQLITE_NOTADB      25	/* File opened that is not a database file */
+#define SQL_TARANTOOL_ITERATOR_FAIL 26
+#define SQL_TARANTOOL_INSERT_FAIL   27
+#define SQL_TARANTOOL_DELETE_FAIL   28
+#define SQL_TARANTOOL_ERROR         29
+#define SQLITE_NOTICE      31	/* Notifications from sqlite3_log() */
+#define SQLITE_WARNING     32	/* Warnings from sqlite3_log() */
+#define SQLITE_ROW         100	/* sqlite3_step() has another row ready */
+#define SQLITE_DONE        101	/* sqlite3_step() has finished executing */
+/* end-of-error-codes */
+
+void *
+sqlite3_malloc(int);
+
+void *
+sqlite3_malloc64(sqlite3_uint64);
+
+void *
+sqlite3_realloc(void *, int);
+
+void *
+sqlite3_realloc64(void *, sqlite3_uint64);
+
+void
+sqlite3_free(void *);
+
+sqlite3_uint64
+sqlite3_msize(void *);
+
+int
+sqlite3_stricmp(const char *, const char *);
+
+int
+sqlite3_strnicmp(const char *, const char *, int);
+
+ const void *
+sqlite3_value_blob(sqlite3_value *);
+
+ int
+sqlite3_value_bytes(sqlite3_value *);
+
+ double
+sqlite3_value_double(sqlite3_value *);
+
+ int
+sqlite3_value_int(sqlite3_value *);
+
+ sqlite3_int64
+sqlite3_value_int64(sqlite3_value *);
+
+ const unsigned char *
+sqlite3_value_text(sqlite3_value *);
+
+ int
+sqlite3_value_type(sqlite3_value *);
+
+ int
+sqlite3_value_numeric_type(sqlite3_value *);
+
+sqlite3 *
+sqlite3_context_db_handle(sqlite3_context *);
+
+
+ void
+sqlite3_result_blob(sqlite3_context *, const void *,
+		    int, void (*)(void *));
+
+ void
+sqlite3_result_blob64(sqlite3_context *, const void *,
+		      sqlite3_uint64, void (*)(void *));
+
+ void
+sqlite3_result_double(sqlite3_context *, double);
+
+ void
+sqlite3_result_error(sqlite3_context *, const char *,
+		     int);
+
+ void
+sqlite3_result_error_toobig(sqlite3_context *);
+
+ void
+sqlite3_result_error_nomem(sqlite3_context *);
+
+ void
+sqlite3_result_error_code(sqlite3_context *, int);
+
+ void
+sqlite3_result_int(sqlite3_context *, int);
+
+ void
+sqlite3_result_int64(sqlite3_context *, sqlite3_int64);
+
+ void
+sqlite3_result_null(sqlite3_context *);
+
+ void
+sqlite3_result_text(sqlite3_context *, const char *,
+		    int, void (*)(void *));
+
+ void
+sqlite3_result_text64(sqlite3_context *, const char *,
+		      sqlite3_uint64, void (*)(void *));
+
+ void
+sqlite3_result_value(sqlite3_context *,
+		     sqlite3_value *);
+
+ void
+sqlite3_result_zeroblob(sqlite3_context *, int n);
+
+ int
+sqlite3_result_zeroblob64(sqlite3_context *,
+			  sqlite3_uint64 n);
+
+ char *
+sqlite3_mprintf(const char *, ...);
+ char *
+sqlite3_vmprintf(const char *, va_list);
+ char *
+sqlite3_snprintf(int, char *, const char *, ...);
+ char *
+sqlite3_vsnprintf(int, char *, const char *, va_list);
+
+int
+sqlite3_strlike(const char *zGlob, const char *zStr,
+		unsigned int cEsc);
+
+typedef void (*sqlite3_destructor_type) (void *);
+#define SQLITE_STATIC      ((sqlite3_destructor_type)0)
+#define SQLITE_TRANSIENT   ((sqlite3_destructor_type)-1)
+
+int
+sqlite3_strglob(const char *zGlob, const char *zStr);
+
+int
+sqlite3_prepare(sqlite3 * db,	/* Database handle */
+		const char *zSql,	/* SQL statement, UTF-8 encoded */
+		int nByte,	/* Maximum length of zSql in bytes. */
+		sqlite3_stmt ** ppStmt,	/* OUT: Statement handle */
+		const char **pzTail	/* OUT: Pointer to unused portion of zSql */
+	);
+
+int
+sqlite3_prepare_v2(sqlite3 * db,	/* Database handle */
+		   const char *zSql,	/* SQL statement, UTF-8 encoded */
+		   int nByte,	/* Maximum length of zSql in bytes. */
+		   sqlite3_stmt ** ppStmt,	/* OUT: Statement handle */
+		   const char **pzTail	/* OUT: Pointer to unused portion of zSql */
+	);
+
+int
+sqlite3_step(sqlite3_stmt *);
+
+const void *
+sqlite3_column_blob(sqlite3_stmt *, int iCol);
+
+int
+sqlite3_column_bytes(sqlite3_stmt *, int iCol);
+
+int
+sqlite3_column_bytes16(sqlite3_stmt *, int iCol);
+
+double
+sqlite3_column_double(sqlite3_stmt *, int iCol);
+
+int
+sqlite3_column_int(sqlite3_stmt *, int iCol);
+
+sqlite3_int64
+sqlite3_column_int64(sqlite3_stmt *, int iCol);
+
+const unsigned char *
+sqlite3_column_text(sqlite3_stmt *,
+		    int iCol);
+
+int
+sqlite3_column_type(sqlite3_stmt *, int iCol);
+
+sqlite3_value *
+sqlite3_column_value(sqlite3_stmt *,
+		     int iCol);
+
+int
+sqlite3_finalize(sqlite3_stmt * pStmt);
+
+int
+sqlite3_exec(sqlite3 *,	/* An open database */
+	     const char *sql,	/* SQL to be evaluated */
+	     int (*callback) (void *, int, char **, char **),	/* Callback function */
+	     void *,	/* 1st argument to callback */
+	     char **errmsg	/* Error msg written here */
+	);
+#define SQLITE_IOERR_READ              (SQLITE_IOERR | (1<<8))
+#define SQLITE_IOERR_SHORT_READ        (SQLITE_IOERR | (2<<8))
+#define SQLITE_IOERR_WRITE             (SQLITE_IOERR | (3<<8))
+#define SQLITE_IOERR_FSYNC             (SQLITE_IOERR | (4<<8))
+#define SQLITE_IOERR_DIR_FSYNC         (SQLITE_IOERR | (5<<8))
+#define SQLITE_IOERR_TRUNCATE          (SQLITE_IOERR | (6<<8))
+#define SQLITE_IOERR_FSTAT             (SQLITE_IOERR | (7<<8))
+#define SQLITE_IOERR_UNLOCK            (SQLITE_IOERR | (8<<8))
+#define SQLITE_IOERR_RDLOCK            (SQLITE_IOERR | (9<<8))
+#define SQLITE_IOERR_DELETE            (SQLITE_IOERR | (10<<8))
+#define SQLITE_IOERR_BLOCKED           (SQLITE_IOERR | (11<<8))
+#define SQLITE_IOERR_NOMEM             (SQLITE_IOERR | (12<<8))
+#define SQLITE_IOERR_ACCESS            (SQLITE_IOERR | (13<<8))
+#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))
+#define SQLITE_IOERR_LOCK              (SQLITE_IOERR | (15<<8))
+#define SQLITE_IOERR_CLOSE             (SQLITE_IOERR | (16<<8))
+#define SQLITE_IOERR_DIR_CLOSE         (SQLITE_IOERR | (17<<8))
+#define SQLITE_IOERR_SHMOPEN           (SQLITE_IOERR | (18<<8))
+#define SQLITE_IOERR_SHMSIZE           (SQLITE_IOERR | (19<<8))
+#define SQLITE_IOERR_SHMLOCK           (SQLITE_IOERR | (20<<8))
+#define SQLITE_IOERR_SHMMAP            (SQLITE_IOERR | (21<<8))
+#define SQLITE_IOERR_SEEK              (SQLITE_IOERR | (22<<8))
+#define SQLITE_IOERR_DELETE_NOENT      (SQLITE_IOERR | (23<<8))
+#define SQLITE_IOERR_MMAP              (SQLITE_IOERR | (24<<8))
+#define SQLITE_IOERR_GETTEMPPATH       (SQLITE_IOERR | (25<<8))
+#define SQLITE_IOERR_CONVPATH          (SQLITE_IOERR | (26<<8))
+#define SQLITE_IOERR_VNODE             (SQLITE_IOERR | (27<<8))
+#define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))
+#define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))
+#define SQLITE_BUSY_SNAPSHOT           (SQLITE_BUSY   |  (2<<8))
+#define SQLITE_CANTOPEN_NOTEMPDIR      (SQLITE_CANTOPEN | (1<<8))
+#define SQLITE_CANTOPEN_ISDIR          (SQLITE_CANTOPEN | (2<<8))
+#define SQLITE_CANTOPEN_FULLPATH       (SQLITE_CANTOPEN | (3<<8))
+#define SQLITE_CANTOPEN_CONVPATH       (SQLITE_CANTOPEN | (4<<8))
+#define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))
+#define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))
+#define SQLITE_READONLY_ROLLBACK       (SQLITE_READONLY | (3<<8))
+#define SQLITE_READONLY_DBMOVED        (SQLITE_READONLY | (4<<8))
+#define SQLITE_ABORT_ROLLBACK          (SQLITE_ABORT | (2<<8))
+#define SQLITE_CONSTRAINT_CHECK        (SQLITE_CONSTRAINT | (1<<8))
+#define SQLITE_CONSTRAINT_COMMITHOOK   (SQLITE_CONSTRAINT | (2<<8))
+#define SQLITE_CONSTRAINT_FOREIGNKEY   (SQLITE_CONSTRAINT | (3<<8))
+#define SQLITE_CONSTRAINT_FUNCTION     (SQLITE_CONSTRAINT | (4<<8))
+#define SQLITE_CONSTRAINT_NOTNULL      (SQLITE_CONSTRAINT | (5<<8))
+#define SQLITE_CONSTRAINT_PRIMARYKEY   (SQLITE_CONSTRAINT | (6<<8))
+#define SQLITE_CONSTRAINT_TRIGGER      (SQLITE_CONSTRAINT | (7<<8))
+#define SQLITE_CONSTRAINT_UNIQUE       (SQLITE_CONSTRAINT | (8<<8))
+#define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))
+#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
+#define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))
+#define SQLITE_OK_LOAD_PERMANENTLY     (SQLITE_OK | (1<<8))
+
+enum sql_type {
+	SQLITE_INTEGER = 1,
+	SQLITE_FLOAT = 2,
+	SQLITE_TEXT = 3,
+	SQLITE_BLOB = 4,
+	SQLITE_NULL = 5,
+};
+
+void *
+sqlite3_user_data(sqlite3_context *);
+
+void
+sqlite3_randomness(int N, void *P);
+
+int
+sqlite3_changes(sqlite3 *);
+
+int
+sqlite3_total_changes(sqlite3 *);
+
+void *
+sqlite3_user_data(sqlite3_context *);
+
+const char *
+sqlite3_libversion(void);
+
+const char *
+sqlite3_sourceid(void);
+
+void
+sqlite3_log(int iErrCode, const char *zFormat, ...);
+
+void *
+sqlite3_aggregate_context(sqlite3_context *,
+			  int nBytes);
+
+
+int
+sqlite3_column_count(sqlite3_stmt * pStmt);
+
+const char *
+sqlite3_column_name(sqlite3_stmt *, int N);
+
+const char *
+sqlite3_errmsg(sqlite3 *);
+
+int
+sqlite3_initialize(void);
+
+#define SQLITE_VERSION        "3.16.2"
+#define SQLITE_VERSION_NUMBER 3016002
+#define SQLITE_SOURCE_ID      "D 1970-01-01 00:00:00 00000000-0000-0000-0000-000000000000"
+
+int
+sqlite3_os_end(void);
+
+#define SQLITE_CONFIG_SINGLETHREAD  1	/* nil */
+#define SQLITE_CONFIG_MULTITHREAD   2	/* nil */
+#define SQLITE_CONFIG_SERIALIZED    3	/* nil */
+#define SQLITE_CONFIG_MALLOC        4	/* sqlite3_mem_methods* */
+#define SQLITE_CONFIG_GETMALLOC     5	/* sqlite3_mem_methods* */
+#define SQLITE_CONFIG_SCRATCH       6	/* void*, int sz, int N */
+#define SQLITE_CONFIG_PAGECACHE     7	/* void*, int sz, int N */
+#define SQLITE_CONFIG_HEAP          8	/* void*, int nByte, int min */
+#define SQLITE_CONFIG_MEMSTATUS     9	/* boolean */
+#define SQLITE_CONFIG_MUTEX        10	/* sqlite3_mutex_methods* */
+#define SQLITE_CONFIG_GETMUTEX     11	/* sqlite3_mutex_methods* */
+/* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */
+#define SQLITE_CONFIG_LOOKASIDE    13	/* int int */
+#define SQLITE_CONFIG_LOG          16	/* xFunc, void* */
+#define SQLITE_CONFIG_URI          17	/* int */
+#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20	/* int */
+#define SQLITE_CONFIG_SQLLOG       21	/* xSqllog, void* */
+#define SQLITE_CONFIG_MMAP_SIZE    22	/* sqlite3_int64, sqlite3_int64 */
+#define SQLITE_CONFIG_PMASZ               24	/* unsigned int szPma */
+#define SQLITE_CONFIG_STMTJRNL_SPILL      25	/* int nByte */
+
+#define SQLITE_DBCONFIG_MAINDBNAME            1000	/* const char* */
+#define SQLITE_DBCONFIG_LOOKASIDE             1001	/* void* int int */
+#define SQLITE_DBCONFIG_ENABLE_FKEY           1002	/* int int* */
+#define SQLITE_DBCONFIG_ENABLE_TRIGGER        1003	/* int int* */
+#define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004	/* int int* */
+#define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005	/* int int* */
+#define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE      1006	/* int int* */
+
+#define SQLITE_TRACE_STMT       0x01
+#define SQLITE_TRACE_PROFILE    0x02
+#define SQLITE_TRACE_ROW        0x04
+#define SQLITE_TRACE_CLOSE      0x08
+
+#define SQLITE_DETERMINISTIC    0x800
+
+#define SQLITE_STATUS_MEMORY_USED          0
+#define SQLITE_STATUS_PAGECACHE_USED       1
+#define SQLITE_STATUS_PAGECACHE_OVERFLOW   2
+#define SQLITE_STATUS_SCRATCH_USED         3
+#define SQLITE_STATUS_SCRATCH_OVERFLOW     4
+#define SQLITE_STATUS_MALLOC_SIZE          5
+#define SQLITE_STATUS_PARSER_STACK         6
+#define SQLITE_STATUS_PAGECACHE_SIZE       7
+#define SQLITE_STATUS_SCRATCH_SIZE         8
+#define SQLITE_STATUS_MALLOC_COUNT         9
+
+sqlite3_int64
+sqlite3_memory_used(void);
+
+int
+sqlite3_create_function_v2(sqlite3 * db,
+			   const char *zFunctionName,
+			   int nArg,
+			   int flags,
+			   void *pApp,
+			   void (*xFunc) (sqlite3_context *,
+					  int,
+					  sqlite3_value **),
+			   void (*xStep) (sqlite3_context *,
+					  int,
+					  sqlite3_value **),
+			   void (*xFinal)
+			   (sqlite3_context *),
+			   void (*xDestroy) (void *)
+	);
+
+#define SQLITE_OPEN_READONLY         0x00000001	/* Ok for sqlite3_open_v2() */
+#define SQLITE_OPEN_READWRITE        0x00000002	/* Ok for sqlite3_open_v2() */
+#define SQLITE_OPEN_CREATE           0x00000004	/* Ok for sqlite3_open_v2() */
+#define SQLITE_OPEN_DELETEONCLOSE    0x00000008	/* VFS only */
+#define SQLITE_OPEN_EXCLUSIVE        0x00000010	/* VFS only */
+#define SQLITE_OPEN_AUTOPROXY        0x00000020	/* VFS only */
+#define SQLITE_OPEN_URI              0x00000040	/* Ok for sqlite3_open_v2() */
+#define SQLITE_OPEN_MEMORY           0x00000080	/* Ok for sqlite3_open_v2() */
+#define SQLITE_OPEN_MAIN_DB          0x00000100	/* VFS only */
+#define SQLITE_OPEN_TEMP_DB          0x00000200	/* VFS only */
+#define SQLITE_OPEN_TRANSIENT_DB     0x00000400	/* VFS only */
+#define SQLITE_OPEN_NOMUTEX          0x00008000	/* Ok for sqlite3_open_v2() */
+#define SQLITE_OPEN_FULLMUTEX        0x00010000	/* Ok for sqlite3_open_v2() */
+#define SQLITE_OPEN_SHAREDCACHE      0x00020000	/* Ok for sqlite3_open_v2() */
+#define SQLITE_OPEN_PRIVATECACHE     0x00040000	/* Ok for sqlite3_open_v2() */
+
+sqlite3_vfs *
+sqlite3_vfs_find(const char *zVfsName);
+
+#define SQLITE_TESTCTRL_FIRST                    5
+#define SQLITE_TESTCTRL_PRNG_SAVE                5
+#define SQLITE_TESTCTRL_PRNG_RESTORE             6
+#define SQLITE_TESTCTRL_PRNG_RESET               7
+#define SQLITE_TESTCTRL_BITVEC_TEST              8
+#define SQLITE_TESTCTRL_FAULT_INSTALL            9
+#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS     10
+#define SQLITE_TESTCTRL_PENDING_BYTE            11
+#define SQLITE_TESTCTRL_ASSERT                  12
+#define SQLITE_TESTCTRL_ALWAYS                  13
+#define SQLITE_TESTCTRL_RESERVE                 14
+#define SQLITE_TESTCTRL_OPTIMIZATIONS           15
+#define SQLITE_TESTCTRL_ISKEYWORD               16
+#define SQLITE_TESTCTRL_SCRATCHMALLOC           17
+#define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
+#define SQLITE_TESTCTRL_EXPLAIN_STMT            19	/* NOT USED */
+#define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD    19
+#define SQLITE_TESTCTRL_NEVER_CORRUPT           20
+#define SQLITE_TESTCTRL_VDBE_COVERAGE           21
+#define SQLITE_TESTCTRL_BYTEORDER               22
+#define SQLITE_TESTCTRL_ISINIT                  23
+#define SQLITE_TESTCTRL_SORTER_MMAP             24
+#define SQLITE_TESTCTRL_IMPOSTER                25
+#define SQLITE_TESTCTRL_LAST                    25
+
+int
+sqlite3_status64(int op, sqlite3_int64 * pCurrent,
+		 sqlite3_int64 * pHighwater,
+		 int resetFlag);
+
+int
+sqlite3_config(int, ...);
+
+
+typedef struct sqlite3_io_methods sqlite3_io_methods;
+struct sqlite3_io_methods {
+	int iVersion;
+	int (*xClose) (sqlite3_file *);
+	int (*xRead) (sqlite3_file *, void *, int iAmt,
+		      sqlite3_int64 iOfst);
+	int (*xWrite) (sqlite3_file *, const void *, int iAmt,
+		       sqlite3_int64 iOfst);
+	int (*xTruncate) (sqlite3_file *, sqlite3_int64 size);
+	int (*xSync) (sqlite3_file *, int flags);
+	int (*xFileSize) (sqlite3_file *, sqlite3_int64 * pSize);
+	int (*xLock) (sqlite3_file *, int);
+	int (*xUnlock) (sqlite3_file *, int);
+	int (*xCheckReservedLock) (sqlite3_file *, int *pResOut);
+	int (*xFileControl) (sqlite3_file *, int op, void *pArg);
+	int (*xSectorSize) (sqlite3_file *);
+	int (*xDeviceCharacteristics) (sqlite3_file *);
+	/* Methods above are valid for version 1 */
+	int (*xShmMap) (sqlite3_file *, int iPg, int pgsz, int,
+			void volatile **);
+	int (*xShmLock) (sqlite3_file *, int offset, int n, int flags);
+	void (*xShmBarrier) (sqlite3_file *);
+	int (*xShmUnmap) (sqlite3_file *, int deleteFlag);
+	/* Methods above are valid for version 2 */
+	int (*xFetch) (sqlite3_file *, sqlite3_int64 iOfst, int iAmt,
+		       void **pp);
+	int (*xUnfetch) (sqlite3_file *, sqlite3_int64 iOfst, void *p);
+	/* Methods above are valid for version 3 */
+	/* Additional methods may be added in future releases */
+};
+
+#define SQLITE_FCNTL_LOCKSTATE               1
+#define SQLITE_FCNTL_GET_LOCKPROXYFILE       2
+#define SQLITE_FCNTL_SET_LOCKPROXYFILE       3
+#define SQLITE_FCNTL_LAST_ERRNO              4
+#define SQLITE_FCNTL_SIZE_HINT               5
+#define SQLITE_FCNTL_CHUNK_SIZE              6
+#define SQLITE_FCNTL_FILE_POINTER            7
+#define SQLITE_FCNTL_SYNC_OMITTED            8
+#define SQLITE_FCNTL_OVERWRITE              10
+#define SQLITE_FCNTL_VFSNAME                11
+#define SQLITE_FCNTL_POWERSAFE_OVERWRITE    12
+#define SQLITE_FCNTL_PRAGMA                 13
+#define SQLITE_FCNTL_BUSYHANDLER            14
+#define SQLITE_FCNTL_TEMPFILENAME           15
+#define SQLITE_FCNTL_MMAP_SIZE              16
+#define SQLITE_FCNTL_TRACE                  17
+#define SQLITE_FCNTL_HAS_MOVED              18
+#define SQLITE_FCNTL_SYNC                   19
+#define SQLITE_FCNTL_COMMIT_PHASETWO        20
+#define SQLITE_FCNTL_ZIPVFS                 22
+#define SQLITE_FCNTL_RBU                    23
+#define SQLITE_FCNTL_VFS_POINTER            24
+#define SQLITE_FCNTL_PDB                    26
+
+int
+sqlite3_os_init(void);
+
+int
+sqlite3_db_release_memory(sqlite3 *);
+
+int
+sqlite3_busy_timeout(sqlite3 *, int ms);
+
+sqlite3_int64
+sqlite3_soft_heap_limit64(sqlite3_int64 N);
+
+int
+sqlite3_limit(sqlite3 *, int id, int newVal);
+
+#define SQLITE_SYNC_NORMAL        0x00002
+#define SQLITE_SYNC_FULL          0x00003
+#define SQLITE_SYNC_DATAONLY      0x00010
+
+#define SQLITE_IOCAP_ATOMIC                 0x00000001
+#define SQLITE_IOCAP_ATOMIC512              0x00000002
+#define SQLITE_IOCAP_ATOMIC1K               0x00000004
+#define SQLITE_IOCAP_ATOMIC2K               0x00000008
+#define SQLITE_IOCAP_ATOMIC4K               0x00000010
+#define SQLITE_IOCAP_ATOMIC8K               0x00000020
+#define SQLITE_IOCAP_ATOMIC16K              0x00000040
+#define SQLITE_IOCAP_ATOMIC32K              0x00000080
+#define SQLITE_IOCAP_ATOMIC64K              0x00000100
+#define SQLITE_IOCAP_SAFE_APPEND            0x00000200
+#define SQLITE_IOCAP_SEQUENTIAL             0x00000400
+#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN  0x00000800
+#define SQLITE_IOCAP_POWERSAFE_OVERWRITE    0x00001000
+#define SQLITE_IOCAP_IMMUTABLE              0x00002000
+
+int
+sqlite3_uri_boolean(const char *zFile,
+		    const char *zParam, int bDefault);
+
+extern char *
+sqlite3_temp_directory;
+
+const char *
+sqlite3_uri_parameter(const char *zFilename,
+		      const char *zParam);
+
+#define SQLITE_ACCESS_EXISTS    0
+#define SQLITE_ACCESS_READWRITE 1	/* Used by PRAGMA temp_store_directory */
+#define SQLITE_ACCESS_READ      2	/* Unused */
+
+#define SQLITE_DBSTATUS_LOOKASIDE_USED       0
+#define SQLITE_DBSTATUS_CACHE_USED           1
+#define SQLITE_DBSTATUS_SCHEMA_USED          2
+#define SQLITE_DBSTATUS_STMT_USED            3
+#define SQLITE_DBSTATUS_LOOKASIDE_HIT        4
+#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE  5
+#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL  6
+#define SQLITE_DBSTATUS_CACHE_HIT            7
+#define SQLITE_DBSTATUS_CACHE_MISS           8
+#define SQLITE_DBSTATUS_CACHE_WRITE          9
+#define SQLITE_DBSTATUS_DEFERRED_FKS        10
+#define SQLITE_DBSTATUS_CACHE_USED_SHARED   11
+#define SQLITE_DBSTATUS_MAX                 11	/* Largest defined DBSTATUS */
+
+const char *
+sqlite3_sql(sqlite3_stmt * pStmt);
+
+int
+sqlite3_vfs_register(sqlite3_vfs *, int makeDflt);
+
+void
+sqlite3_free_table(char **result);
+
+#define SQLITE_STMTSTATUS_FULLSCAN_STEP     1
+#define SQLITE_STMTSTATUS_SORT              2
+#define SQLITE_STMTSTATUS_AUTOINDEX         3
+#define SQLITE_STMTSTATUS_VM_STEP           4
+
+void
+sqlite3_interrupt(sqlite3 *);
+
+int
+sqlite3_bind_blob(sqlite3_stmt *, int, const void *,
+		  int n, void (*)(void *));
+
+int
+sqlite3_bind_blob64(sqlite3_stmt *, int, const void *,
+		    sqlite3_uint64, void (*)(void *));
+
+int
+sqlite3_bind_double(sqlite3_stmt *, int, double);
+
+int
+sqlite3_bind_int(sqlite3_stmt *, int, int);
+
+int
+sqlite3_bind_int64(sqlite3_stmt *, int, sqlite3_int64);
+
+int
+sqlite3_bind_null(sqlite3_stmt *, int);
+
+int
+sqlite3_bind_text(sqlite3_stmt *, int, const char *, int,
+		  void (*)(void *));
+
+int
+sqlite3_bind_text64(sqlite3_stmt *, int, const char *,
+		    sqlite3_uint64, void (*)(void *));
+int
+sqlite3_bind_value(sqlite3_stmt *, int,
+		   const sqlite3_value *);
+
+int
+sqlite3_bind_zeroblob(sqlite3_stmt *, int, int n);
+
+int
+sqlite3_bind_zeroblob64(sqlite3_stmt *, int,
+			sqlite3_uint64);
+
+int
+sqlite3_stmt_busy(sqlite3_stmt *);
+
+int
+sql_init_db(sqlite3 **db);
+
+int
+sqlite3_close(sqlite3 *);
+
+
+/**
+ * Get number of the named parameter in the prepared sql
+ * statement.
+ * @param pStmt Prepared statement.
+ * @param zName Parameter name.
+ * @param nName Parameter name length.
+ *
+ * @retval > 0 Number of the parameter.
+ * @retval   0 Parameter is not found.
+ */
+int
+sqlite3_bind_parameter_lindex(sqlite3_stmt * pStmt, const char *zName,
+			      int nName);
+
 /*
  * If compiling for a processor that lacks floating point support,
  * substitute integer for floating-point
@@ -3499,7 +4271,7 @@ void sqlite3ParserTrace(FILE *, char *);
 #ifdef SQLITE_ENABLE_IOTRACE
 #define IOTRACE(A)  if( sqlite3IoTrace ){ sqlite3IoTrace A; }
 void sqlite3VdbeIOTraceSql(Vdbe *);
-SQLITE_API SQLITE_EXTERN void (SQLITE_CDECL * sqlite3IoTrace) (const char *,
+ SQLITE_EXTERN void (SQLITE_CDECL * sqlite3IoTrace) (const char *,
 							       ...);
 #else
 #define IOTRACE(A)
-- 
2.11.0

^ permalink raw reply	[flat|nested] 6+ messages in thread

* [tarantool-patches] [PATCH 2/4] sql: remove mutexes around the code
  2018-03-26 15:56 [tarantool-patches] [PATCH 0/4] Cleanup SQL memory and threading subsystems Kirill Yukhin
  2018-03-26 15:56 ` [tarantool-patches] [PATCH 1/4] sql: Remove all references to sqlite3.h Kirill Yukhin
@ 2018-03-26 15:56 ` Kirill Yukhin
  2018-03-26 15:56 ` [tarantool-patches] [PATCH 3/4] sql: remove dead memory allocation systems Kirill Yukhin
                   ` (2 subsequent siblings)
  4 siblings, 0 replies; 6+ messages in thread
From: Kirill Yukhin @ 2018-03-26 15:56 UTC (permalink / raw)
  To: v.shpilevoy; +Cc: tarantool-patches, Kirill Yukhin

This is first part, which will be likely squashed with
following. Tests pass.
---
 src/box/sql/CMakeLists.txt |   4 -
 src/box/sql/date.c         |   7 --
 src/box/sql/func.c         |   2 -
 src/box/sql/global.c       |   6 --
 src/box/sql/legacy.c       |   2 -
 src/box/sql/main.c         | 200 ++-------------------------------------------
 src/box/sql/malloc.c       |  53 ++----------
 src/box/sql/os.c           |  21 -----
 src/box/sql/os_unix.c      | 143 ++------------------------------
 src/box/sql/prepare.c      |   8 --
 src/box/sql/printf.c       |   6 --
 src/box/sql/random.c       |  11 ---
 src/box/sql/sqliteInt.h    |  71 +---------------
 src/box/sql/status.c       |   9 +-
 src/box/sql/tokenize.c     |   2 -
 src/box/sql/vdbe.c         |   5 +-
 src/box/sql/vdbeapi.c      |  54 ------------
 src/box/sql/vdbeaux.c      |   2 -
 src/box/sql/vdbemem.c      |  17 ----
 src/box/sql/vdbesort.c     |   6 +-
 20 files changed, 27 insertions(+), 602 deletions(-)

diff --git a/src/box/sql/CMakeLists.txt b/src/box/sql/CMakeLists.txt
index 238e185..8494e15 100644
--- a/src/box/sql/CMakeLists.txt
+++ b/src/box/sql/CMakeLists.txt
@@ -14,7 +14,6 @@ set(SRCDIR ${CMAKE_CURRENT_SOURCE_DIR})
 include_directories(${SRCDIR})
 
 add_definitions(-DSQLITE_MAX_WORKER_THREADS=0)
-add_definitions(-DTHREADSAFE=0)
 add_definitions(-DSQLITE_DEFAULT_FOREIGN_KEYS=1)
 add_definitions(-DSQLITE_OMIT_AUTOMATIC_INDEX)
 
@@ -54,9 +53,6 @@ add_library(sql STATIC
     mem2.c
     mem3.c
     mem5.c
-    mutex.c
-    mutex_noop.c
-    mutex_unix.c
     os.c
     os_unix.c
     pragma.c
diff --git a/src/box/sql/date.c b/src/box/sql/date.c
index 21df6df..9566cc3 100644
--- a/src/box/sql/date.c
+++ b/src/box/sql/date.c
@@ -545,10 +545,6 @@ osLocaltime(time_t * t, struct tm *pTm)
 	int rc;
 #if !HAVE_LOCALTIME_R && !HAVE_LOCALTIME_S
 	struct tm *pX;
-#if SQLITE_THREADSAFE>0
-	sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
-#endif
-	sqlite3_mutex_enter(mutex);
 	pX = localtime(t);
 #ifndef SQLITE_UNTESTABLE
 	if (sqlite3GlobalConfig.bLocaltimeFault)
@@ -556,7 +552,6 @@ osLocaltime(time_t * t, struct tm *pTm)
 #endif
 	if (pX)
 		*pTm = *pX;
-	sqlite3_mutex_leave(mutex);
 	rc = pX == 0;
 #else
 #ifndef SQLITE_UNTESTABLE
@@ -1290,11 +1285,9 @@ currentTimeFunc(sqlite3_context * context, int argc, sqlite3_value ** argv)
 #if HAVE_GMTIME_R
 	pTm = gmtime_r(&t, &sNow);
 #else
-	sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
 	pTm = gmtime(&t);
 	if (pTm)
 		memcpy(&sNow, pTm, sizeof(sNow));
-	sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
 #endif
 	if (pTm) {
 		strftime(zBuf, 20, zFormat, &sNow);
diff --git a/src/box/sql/func.c b/src/box/sql/func.c
index d8d39a2..47b45de 100644
--- a/src/box/sql/func.c
+++ b/src/box/sql/func.c
@@ -1712,12 +1712,10 @@ sqlite3_overload_function(sqlite3 * db, const char *zName, int nArg)
 		return SQLITE_MISUSE_BKPT;
 	}
 #endif
-	sqlite3_mutex_enter(db->mutex);
 	if (sqlite3FindFunction(db, zName, nArg, 0) == 0) {
 		rc = sqlite3CreateFunc(db, zName, nArg, 0, 0, sqlite3InvalidFunction, 0, 0, 0);
 	}
 	rc = sqlite3ApiExit(db, rc);
-	sqlite3_mutex_leave(db->mutex);
 	return rc;
 }
 
diff --git a/src/box/sql/global.c b/src/box/sql/global.c
index 97bdbe6..6a78550 100644
--- a/src/box/sql/global.c
+++ b/src/box/sql/global.c
@@ -195,8 +195,6 @@ const unsigned char sqlite3CtypeMap[256] = {
  */
 SQLITE_WSD struct Sqlite3Config sqlite3Config = {
 	SQLITE_DEFAULT_MEMSTATUS,	/* bMemstat */
-	1,			/* bCoreMutex */
-	SQLITE_THREADSAFE == 1,	/* bFullMutex */
 	SQLITE_USE_URI,		/* bOpenUri */
 	SQLITE_ALLOW_COVERING_INDEX_SCAN,	/* bUseCis */
 	0x7ffffffe,		/* mxStrlen */
@@ -205,7 +203,6 @@ SQLITE_WSD struct Sqlite3Config sqlite3Config = {
 	125,			/* nLookaside */
 	0,			/* nStmtSpill */
 	{0, 0, 0, 0, 0, 0, 0, 0},	/* m */
-	{0, 0, 0, 0, 0, 0, 0, 0, 0},	/* mutex */
 	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},	/* pcache2 */
 	(void *)0,		/* pHeap */
 	0,			/* nHeap */
@@ -224,10 +221,7 @@ SQLITE_WSD struct Sqlite3Config sqlite3Config = {
 	/* All the rest should always be initialized to zero */
 	0,			/* isInit */
 	0,			/* inProgress */
-	0,			/* isMutexInit */
 	0,			/* isMallocInit */
-	0,			/* nRefInitMutex */
-	0,			/* pInitMutex */
 	0,			/* xLog */
 	0,			/* pLogArg */
 #ifdef SQLITE_ENABLE_SQLLOG
diff --git a/src/box/sql/legacy.c b/src/box/sql/legacy.c
index e757095..978cf01 100644
--- a/src/box/sql/legacy.c
+++ b/src/box/sql/legacy.c
@@ -69,7 +69,6 @@ sqlite3_exec(sqlite3 * db,	/* The database on which the SQL executes */
 	if (zSql == 0)
 		zSql = "";
 
-	sqlite3_mutex_enter(db->mutex);
 	sqlite3Error(db, SQLITE_OK);
 	while (rc == SQLITE_OK && zSql[0]) {
 		int nCol;
@@ -184,6 +183,5 @@ sqlite3_exec(sqlite3 * db,	/* The database on which the SQL executes */
 	}
 
 	assert((rc & db->errMask) == rc);
-	sqlite3_mutex_leave(db->mutex);
 	return rc;
 }
diff --git a/src/box/sql/main.c b/src/box/sql/main.c
index f0333fa..1f8c026 100644
--- a/src/box/sql/main.c
+++ b/src/box/sql/main.c
@@ -90,16 +90,6 @@ sqlite3_libversion_number(void)
 	return SQLITE_VERSION_NUMBER;
 }
 
-/* IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns
- * zero if and only if SQLite was compiled with mutexing code omitted due to
- * the SQLITE_THREADSAFE compile-time option being set to 0.
- */
-int
-sqlite3_threadsafe(void)
-{
-	return SQLITE_THREADSAFE;
-}
-
 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
 /*
  * If the following function pointer is not NULL and if
@@ -132,7 +122,7 @@ char *sqlite3_data_directory = 0;
  * Initialize SQLite.
  *
  * This routine must be called to initialize the memory allocation,
- * VFS, and mutex subsystems prior to doing any serious work with
+ * and VFS subsystems prior to doing any serious work with
  * SQLite.  But as long as you do not compile with SQLITE_OMIT_AUTOINIT
  * this routine will be called automatically by key routines such as
  * sqlite3_open().
@@ -162,9 +152,7 @@ char *sqlite3_data_directory = 0;
 int
 sqlite3_initialize(void)
 {
-	MUTEX_LOGIC(sqlite3_mutex * pMaster;
-	    )			/* The main static mutex */
-	int rc;			/* Result code */
+	int rc = SQLITE_OK;
 #ifdef SQLITE_EXTRA_INIT
 	int bRunExtraInit = 0;	/* Extra initialization needed */
 #endif
@@ -190,56 +178,18 @@ sqlite3_initialize(void)
 	if (sqlite3GlobalConfig.isInit)
 		return SQLITE_OK;
 
-	/* Make sure the mutex subsystem is initialized.  If unable to
-	 * initialize the mutex subsystem, return early with the error.
-	 * If the system is so sick that we are unable to allocate a mutex,
-	 * there is not much SQLite is going to be able to do.
-	 *
-	 * The mutex subsystem must take care of serializing its own
-	 * initialization.
-	 */
-	rc = sqlite3MutexInit();
-	if (rc)
-		return rc;
-
-	/* Initialize the malloc() system and the recursive pInitMutex mutex.
-	 * This operation is protected by the STATIC_MASTER mutex.  Note that
-	 * MutexAlloc() is called for a static mutex prior to initializing the
-	 * malloc subsystem - this implies that the allocation of a static
-	 * mutex must not require support from the malloc subsystem.
-	 */
-	MUTEX_LOGIC(pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
-	    )
-	    sqlite3_mutex_enter(pMaster);
-	sqlite3GlobalConfig.isMutexInit = 1;
-	if (!sqlite3GlobalConfig.isMallocInit) {
+	if (!sqlite3GlobalConfig.isMallocInit)
 		rc = sqlite3MallocInit();
-	}
-	if (rc == SQLITE_OK) {
+	if (rc == SQLITE_OK)
 		sqlite3GlobalConfig.isMallocInit = 1;
-		if (!sqlite3GlobalConfig.pInitMutex) {
-			sqlite3GlobalConfig.pInitMutex =
-			    sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
-			if (sqlite3GlobalConfig.bCoreMutex
-			    && !sqlite3GlobalConfig.pInitMutex) {
-				rc = SQLITE_NOMEM_BKPT;
-			}
-		}
-	}
-	if (rc == SQLITE_OK) {
-		sqlite3GlobalConfig.nRefInitMutex++;
-	}
-	sqlite3_mutex_leave(pMaster);
 
-	/* If rc is not SQLITE_OK at this point, then either the malloc
-	 * subsystem could not be initialized or the system failed to allocate
-	 * the pInitMutex mutex. Return an error in either case.
+	/* If rc is not SQLITE_OK at this point, then the malloc
+	 * subsystem could not be initialized.
 	 */
-	if (rc != SQLITE_OK) {
+	if (rc != SQLITE_OK)
 		return rc;
-	}
 
-	/* Do the rest of the initialization under the recursive mutex so
+	/* Do the rest of the initialization
 	 * that we will be able to handle recursive calls into
 	 * sqlite3_initialize().  The recursive calls normally come through
 	 * sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other
@@ -248,11 +198,9 @@ sqlite3_initialize(void)
 	 * IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls
 	 * to the xInit method, so the xInit method need not be threadsafe.
 	 *
-	 * The following mutex is what serializes access to the appdef pcache xInit
-	 * methods.  The sqlite3_pcache_methods.xInit() all is embedded in the
+         * The sqlite3_pcache_methods.xInit() all is embedded in the
 	 * call to sqlite3PcacheInitialize().
 	 */
-	sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex);
 	if (sqlite3GlobalConfig.isInit == 0
 	    && sqlite3GlobalConfig.inProgress == 0) {
 		sqlite3GlobalConfig.inProgress = 1;
@@ -276,19 +224,6 @@ sqlite3_initialize(void)
 		}
 		sqlite3GlobalConfig.inProgress = 0;
 	}
-	sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex);
-
-	/* Go back under the static mutex and clean up the recursive
-	 * mutex to prevent a resource leak.
-	 */
-	sqlite3_mutex_enter(pMaster);
-	sqlite3GlobalConfig.nRefInitMutex--;
-	if (sqlite3GlobalConfig.nRefInitMutex <= 0) {
-		assert(sqlite3GlobalConfig.nRefInitMutex == 0);
-		sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex);
-		sqlite3GlobalConfig.pInitMutex = 0;
-	}
-	sqlite3_mutex_leave(pMaster);
 
 	/* The following is just a sanity check to make sure SQLite has
 	 * been compiled correctly.  It is important to run this code, but
@@ -364,10 +299,6 @@ sqlite3_shutdown(void)
 		sqlite3_temp_directory = 0;
 #endif
 	}
-	if (sqlite3GlobalConfig.isMutexInit) {
-		sqlite3MutexEnd();
-		sqlite3GlobalConfig.isMutexInit = 0;
-	}
 
 	return SQLITE_OK;
 }
@@ -395,57 +326,6 @@ sqlite3_config(int op, ...)
 
 	va_start(ap, op);
 	switch (op) {
-
-		/* Mutex configuration options are only available in a threadsafe
-		 * compile.
-		 */
-#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0	/* IMP: R-54466-46756 */
-	case SQLITE_CONFIG_SINGLETHREAD:{
-			/* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to
-			 * Single-thread.
-			 */
-			sqlite3GlobalConfig.bCoreMutex = 0;	/* Disable mutex on core */
-			sqlite3GlobalConfig.bFullMutex = 0;	/* Disable mutex on connections */
-			break;
-		}
-#endif
-#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0	/* IMP: R-20520-54086 */
-	case SQLITE_CONFIG_MULTITHREAD:{
-			/* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to
-			 * Multi-thread.
-			 */
-			sqlite3GlobalConfig.bCoreMutex = 1;	/* Enable mutex on core */
-			sqlite3GlobalConfig.bFullMutex = 0;	/* Disable mutex on connections */
-			break;
-		}
-#endif
-#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0	/* IMP: R-59593-21810 */
-	case SQLITE_CONFIG_SERIALIZED:{
-			/* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to
-			 * Serialized.
-			 */
-			sqlite3GlobalConfig.bCoreMutex = 1;	/* Enable mutex on core */
-			sqlite3GlobalConfig.bFullMutex = 1;	/* Enable mutex on connections */
-			break;
-		}
-#endif
-#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0	/* IMP: R-63666-48755 */
-	case SQLITE_CONFIG_MUTEX:{
-			/* Specify an alternative mutex implementation */
-			sqlite3GlobalConfig.mutex =
-			    *va_arg(ap, sqlite3_mutex_methods *);
-			break;
-		}
-#endif
-#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0	/* IMP: R-14450-37597 */
-	case SQLITE_CONFIG_GETMUTEX:{
-			/* Retrieve the current mutex implementation */
-			*va_arg(ap, sqlite3_mutex_methods *) =
-			    sqlite3GlobalConfig.mutex;
-			break;
-		}
-#endif
-
 	case SQLITE_CONFIG_MALLOC:{
 			/* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a
 			 * single argument which is a pointer to an instance of the
@@ -709,21 +589,6 @@ setupLookaside(sqlite3 * db, void *pBuf, int sz, int cnt)
 }
 
 /*
- * Return the mutex associated with a database connection.
- */
-sqlite3_mutex *
-sqlite3_db_mutex(sqlite3 * db)
-{
-#ifdef SQLITE_ENABLE_API_ARMOR
-	if (!sqlite3SafetyCheckOk(db)) {
-		(void)SQLITE_MISUSE_BKPT;
-		return 0;
-	}
-#endif
-	return db->mutex;
-}
-
-/*
  * Free up as much memory as we can from the given database
  * connection.
  */
@@ -889,7 +754,6 @@ functionDestroy(sqlite3 * db, FuncDef * p)
 static int
 connectionIsBusy(sqlite3 * db)
 {
-	assert(sqlite3_mutex_held(db->mutex));
 	if (db->pVdbe)
 		return 1;
 	return 0;
@@ -910,7 +774,6 @@ sqlite3Close(sqlite3 * db, int forceZombie)
 	if (!sqlite3SafetyCheckSickOrOk(db)) {
 		return SQLITE_MISUSE_BKPT;
 	}
-	sqlite3_mutex_enter(db->mutex);
 	if (db->mTrace & SQLITE_TRACE_CLOSE) {
 		db->xTrace(SQLITE_TRACE_CLOSE, db->pTraceArg, db, 0);
 	}
@@ -922,7 +785,6 @@ sqlite3Close(sqlite3 * db, int forceZombie)
 		sqlite3ErrorWithMsg(db, SQLITE_BUSY,
 				    "unable to close due to unfinalized "
 				    "statements");
-		sqlite3_mutex_leave(db->mutex);
 		return SQLITE_BUSY;
 	}
 #ifdef SQLITE_ENABLE_SQLLOG
@@ -975,7 +837,6 @@ sqlite3RollbackAll(Vdbe * pVdbe, int tripCode)
 	int inTrans = 0;
 	(void)tripCode;
 	struct session *user_session = current_session();
-	assert(sqlite3_mutex_held(db->mutex));
 
 	/* DDL is impossible inside a transaction.  */
 	assert((user_session->sql_flags & SQLITE_InternChanges) == 0
@@ -1364,12 +1225,10 @@ sqlite3_busy_handler(sqlite3 * db, int (*xBusy) (void *, int), void *pArg)
 	if (!sqlite3SafetyCheckOk(db))
 		return SQLITE_MISUSE_BKPT;
 #endif
-	sqlite3_mutex_enter(db->mutex);
 	db->busyHandler.xFunc = xBusy;
 	db->busyHandler.pArg = pArg;
 	db->busyHandler.nBusy = 0;
 	db->busyTimeout = 0;
-	sqlite3_mutex_leave(db->mutex);
 	return SQLITE_OK;
 }
 
@@ -1389,7 +1248,6 @@ sqlite3_progress_handler(sqlite3 * db,
 		return;
 	}
 #endif
-	sqlite3_mutex_enter(db->mutex);
 	if (nOps > 0) {
 		db->xProgress = xProgress;
 		db->nProgressOps = (unsigned)nOps;
@@ -1399,7 +1257,6 @@ sqlite3_progress_handler(sqlite3 * db,
 		db->nProgressOps = 0;
 		db->pProgressArg = 0;
 	}
-	sqlite3_mutex_leave(db->mutex);
 }
 #endif
 
@@ -1459,7 +1316,6 @@ sqlite3CreateFunc(sqlite3 * db,
 	FuncDef *p;
 	int extraFlags;
 
-	assert(sqlite3_mutex_held(db->mutex));
 	if (zFunctionName == 0 ||
 	    (xSFunc && (xFinal || xStep)) ||
 	    (!xSFunc && (xFinal && !xStep)) ||
@@ -1554,7 +1410,6 @@ sqlite3_create_function_v2(sqlite3 * db,
 		return SQLITE_MISUSE_BKPT;
 	}
 #endif
-	sqlite3_mutex_enter(db->mutex);
 	if (xDestroy) {
 		pArg =
 		    (FuncDestructor *) sqlite3DbMallocZero(db,
@@ -1577,7 +1432,6 @@ sqlite3_create_function_v2(sqlite3 * db,
 
  out:
 	rc = sqlite3ApiExit(db, rc);
-	sqlite3_mutex_leave(db->mutex);
 	return rc;
 }
 
@@ -1595,7 +1449,6 @@ sqlite3_trace_v2(sqlite3 * db,		/* Trace this connection */
 		return SQLITE_MISUSE_BKPT;
 	}
 #endif
-	sqlite3_mutex_enter(db->mutex);
 	if (mTrace == 0)
 		xTrace = 0;
 	if (xTrace == 0)
@@ -1603,7 +1456,6 @@ sqlite3_trace_v2(sqlite3 * db,		/* Trace this connection */
 	db->mTrace = mTrace;
 	db->xTrace = xTrace;
 	db->pTraceArg = pArg;
-	sqlite3_mutex_leave(db->mutex);
 	return SQLITE_OK;
 }
 
@@ -1627,11 +1479,9 @@ sqlite3_commit_hook(sqlite3 * db,	/* Attach the hook to this database */
 		return 0;
 	}
 #endif
-	sqlite3_mutex_enter(db->mutex);
 	pOld = db->pCommitArg;
 	db->xCommitCallback = xCallback;
 	db->pCommitArg = pArg;
-	sqlite3_mutex_leave(db->mutex);
 	return pOld;
 }
 
@@ -1653,11 +1503,9 @@ sqlite3_update_hook(sqlite3 * db,	/* Attach the hook to this database */
 		return 0;
 	}
 #endif
-	sqlite3_mutex_enter(db->mutex);
 	pRet = db->pUpdateArg;
 	db->xUpdateCallback = xCallback;
 	db->pUpdateArg = pArg;
-	sqlite3_mutex_leave(db->mutex);
 	return pRet;
 }
 
@@ -1678,11 +1526,9 @@ sqlite3_rollback_hook(sqlite3 * db,	/* Attach the hook to this database */
 		return 0;
 	}
 #endif
-	sqlite3_mutex_enter(db->mutex);
 	pRet = db->pRollbackArg;
 	db->xRollbackCallback = xCallback;
 	db->pRollbackArg = pArg;
-	sqlite3_mutex_leave(db->mutex);
 	return pRet;
 }
 
@@ -1699,11 +1545,9 @@ sqlite3_preupdate_hook(sqlite3 * db,		/* Attach the hook to this database */
 		       void *pArg)		/* First callback argument */
 {
 	void *pRet;
-	sqlite3_mutex_enter(db->mutex);
 	pRet = db->pPreUpdateArg;
 	db->xPreUpdateCallback = xCallback;
 	db->pPreUpdateArg = pArg;
-	sqlite3_mutex_leave(db->mutex);
 	return pRet;
 }
 #endif				/* SQLITE_ENABLE_PREUPDATE_HOOK */
@@ -1779,7 +1623,6 @@ sqlite3_errmsg(sqlite3 * db)
 	if (!sqlite3SafetyCheckSickOrOk(db)) {
 		return sqlite3ErrStr(SQLITE_MISUSE_BKPT);
 	}
-	sqlite3_mutex_enter(db->mutex);
 	if (db->mallocFailed) {
 		z = sqlite3ErrStr(SQLITE_NOMEM_BKPT);
 	} else {
@@ -1790,7 +1633,6 @@ sqlite3_errmsg(sqlite3 * db)
 			z = sqlite3ErrStr(db->errCode);
 		}
 	}
-	sqlite3_mutex_leave(db->mutex);
 	return z;
 }
 
@@ -2256,7 +2098,6 @@ sql_init_db(sqlite3 **out_db)
 {
 	sqlite3 *db;
 	int rc;			/* Return code */
-	int isThreadsafe;	/* True for threadsafe connections */
 
 #ifdef SQLITE_ENABLE_API_ARMOR
 	if (ppDb == 0)
@@ -2268,24 +2109,10 @@ sql_init_db(sqlite3 **out_db)
 		return rc;
 #endif
 
-	if (sqlite3GlobalConfig.bCoreMutex == 0) {
-		isThreadsafe = 0;
-	} else {
-		isThreadsafe = sqlite3GlobalConfig.bFullMutex;
-	}
 	/* Allocate the sqlite data structure */
 	db = sqlite3MallocZero(sizeof(sqlite3));
 	if (db == 0)
 		goto opendb_out;
-	if (isThreadsafe) {
-		db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
-		if (db->mutex == 0) {
-			sqlite3_free(db);
-			db = 0;
-			goto opendb_out;
-		}
-	}
-	sqlite3_mutex_enter(db->mutex);
 	db->errMask = 0xff;
 	db->magic = SQLITE_MAGIC_BUSY;
 
@@ -2382,11 +2209,6 @@ sql_init_db(sqlite3 **out_db)
 			sqlite3CommitInternalChanges();
 	}
 opendb_out:
-	if (db) {
-		assert(db->mutex != 0 || isThreadsafe == 0
-		       || sqlite3GlobalConfig.bFullMutex == 0);
-		sqlite3_mutex_leave(db->mutex);
-	}
 	rc = sqlite3_errcode(db);
 	assert(db != 0 || rc == SQLITE_NOMEM);
 	if (rc == SQLITE_NOMEM) {
@@ -2492,9 +2314,7 @@ sqlite3_extended_result_codes(sqlite3 * db, int onoff)
 	if (!sqlite3SafetyCheckOk(db))
 		return SQLITE_MISUSE_BKPT;
 #endif
-	sqlite3_mutex_enter(db->mutex);
 	db->errMask = onoff ? 0xffffffff : 0xff;
-	sqlite3_mutex_leave(db->mutex);
 	return SQLITE_OK;
 }
 
@@ -2805,14 +2625,12 @@ sqlite3_test_control(int op, ...)
 		 */
 	case SQLITE_TESTCTRL_IMPOSTER:{
 			sqlite3 *db = va_arg(ap, sqlite3 *);
-			sqlite3_mutex_enter(db->mutex);
 			db->init.busy = db->init.imposterTable =
 			    va_arg(ap, int);
 			db->init.newTnum = va_arg(ap, int);
 			if (db->init.busy == 0 && db->init.newTnum > 0) {
 				sqlite3ResetAllSchemasOfConnection(db);
 			}
-			sqlite3_mutex_leave(db->mutex);
 			break;
 		}
 	}
diff --git a/src/box/sql/malloc.c b/src/box/sql/malloc.c
index 325faf5..0a8107a 100644
--- a/src/box/sql/malloc.c
+++ b/src/box/sql/malloc.c
@@ -68,7 +68,6 @@ typedef struct ScratchFreeslot {
  * State information local to the memory allocation subsystem.
  */
 static SQLITE_WSD struct Mem0Global {
-	sqlite3_mutex *mutex;	/* Mutex to serialize access */
 	sqlite3_int64 alarmThreshold;	/* The soft heap limit */
 
 	/*
@@ -87,18 +86,10 @@ static SQLITE_WSD struct Mem0Global {
 	 */
 	int nearlyFull;
 } mem0 = {
-0, 0, 0, 0, 0, 0};
+0, 0, 0, 0, 0};
 
 #define mem0 GLOBAL(struct Mem0Global, mem0)
 
-/*
- * Return the memory allocator mutex. sqlite3_status() needs it.
- */
-sqlite3_mutex *
-sqlite3MallocMutex(void)
-{
-	return mem0.mutex;
-}
 
 /*
  * Set the soft heap-size limit for the library. Passing a zero or
@@ -115,16 +106,13 @@ sqlite3_soft_heap_limit64(sqlite3_int64 n)
 	if (rc)
 		return -1;
 #endif
-	sqlite3_mutex_enter(mem0.mutex);
 	priorLimit = mem0.alarmThreshold;
 	if (n < 0) {
-		sqlite3_mutex_leave(mem0.mutex);
 		return priorLimit;
 	}
 	mem0.alarmThreshold = n;
 	nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
 	mem0.nearlyFull = (n > 0 && n <= nUsed);
-	sqlite3_mutex_leave(mem0.mutex);
 	excess = sqlite3_memory_used() - n;
 	if (excess > 0)
 		sqlite3_release_memory((int)(excess & 0x7fffffff));
@@ -150,7 +138,6 @@ sqlite3MallocInit(void)
 		sqlite3MemSetDefault();
 	}
 	memset(&mem0, 0, sizeof(mem0));
-	mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
 	if (sqlite3GlobalConfig.pScratch && sqlite3GlobalConfig.szScratch >= 100
 	    && sqlite3GlobalConfig.nScratch > 0) {
 		int i, n, sz;
@@ -239,9 +226,7 @@ sqlite3MallocAlarm(int nByte)
 {
 	if (mem0.alarmThreshold <= 0)
 		return;
-	sqlite3_mutex_leave(mem0.mutex);
 	sqlite3_release_memory(nByte);
-	sqlite3_mutex_enter(mem0.mutex);
 }
 
 /*
@@ -253,7 +238,6 @@ mallocWithAlarm(int n, void **pp)
 {
 	int nFull;
 	void *p;
-	assert(sqlite3_mutex_held(mem0.mutex));
 	nFull = sqlite3GlobalConfig.m.xRoundup(n);
 	sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n);
 	if (mem0.alarmThreshold > 0) {
@@ -299,9 +283,7 @@ sqlite3Malloc(u64 n)
 		 */
 		p = 0;
 	} else if (sqlite3GlobalConfig.bMemstat) {
-		sqlite3_mutex_enter(mem0.mutex);
 		mallocWithAlarm((int)n, &p);
-		sqlite3_mutex_leave(mem0.mutex);
 	} else {
 		p = sqlite3GlobalConfig.m.xMalloc((int)n);
 	}
@@ -340,7 +322,7 @@ sqlite3_malloc64(sqlite3_uint64 n)
  * case by setting scratchAllocOut to 1 when an allocation
  * is outstanding clearing it when the allocation is freed.
  */
-#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
+#if !defined(NDEBUG)
 static int scratchAllocOut = 0;
 #endif
 
@@ -358,28 +340,22 @@ sqlite3ScratchMalloc(int n)
 	void *p;
 	assert(n > 0);
 
-	sqlite3_mutex_enter(mem0.mutex);
 	sqlite3StatusHighwater(SQLITE_STATUS_SCRATCH_SIZE, n);
 	if (mem0.nScratchFree && sqlite3GlobalConfig.szScratch >= n) {
 		p = mem0.pScratchFree;
 		mem0.pScratchFree = mem0.pScratchFree->pNext;
 		mem0.nScratchFree--;
 		sqlite3StatusUp(SQLITE_STATUS_SCRATCH_USED, 1);
-		sqlite3_mutex_leave(mem0.mutex);
 	} else {
-		sqlite3_mutex_leave(mem0.mutex);
 		p = sqlite3Malloc(n);
 		if (sqlite3GlobalConfig.bMemstat && p) {
-			sqlite3_mutex_enter(mem0.mutex);
 			sqlite3StatusUp(SQLITE_STATUS_SCRATCH_OVERFLOW,
 					sqlite3MallocSize(p));
-			sqlite3_mutex_leave(mem0.mutex);
 		}
 		sqlite3MemdebugSetType(p, MEMTYPE_SCRATCH);
 	}
-	assert(sqlite3_mutex_notheld(mem0.mutex));
 
-#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
+#if !defined(NDEBUG)
 	/* EVIDENCE-OF: R-12970-05880 SQLite will not use more than one scratch
 	 * buffers per thread.
 	 *
@@ -398,7 +374,7 @@ sqlite3ScratchFree(void *p)
 {
 	if (p) {
 
-#if SQLITE_THREADSAFE==0 && !defined(NDEBUG)
+#if !defined(NDEBUG)
 		/* Verify that no more than two scratch allocation per thread
 		 * is outstanding at one time.  (This is only checked in the
 		 * single-threaded case since checking in the multi-threaded case
@@ -413,14 +389,12 @@ sqlite3ScratchFree(void *p)
 			/* Release memory from the SQLITE_CONFIG_SCRATCH allocation */
 			ScratchFreeslot *pSlot;
 			pSlot = (ScratchFreeslot *) p;
-			sqlite3_mutex_enter(mem0.mutex);
 			pSlot->pNext = mem0.pScratchFree;
 			mem0.pScratchFree = pSlot;
 			mem0.nScratchFree++;
 			assert(mem0.nScratchFree <=
 			       (u32) sqlite3GlobalConfig.nScratch);
 			sqlite3StatusDown(SQLITE_STATUS_SCRATCH_USED, 1);
-			sqlite3_mutex_leave(mem0.mutex);
 		} else {
 			/* Release memory back to the heap */
 			assert(sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH));
@@ -429,7 +403,6 @@ sqlite3ScratchFree(void *p)
 			sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
 			if (sqlite3GlobalConfig.bMemstat) {
 				int iSize = sqlite3MallocSize(p);
-				sqlite3_mutex_enter(mem0.mutex);
 				sqlite3StatusDown
 				    (SQLITE_STATUS_SCRATCH_OVERFLOW, iSize);
 				sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED,
@@ -437,7 +410,6 @@ sqlite3ScratchFree(void *p)
 				sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT,
 						  1);
 				sqlite3GlobalConfig.m.xFree(p);
-				sqlite3_mutex_leave(mem0.mutex);
 			} else {
 				sqlite3GlobalConfig.m.xFree(p);
 			}
@@ -486,10 +458,8 @@ sqlite3DbMallocSize(sqlite3 * db, void *p)
 		}
 #endif
 		return sqlite3GlobalConfig.m.xSize(p);
-	} else {
-		assert(sqlite3_mutex_held(db->mutex));
+	} else
 		return db->lookaside.sz;
-	}
 }
 
 sqlite3_uint64
@@ -511,12 +481,10 @@ sqlite3_free(void *p)
 	assert(sqlite3MemdebugHasType(p, MEMTYPE_HEAP));
 	assert(sqlite3MemdebugNoType(p, (u8) ~ MEMTYPE_HEAP));
 	if (sqlite3GlobalConfig.bMemstat) {
-		sqlite3_mutex_enter(mem0.mutex);
 		sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED,
 				  sqlite3MallocSize(p));
 		sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);
 		sqlite3GlobalConfig.m.xFree(p);
-		sqlite3_mutex_leave(mem0.mutex);
 	} else {
 		sqlite3GlobalConfig.m.xFree(p);
 	}
@@ -539,7 +507,6 @@ measureAllocationSize(sqlite3 * db, void *p)
 void
 sqlite3DbFree(sqlite3 * db, void *p)
 {
-	assert(db == 0 || sqlite3_mutex_held(db->mutex));
 	if (p == 0)
 		return;
 	if (db) {
@@ -597,7 +564,6 @@ sqlite3Realloc(void *pOld, u64 nBytes)
 	if (nOld == nNew) {
 		pNew = pOld;
 	} else if (sqlite3GlobalConfig.bMemstat) {
-		sqlite3_mutex_enter(mem0.mutex);
 		sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, (int)nBytes);
 		nDiff = nNew - nOld;
 		if (nDiff > 0
@@ -614,7 +580,6 @@ sqlite3Realloc(void *pOld, u64 nBytes)
 			nNew = sqlite3MallocSize(pNew);
 			sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew - nOld);
 		}
-		sqlite3_mutex_leave(mem0.mutex);
 	} else {
 		pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
 	}
@@ -732,7 +697,6 @@ sqlite3DbMallocRawNN(sqlite3 * db, u64 n)
 #ifndef SQLITE_OMIT_LOOKASIDE
 	LookasideSlot *pBuf;
 	assert(db != 0);
-	assert(sqlite3_mutex_held(db->mutex));
 	assert(db->pnBytesFreed == 0);
 	if (db->lookaside.bDisable == 0) {
 		assert(db->mallocFailed == 0);
@@ -754,7 +718,6 @@ sqlite3DbMallocRawNN(sqlite3 * db, u64 n)
 	}
 #else
 	assert(db != 0);
-	assert(sqlite3_mutex_held(db->mutex));
 	assert(db->pnBytesFreed == 0);
 	if (db->mallocFailed) {
 		return 0;
@@ -776,7 +739,6 @@ sqlite3DbRealloc(sqlite3 * db, void *p, u64 n)
 	assert(db != 0);
 	if (p == 0)
 		return sqlite3DbMallocRawNN(db, n);
-	assert(sqlite3_mutex_held(db->mutex));
 	if (isLookaside(db, p) && n <= db->lookaside.sz)
 		return p;
 	return dbReallocFinish(db, p, n);
@@ -941,12 +903,7 @@ apiOomError(sqlite3 * db)
 int
 sqlite3ApiExit(sqlite3 * db, int rc)
 {
-	/* If the db handle must hold the connection handle mutex here.
-	 * Otherwise the read (and possible write) of db->mallocFailed
-	 * is unsafe, as is the call to sqlite3Error().
-	 */
 	assert(db != 0);
-	assert(sqlite3_mutex_held(db->mutex));
 	if (db->mallocFailed || rc == SQLITE_IOERR_NOMEM) {
 		return apiOomError(db);
 	}
diff --git a/src/box/sql/os.c b/src/box/sql/os.c
index ecb437f..ae98831 100644
--- a/src/box/sql/os.c
+++ b/src/box/sql/os.c
@@ -439,25 +439,17 @@ sqlite3_vfs *
 sqlite3_vfs_find(const char *zVfs)
 {
 	sqlite3_vfs *pVfs = 0;
-#if SQLITE_THREADSAFE
-	sqlite3_mutex *mutex;
-#endif
 #ifndef SQLITE_OMIT_AUTOINIT
 	int rc = sqlite3_initialize();
 	if (rc)
 		return 0;
 #endif
-#if SQLITE_THREADSAFE
-	mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
-#endif
-	sqlite3_mutex_enter(mutex);
 	for (pVfs = vfsList; pVfs; pVfs = pVfs->pNext) {
 		if (zVfs == 0)
 			break;
 		if (strcmp(zVfs, pVfs->zName) == 0)
 			break;
 	}
-	sqlite3_mutex_leave(mutex);
 	return pVfs;
 }
 
@@ -467,8 +459,6 @@ sqlite3_vfs_find(const char *zVfs)
 static void
 vfsUnlink(sqlite3_vfs * pVfs)
 {
-	assert(sqlite3_mutex_held
-	       (sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)));
 	if (pVfs == 0) {
 		/* No-op */
 	} else if (vfsList == pVfs) {
@@ -492,8 +482,6 @@ vfsUnlink(sqlite3_vfs * pVfs)
 int
 sqlite3_vfs_register(sqlite3_vfs * pVfs, int makeDflt)
 {
-	MUTEX_LOGIC(sqlite3_mutex * mutex;
-	    )
 #ifndef SQLITE_OMIT_AUTOINIT
 	int rc = sqlite3_initialize();
 	if (rc)
@@ -504,9 +492,6 @@ sqlite3_vfs_register(sqlite3_vfs * pVfs, int makeDflt)
 		return SQLITE_MISUSE_BKPT;
 #endif
 
-	MUTEX_LOGIC(mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
-	    )
-	    sqlite3_mutex_enter(mutex);
 	vfsUnlink(pVfs);
 	if (makeDflt || vfsList == 0) {
 		pVfs->pNext = vfsList;
@@ -516,7 +501,6 @@ sqlite3_vfs_register(sqlite3_vfs * pVfs, int makeDflt)
 		vfsList->pNext = pVfs;
 	}
 	assert(vfsList);
-	sqlite3_mutex_leave(mutex);
 	return SQLITE_OK;
 }
 
@@ -526,11 +510,6 @@ sqlite3_vfs_register(sqlite3_vfs * pVfs, int makeDflt)
 int
 sqlite3_vfs_unregister(sqlite3_vfs * pVfs)
 {
-#if SQLITE_THREADSAFE
-	sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
-#endif
-	sqlite3_mutex_enter(mutex);
 	vfsUnlink(pVfs);
-	sqlite3_mutex_leave(mutex);
 	return SQLITE_OK;
 }
diff --git a/src/box/sql/os_unix.c b/src/box/sql/os_unix.c
index 56c1c7e..4285d9f 100644
--- a/src/box/sql/os_unix.c
+++ b/src/box/sql/os_unix.c
@@ -134,15 +134,6 @@
 #define SQLITE_FSFLAGS_IS_MSDOS     0x1
 
 /*
- * If we are to be thread-safe, include the pthreads header and define
- * the SQLITE_UNIX_THREADS macro.
- */
-#if SQLITE_THREADSAFE
-#include <pthread.h>
-#define SQLITE_UNIX_THREADS 1
-#endif
-
-/*
  * Default permissions when creating a new file
  */
 #ifndef SQLITE_DEFAULT_FILE_PERMISSIONS
@@ -287,16 +278,6 @@ static pid_t randomnessPid = 0;
 #endif
 
 /*
- * The threadid macro resolves to the thread-id or to 0.  Used for
- * testing and debugging only.
- */
-#if SQLITE_THREADSAFE
-#define threadid pthread_self()
-#else
-#define threadid 0
-#endif
-
-/*
  * HAVE_MREMAP defaults to true on Linux and false everywhere else.
  */
 #if !defined(HAVE_MREMAP)
@@ -648,39 +629,6 @@ robust_open(const char *z, int f, mode_t m)
 	return fd;
 }
 
-/*
- * Helper functions to obtain and relinquish the global mutex. The
- * global mutex is used to protect the unixInodeInfo object
- * used by this file, all of which may be shared by multiple threads.
- *
- * Function unixMutexHeld() is used to assert() that the global mutex
- * is held when required. This function is only used as part of assert()
- * statements. e.g.
- *
- *   unixEnterMutex()
- *     assert( unixMutexHeld() );
- *   unixEnterLeave()
- */
-static void
-unixEnterMutex(void)
-{
-	sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1));
-}
-
-static void
-unixLeaveMutex(void)
-{
-	sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1));
-}
-
-#ifdef SQLITE_DEBUG
-static int
-unixMutexHeld(void)
-{
-	return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1));
-}
-#endif
-
 #ifdef SQLITE_LOCK_TRACE
 /*
  * Print out information about all locking operations.
@@ -717,8 +665,8 @@ lockTrace(int fd, int op, struct flock *p)
 	assert(p->l_whence == SEEK_SET);
 	s = osFcntl(fd, op, p);
 	savedErrno = errno;
-	sqlite3DebugPrintf("fcntl %d %d %s %s %d %d %d %d\n",
-			   threadid, fd, zOpName, zType, (int)p->l_start,
+	sqlite3DebugPrintf("fcntl %d %s %s %d %d %d %d\n",
+			   fd, zOpName, zType, (int)p->l_start,
 			   (int)p->l_len, (int)p->l_pid, s);
 	if (s == (-1) && op == F_SETLK
 	    && (p->l_type == F_RDLCK || p->l_type == F_WRLCK)) {
@@ -951,39 +899,7 @@ unixLogErrorAtLine(int errcode,	/* SQLite error code */
 	char *zErr;		/* Message from strerror() or equivalent */
 	int iErrno = errno;	/* Saved syscall error number */
 
-	/* If this is not a threadsafe build (SQLITE_THREADSAFE==0), then use
-	 * the strerror() function to obtain the human-readable error message
-	 * equivalent to errno. Otherwise, use strerror_r().
-	 */
-#if SQLITE_THREADSAFE && defined(HAVE_STRERROR_R)
-	char aErr[80];
-	memset(aErr, 0, sizeof(aErr));
-	zErr = aErr;
-
-	/* If STRERROR_R_CHAR_P (set by autoconf scripts) or __USE_GNU is defined,
-	 * assume that the system provides the GNU version of strerror_r() that
-	 * returns a pointer to a buffer containing the error message. That pointer
-	 * may point to aErr[], or it may point to some static storage somewhere.
-	 * Otherwise, assume that the system provides the POSIX version of
-	 * strerror_r(), which always writes an error message into aErr[].
-	 *
-	 * If the code incorrectly assumes that it is the POSIX version that is
-	 * available, the error message will often be an empty string. Not a
-	 * huge problem. Incorrectly concluding that the GNU version is available
-	 * could lead to a segfault though.
-	 */
-#if defined(STRERROR_R_CHAR_P) || defined(__USE_GNU)
-	zErr =
-#endif
-	    strerror_r(iErrno, aErr, sizeof(aErr) - 1);
-
-#elif SQLITE_THREADSAFE
-	/* This is a threadsafe build, but strerror_r() is not available. */
-	zErr = "";
-#else
-	/* Non-threadsafe build, use strerror(). */
 	zErr = strerror(iErrno);
-#endif
 
 	if (zPath == 0)
 		zPath = "";
@@ -1045,15 +961,11 @@ closePendingFds(unixFile * pFile)
 
 /*
  * Release a unixInodeInfo structure previously allocated by findInodeInfo().
- *
- * The mutex entered using the unixEnterMutex() function must be held
- * when this function is called.
  */
 static void
 releaseInodeInfo(unixFile * pFile)
 {
 	unixInodeInfo *pInode = pFile->pInode;
-	assert(unixMutexHeld());
 	if (ALWAYS(pInode)) {
 		pInode->nRef--;
 		if (pInode->nRef == 0) {
@@ -1080,9 +992,6 @@ releaseInodeInfo(unixFile * pFile)
  * describes that file descriptor.  Create a new one if necessary.  The
  * return value might be uninitialized if an error occurs.
  *
- * The mutex entered using the unixEnterMutex() function must be held
- * when this function is called.
- *
  * Return an appropriate error code.
  */
 static int
@@ -1096,8 +1005,6 @@ findInodeInfo(unixFile * pFile,	/* Unix file with file desc used in the key */
 	struct stat statbuf;	/* Low-level file information */
 	unixInodeInfo *pInode = 0;	/* Candidate unixInodeInfo object */
 
-	assert(unixMutexHeld());
-
 	/* Get low-level information about the file that we can used to
 	 * create a unique name for the file.
 	 */
@@ -1238,15 +1145,12 @@ unixCheckReservedLock(sqlite3_file * id, int *pResOut)
 
 	assert(pFile);
 	assert(pFile->eFileLock <= SHARED_LOCK);
-	unixEnterMutex();	/* Because pFile->pInode is shared across threads */
 
 	/* Check if a thread in this process holds such a lock */
 	if (pFile->pInode->eFileLock > SHARED_LOCK) {
 		reserved = 1;
 	}
 
-	unixLeaveMutex();
-
 	*pResOut = reserved;
 	return rc;
 }
@@ -1275,7 +1179,6 @@ unixFileLock(unixFile * pFile, struct flock *pLock)
 {
 	int rc;
 	unixInodeInfo *pInode = pFile->pInode;
-	assert(unixMutexHeld());
 	assert(pInode != 0);
 	if ((pFile->ctrlFlags & (UNIXFILE_EXCL | UNIXFILE_RDONLY)) ==
 	    UNIXFILE_EXCL) {
@@ -1367,12 +1270,10 @@ unixLock(sqlite3_file * id, int eFileLock)
 	assert(pFile);
 
 	/* If there is already a lock of this type or more restrictive on the
-	 * unixFile, do nothing. Don't use the end_lock: exit path, as
-	 * unixEnterMutex() hasn't been called yet.
+	 * unixFile, do nothing.
 	 */
-	if (pFile->eFileLock >= eFileLock) {
+	if (pFile->eFileLock >= eFileLock)
 		return SQLITE_OK;
-	}
 
 	/* Make sure the locking sequence is correct.
 	 *  (1) We never move from unlocked to anything higher than shared lock.
@@ -1383,9 +1284,6 @@ unixLock(sqlite3_file * id, int eFileLock)
 	assert(eFileLock != PENDING_LOCK);
 	assert(eFileLock != RESERVED_LOCK || pFile->eFileLock == SHARED_LOCK);
 
-	/* This mutex is needed because pFile->pInode is shared across threads
-	 */
-	unixEnterMutex();
 	pInode = pFile->pInode;
 
 	/* If some thread using this PID has a lock via a different unixFile*
@@ -1529,7 +1427,6 @@ unixLock(sqlite3_file * id, int eFileLock)
 	}
 
  end_lock:
-	unixLeaveMutex();
 	return rc;
 }
 
@@ -1575,7 +1472,6 @@ posixUnlock(sqlite3_file * id, int eFileLock, int handleNFSUnlock)
 	if (pFile->eFileLock <= eFileLock) {
 		return SQLITE_OK;
 	}
-	unixEnterMutex();
 	pInode = pFile->pInode;
 	assert(pInode->nShared != 0);
 	if (pFile->eFileLock > SHARED_LOCK) {
@@ -1711,7 +1607,6 @@ posixUnlock(sqlite3_file * id, int eFileLock, int handleNFSUnlock)
 	}
 
  end_unlock:
-	unixLeaveMutex();
 	if (rc == SQLITE_OK)
 		pFile->eFileLock = eFileLock;
 	return rc;
@@ -1778,7 +1673,6 @@ unixClose(sqlite3_file * id)
 	unixFile *pFile = (unixFile *) id;
 	verifyDbFile(pFile);
 	unixUnlock(id, NO_LOCK);
-	unixEnterMutex();
 
 	/* unixFile.pInode is always valid here. Otherwise, a different close
 	 * routine (e.g. nolockClose()) would be called instead.
@@ -1794,7 +1688,6 @@ unixClose(sqlite3_file * id)
 	}
 	releaseInodeInfo(pFile);
 	rc = closeUnixFile(id);
-	unixLeaveMutex();
 	return rc;
 }
 
@@ -2355,7 +2248,6 @@ afpCheckReservedLock(sqlite3_file * id, int *pResOut)
 		*pResOut = 1;
 		return SQLITE_OK;
 	}
-	unixEnterMutex();	/* Because pFile->pInode is shared across threads */
 
 	/* Check if a thread in this process holds such a lock */
 	if (pFile->pInode->eFileLock > SHARED_LOCK) {
@@ -2384,8 +2276,6 @@ afpCheckReservedLock(sqlite3_file * id, int *pResOut)
 		}
 	}
 
-	unixLeaveMutex();
-
 	*pResOut = reserved;
 	return rc;
 }
@@ -2426,8 +2316,7 @@ afpLock(sqlite3_file * id, int eFileLock)
 	assert(pFile);
 
 	/* If there is already a lock of this type or more restrictive on the
-	 * unixFile, do nothing. Don't use the afp_end_lock: exit path, as
-	 * unixEnterMutex() hasn't been called yet.
+	 * unixFile, do nothing.
 	 */
 	if (pFile->eFileLock >= eFileLock) {
 		return SQLITE_OK;
@@ -2442,9 +2331,6 @@ afpLock(sqlite3_file * id, int eFileLock)
 	assert(eFileLock != PENDING_LOCK);
 	assert(eFileLock != RESERVED_LOCK || pFile->eFileLock == SHARED_LOCK);
 
-	/* This mutex is needed because pFile->pInode is shared across threads
-	 */
-	unixEnterMutex();
 	pInode = pFile->pInode;
 
 	/* If some thread using this PID has a lock via a different unixFile*
@@ -2594,7 +2480,6 @@ afpLock(sqlite3_file * id, int eFileLock)
 	}
 
  afp_end_lock:
-	unixLeaveMutex();
 	return rc;
 }
 
@@ -2624,7 +2509,6 @@ afpUnlock(sqlite3_file * id, int eFileLock)
 	if (pFile->eFileLock <= eFileLock) {
 		return SQLITE_OK;
 	}
-	unixEnterMutex();
 	pInode = pFile->pInode;
 	assert(pInode->nShared != 0);
 	if (pFile->eFileLock > SHARED_LOCK) {
@@ -2710,7 +2594,6 @@ afpUnlock(sqlite3_file * id, int eFileLock)
 		}
 	}
 
-	unixLeaveMutex();
 	if (rc == SQLITE_OK)
 		pFile->eFileLock = eFileLock;
 	return rc;
@@ -2726,7 +2609,6 @@ afpClose(sqlite3_file * id)
 	unixFile *pFile = (unixFile *) id;
 	assert(id != 0);
 	afpUnlock(id, NO_LOCK);
-	unixEnterMutex();
 	if (pFile->pInode && pFile->pInode->nLock) {
 		/* If there are outstanding locks, do not actually close the file just
 		 * yet because that would clear those locks.  Instead, add the file
@@ -2738,7 +2620,6 @@ afpClose(sqlite3_file * id)
 	releaseInodeInfo(pFile);
 	sqlite3_free(pFile->lockingContext);
 	rc = closeUnixFile(id);
-	unixLeaveMutex();
 	return rc;
 }
 
@@ -4110,11 +3991,10 @@ fillInUnixFile(sqlite3_vfs * pVfs,	/* Pointer to vfs object */
 	    || pLockingStyle == &nfsIoMethods
 #endif
 	    ) {
-		unixEnterMutex();
 		rc = findInodeInfo(pNew, &pNew->pInode);
 		if (rc != SQLITE_OK) {
 			/* If an error occurred in findInodeInfo(), close the file descriptor
-			 * immediately, before releasing the mutex. findInodeInfo() may fail
+			 * immediately. findInodeInfo() may fail
 			 * in two scenarios:
 			 *
 			 *   (a) A call to fstat() failed.
@@ -4134,7 +4014,6 @@ fillInUnixFile(sqlite3_vfs * pVfs,	/* Pointer to vfs object */
 			robust_close(pNew, h, __LINE__);
 			h = -1;
 		}
-		unixLeaveMutex();
 	}
 #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
 	else if (pLockingStyle == &afpIoMethods) {
@@ -4153,14 +4032,12 @@ fillInUnixFile(sqlite3_vfs * pVfs,	/* Pointer to vfs object */
 			pCtx->dbPath = zFilename;
 			pCtx->reserved = 0;
 			srandomdev();
-			unixEnterMutex();
 			rc = findInodeInfo(pNew, &pNew->pInode);
 			if (rc != SQLITE_OK) {
 				sqlite3_free(pNew->lockingContext);
 				robust_close(pNew, h, __LINE__);
 				h = -1;
 			}
-			unixLeaveMutex();
 		}
 	}
 #endif
@@ -4308,7 +4185,6 @@ findReusableFd(const char *zPath, int flags)
 	if (0 == osStat(zPath, &sStat)) {
 		unixInodeInfo *pInode;
 
-		unixEnterMutex();
 		pInode = inodeList;
 		while (pInode && (pInode->fileId.dev != sStat.st_dev
 				  || pInode->fileId.ino !=
@@ -4325,7 +4201,6 @@ findReusableFd(const char *zPath, int flags)
 				*pp = pUnused->pNext;
 			}
 		}
-		unixLeaveMutex();
 	}
 	return pUnused;
 }
@@ -4897,12 +4772,10 @@ unixDlError(sqlite3_vfs * NotUsed, int nBuf, char *zBufOut)
 {
 	const char *zErr;
 	UNUSED_PARAMETER(NotUsed);
-	unixEnterMutex();
 	zErr = dlerror();
 	if (zErr) {
 		sqlite3_snprintf(nBuf, zBufOut, "%s", zErr);
 	}
-	unixLeaveMutex();
 }
 
 static
@@ -6379,8 +6252,8 @@ proxyClose(sqlite3_file * id)
  * files.
  *
  * This routine is called once during SQLite initialization and by a
- * single thread.  The memory allocation and mutex subsystems have not
- * necessarily been initialized when this routine is called, and so they
+ * single thread.  The memory allocation subsystem have not
+ * necessarily been initialized when this routine \is called, and so they
  * should not be used.
  */
 int
diff --git a/src/box/sql/prepare.c b/src/box/sql/prepare.c
index 9b80282..0ea181d 100644
--- a/src/box/sql/prepare.c
+++ b/src/box/sql/prepare.c
@@ -86,7 +86,6 @@ sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed)
 	sqlite3 *db = pData->db;
 	assert(argc == 3);
 	UNUSED_PARAMETER2(NotUsed, argc);
-	assert(sqlite3_mutex_held(db->mutex));
 	if (db->mallocFailed) {
 		corruptSchema(pData, argv[0], 0);
 		return 1;
@@ -165,7 +164,6 @@ sqlite3InitDatabase(sqlite3 * db)
 	InitData initData;
 
 	assert(db->pSchema != NULL);
-	assert(sqlite3_mutex_held(db->mutex));
 
 	memset(&initData, 0, sizeof(InitData));
 	initData.db = db;
@@ -227,7 +225,6 @@ sqlite3SchemaToIndex(sqlite3 * db, Schema * pSchema)
 	 * more likely to cause a segfault than -1 (of course there are assert()
 	 * statements too, but it never hurts to play the odds).
 	 */
-	assert(sqlite3_mutex_held(db->mutex));
 	if (pSchema) {
 		if (db->pSchema == pSchema) {
 			i = 0;
@@ -279,7 +276,6 @@ sqlite3Prepare(sqlite3 * db,	/* Database handle. */
 	sParse.pReprepare = pReprepare;
 	assert(ppStmt && *ppStmt == 0);
 	/* assert( !db->mallocFailed ); // not true with SQLITE_USE_ALLOCA */
-	assert(sqlite3_mutex_held(db->mutex));
 
 	/* Check to verify that it is possible to get a read lock on all
 	 * database schemas.  The inability to get a read lock indicates that
@@ -410,7 +406,6 @@ sqlite3LockAndPrepare(sqlite3 * db,		/* Database handle. */
 	if (!sqlite3SafetyCheckOk(db) || zSql == 0) {
 		return SQLITE_MISUSE_BKPT;
 	}
-	sqlite3_mutex_enter(db->mutex);
 	rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt,
 			    pzTail);
 	if (rc == SQLITE_SCHEMA) {
@@ -418,7 +413,6 @@ sqlite3LockAndPrepare(sqlite3 * db,		/* Database handle. */
 		rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt,
 				    pzTail);
 	}
-	sqlite3_mutex_leave(db->mutex);
 	assert(rc == SQLITE_OK || *ppStmt == 0);
 	return rc;
 }
@@ -439,11 +433,9 @@ sqlite3Reprepare(Vdbe * p)
 	const char *zSql;
 	sqlite3 *db;
 
-	assert(sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex));
 	zSql = sqlite3_sql((sqlite3_stmt *) p);
 	assert(zSql != 0);	/* Reprepare only called for prepare_v2() statements */
 	db = sqlite3VdbeDb(p);
-	assert(sqlite3_mutex_held(db->mutex));
 	rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0);
 	if (rc) {
 		if (rc == SQLITE_NOMEM) {
diff --git a/src/box/sql/printf.c b/src/box/sql/printf.c
index 7884487..4be7bb8 100644
--- a/src/box/sql/printf.c
+++ b/src/box/sql/printf.c
@@ -1167,14 +1167,8 @@ sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...)
  * We house it in a separate routine from sqlite3_log() to avoid using
  * stack space on small-stack systems when logging is disabled.
  *
- * sqlite3_log() must render into a static buffer.  It cannot dynamically
- * allocate memory because it might be called while the memory allocator
- * mutex is held.
- *
  * sqlite3VXPrintf() might ask for *temporary* memory allocations for
  * certain format characters (%q) or for very large precisions or widths.
- * Care must be taken that any sqlite3_log() calls that occur while the
- * memory mutex is held do not use these mechanisms.
  */
 static void
 renderLogMsg(int iErrCode, const char *zFormat, va_list ap)
diff --git a/src/box/sql/random.c b/src/box/sql/random.c
index 4006ef0..4d6e642 100644
--- a/src/box/sql/random.c
+++ b/src/box/sql/random.c
@@ -70,23 +70,13 @@ sqlite3_randomness(int N, void *pBuf)
 #define wsdPrng sqlite3Prng
 #endif
 
-#if SQLITE_THREADSAFE
-	sqlite3_mutex *mutex;
-#endif
-
 #ifndef SQLITE_OMIT_AUTOINIT
 	if (sqlite3_initialize())
 		return;
 #endif
 
-#if SQLITE_THREADSAFE
-	mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PRNG);
-#endif
-
-	sqlite3_mutex_enter(mutex);
 	if (N <= 0 || pBuf == 0) {
 		wsdPrng.isInit = 0;
-		sqlite3_mutex_leave(mutex);
 		return;
 	}
 
@@ -127,7 +117,6 @@ sqlite3_randomness(int N, void *pBuf)
 		t += wsdPrng.s[wsdPrng.i];
 		*(zBuf++) = wsdPrng.s[t];
 	} while (--N);
-	sqlite3_mutex_leave(mutex);
 }
 
 #ifndef SQLITE_UNTESTABLE
diff --git a/src/box/sql/sqliteInt.h b/src/box/sql/sqliteInt.h
index 50dadf4..f2a74ce 100644
--- a/src/box/sql/sqliteInt.h
+++ b/src/box/sql/sqliteInt.h
@@ -180,26 +180,6 @@
 #define SQLITE_NOINLINE
 #endif
 
-
-/*
- * The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2.
- * 0 means mutexes are permanently disable and the library is never
- * threadsafe.  1 means the library is serialized which is the highest
- * level of threadsafety.  2 means the library is multithreaded - multiple
- * threads can use SQLite as long as no two threads try to use the same
- * database connection at the same time.
- *
- * Older versions of SQLite used an optional THREADSAFE macro.
- * We support that for legacy.
- */
-#if !defined(SQLITE_THREADSAFE)
-#if defined(THREADSAFE)
-#define SQLITE_THREADSAFE THREADSAFE
-#else
-#define SQLITE_THREADSAFE 1	/* IMP: R-07272-22309 */
-#endif
-#endif
-
 /*
  * Powersafe overwrite is on by default.  But can be turned off using
  * the -DSQLITE_POWERSAFE_OVERWRITE=0 command-line option.
@@ -251,16 +231,6 @@
 #endif
 
 /*
- * We need to define _XOPEN_SOURCE as follows in order to enable
- * recursive mutexes on most Unix systems and fchmod() on OpenBSD.
- * But _XOPEN_SOURCE define causes problems for Mac OS X, so omit
- * it.
- */
-#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__)
-#define _XOPEN_SOURCE 600
-#endif
-
-/*
  * Enable SQLITE_ENABLE_EXPLAIN_COMMENTS if SQLITE_DEBUG is turned on.
  */
 #if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG)
@@ -450,20 +420,6 @@ struct sqlite3_vfs {
 	*/
 };
 
-typedef struct sqlite3_mutex sqlite3_mutex;
-typedef struct sqlite3_mutex_methods sqlite3_mutex_methods;
-struct sqlite3_mutex_methods {
-	int (*xMutexInit) (void);
-	int (*xMutexEnd) (void);
-	sqlite3_mutex *(*xMutexAlloc) (int);
-	void (*xMutexFree) (sqlite3_mutex *);
-	void (*xMutexEnter) (sqlite3_mutex *);
-	int (*xMutexTry) (sqlite3_mutex *);
-	void (*xMutexLeave) (sqlite3_mutex *);
-	int (*xMutexHeld) (sqlite3_mutex *);
-	int (*xMutexNotheld) (sqlite3_mutex *);
-};
-
 #define SQLITE_LIMIT_LENGTH                    0
 #define SQLITE_LIMIT_SQL_LENGTH                1
 #define SQLITE_LIMIT_COLUMN                    2
@@ -1215,7 +1171,7 @@ sqlite3_bind_parameter_lindex(sqlite3_stmt * pStmt, const char *zName,
  * SQLITE_TEMP_STORE is set to 3 (never use temporary files), set it
  * to zero.
  */
-#if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0
+#if SQLITE_TEMP_STORE==3
 #undef SQLITE_MAX_WORKER_THREADS
 #define SQLITE_MAX_WORKER_THREADS 0
 #endif
@@ -1657,7 +1613,6 @@ typedef int VList;
 #include "cursor.h"
 #include "vdbe.h"
 #include "os.h"
-#include "mutex.h"
 
 /*
  * An instance of the following structure stores a database schema.
@@ -1729,7 +1684,6 @@ struct sqlite3 {
 	sqlite3_vfs *pVfs;	/* OS Interface */
 	struct Vdbe *pVdbe;	/* List of active virtual machines */
 	struct coll *pDfltColl;	/* The default collating sequence (BINARY) */
-	sqlite3_mutex *mutex;	/* Connection mutex */
 	struct Schema *pSchema; /* Schema of the database */
 	i64 szMmap;		/* Default mmap_size setting */
 	int errCode;		/* Most recent error code (SQLITE_*) */
@@ -3365,8 +3319,6 @@ typedef struct {
  */
 struct Sqlite3Config {
 	int bMemstat;		/* True to enable memory status */
-	int bCoreMutex;		/* True to enable core mutexing */
-	int bFullMutex;		/* True to enable full mutexing */
 	int bOpenUri;		/* True to interpret filenames as URIs */
 	int bUseCis;		/* Use covering indices for full-scans */
 	int mxStrlen;		/* Maximum string length */
@@ -3375,7 +3327,6 @@ struct Sqlite3Config {
 	int nLookaside;		/* Default lookaside buffer count */
 	int nStmtSpill;		/* Stmt-journal spill-to-disk threshold */
 	sqlite3_mem_methods m;	/* Low-level memory allocation interface */
-	sqlite3_mutex_methods mutex;	/* Low-level mutex interface */
 	sqlite3_pcache_methods2 pcache2;	/* Low-level page-cache interface */
 	void *pHeap;		/* Heap storage space */
 	int nHeap;		/* Size of pHeap[] */
@@ -3396,10 +3347,7 @@ struct Sqlite3Config {
 	 */
 	int isInit;		/* True after initialization has finished */
 	int inProgress;		/* True while initialization in progress */
-	int isMutexInit;	/* True after mutexes are initialized */
 	int isMallocInit;	/* True after malloc is initialized */
-	int nRefInitMutex;	/* Number of users of pInitMutex */
-	sqlite3_mutex *pInitMutex;	/* Mutex used by sqlite3_initialize() */
 	void (*xLog) (void *, int, const char *);	/* Function for logging */
 	void *pLogArg;		/* First argument to xLog() */
 #ifdef SQLITE_ENABLE_SQLLOG
@@ -3640,28 +3588,11 @@ const sqlite3_mem_methods *sqlite3MemGetMemsys5(void);
 const sqlite3_mem_methods *sqlite3MemGetMemsys3(void);
 #endif
 
-#ifndef SQLITE_MUTEX_OMIT
-sqlite3_mutex_methods const *sqlite3DefaultMutex(void);
-sqlite3_mutex_methods const *sqlite3NoopMutex(void);
-sqlite3_mutex *sqlite3MutexAlloc(int);
-int sqlite3MutexInit(void);
-int sqlite3MutexEnd(void);
-#endif
-#if !defined(SQLITE_MUTEX_OMIT) && !defined(SQLITE_MUTEX_NOOP)
-void sqlite3MemoryBarrier(void);
-#else
-#define sqlite3MemoryBarrier()
-#endif
-
 sqlite3_int64 sqlite3StatusValue(int);
 void sqlite3StatusUp(int, int);
 void sqlite3StatusDown(int, int);
 void sqlite3StatusHighwater(int, int);
 
-/* Access to mutexes used by sqlite3_status() */
-sqlite3_mutex *sqlite3Pcache1Mutex(void);
-sqlite3_mutex *sqlite3MallocMutex(void);
-
 #ifndef SQLITE_OMIT_FLOATING_POINT
 int sqlite3IsNaN(double);
 #else
diff --git a/src/box/sql/status.c b/src/box/sql/status.c
index 8b476f8..963d3d8 100644
--- a/src/box/sql/status.c
+++ b/src/box/sql/status.c
@@ -68,8 +68,7 @@ static SQLITE_WSD struct sqlite3StatType {
 #endif
 
 /*
- * Return the current value of a status parameter.  The caller must
- * be holding the appropriate mutex.
+ * Return the current value of a status parameter.
  */
 sqlite3_int64
 sqlite3StatusValue(int op)
@@ -81,8 +80,7 @@ sqlite3StatusValue(int op)
 }
 
 /*
- * Add N to the value of a status record.  The caller must hold the
- * appropriate mutex.  (Locking is checked by assert()).
+ * Add N to the value of a status record.
  *
  * The StatusUp() routine can accept positive or negative values for N.
  * The value of N is added to the current status value and the high-water
@@ -115,7 +113,6 @@ sqlite3StatusDown(int op, int N)
 
 /*
  * Adjust the highwater mark if necessary.
- * The caller must hold the appropriate mutex.
  */
 void
 sqlite3StatusHighwater(int op, int X)
@@ -193,7 +190,6 @@ sqlite3_db_status(sqlite3 * db,	/* The database connection whose status is desir
 		return SQLITE_MISUSE_BKPT;
 	}
 #endif
-	sqlite3_mutex_enter(db->mutex);
 	switch (op) {
 	case SQLITE_DBSTATUS_LOOKASIDE_USED:{
 			*pCurrent = db->lookaside.nOut;
@@ -347,6 +343,5 @@ sqlite3_db_status(sqlite3 * db,	/* The database connection whose status is desir
 			rc = SQLITE_ERROR;
 		}
 	}
-	sqlite3_mutex_leave(db->mutex);
 	return rc;
 }
diff --git a/src/box/sql/tokenize.c b/src/box/sql/tokenize.c
index 056924e..f810db4 100644
--- a/src/box/sql/tokenize.c
+++ b/src/box/sql/tokenize.c
@@ -609,11 +609,9 @@ sqlite3RunParser(Parse * pParse, const char *zSql, char **pzErrMsg)
 	assert(nErr == 0);
 	pParse->zTail = &zSql[i];
 #ifdef YYTRACKMAXSTACKDEPTH
-	sqlite3_mutex_enter(sqlite3MallocMutex());
 	sqlite3StatusHighwater(SQLITE_STATUS_PARSER_STACK,
 			       sqlite3ParserStackPeak(pEngine)
 	    );
-	sqlite3_mutex_leave(sqlite3MallocMutex());
 #endif				/* YYDEBUG */
 	sqlite3ParserFree(pEngine, sqlite3_free);
 	if (db->mallocFailed) {
diff --git a/src/box/sql/vdbe.c b/src/box/sql/vdbe.c
index 96609b5..6877cab 100644
--- a/src/box/sql/vdbe.c
+++ b/src/box/sql/vdbe.c
@@ -5527,10 +5527,7 @@ abort_due_to_error:
 		sqlite3SchemaClear(db);
 	}
 
-	/* This is the only way out of this procedure.  We have to
-	 * release the mutexes on btrees that were acquired at the
-	 * top.
-	 */
+	/* This is the only way out of this procedure. */
 vdbe_return:
 	testcase( nVmStep>0);
 	p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep;
diff --git a/src/box/sql/vdbeapi.c b/src/box/sql/vdbeapi.c
index 9c86c4c..dff1e16 100644
--- a/src/box/sql/vdbeapi.c
+++ b/src/box/sql/vdbeapi.c
@@ -125,7 +125,6 @@ sqlite3_finalize(sqlite3_stmt * pStmt)
 		sqlite3 *db = v->db;
 		if (vdbeSafety(v))
 			return SQLITE_MISUSE_BKPT;
-		sqlite3_mutex_enter(db->mutex);
 		checkProfileCallback(db, v);
 		rc = sqlite3VdbeFinalize(v);
 		rc = sqlite3ApiExit(db, rc);
@@ -150,13 +149,11 @@ sqlite3_reset(sqlite3_stmt * pStmt)
 	} else {
 		Vdbe *v = (Vdbe *) pStmt;
 		sqlite3 *db = v->db;
-		sqlite3_mutex_enter(db->mutex);
 		checkProfileCallback(db, v);
 		rc = sqlite3VdbeReset(v);
 		sqlite3VdbeRewind(v);
 		assert((rc & (db->errMask)) == rc);
 		rc = sqlite3ApiExit(db, rc);
-		sqlite3_mutex_leave(db->mutex);
 	}
 	return rc;
 }
@@ -170,10 +167,6 @@ sqlite3_clear_bindings(sqlite3_stmt * pStmt)
 	int i;
 	int rc = SQLITE_OK;
 	Vdbe *p = (Vdbe *) pStmt;
-#if SQLITE_THREADSAFE
-	sqlite3_mutex *mutex = ((Vdbe *) pStmt)->db->mutex;
-#endif
-	sqlite3_mutex_enter(mutex);
 	for (i = 0; i < p->nVar; i++) {
 		sqlite3VdbeMemRelease(&p->aVar[i]);
 		p->aVar[i].flags = MEM_Null;
@@ -181,7 +174,6 @@ sqlite3_clear_bindings(sqlite3_stmt * pStmt)
 	if (p->isPrepareV2 && p->expmask) {
 		p->expired = 1;
 	}
-	sqlite3_mutex_leave(mutex);
 	return rc;
 }
 
@@ -369,7 +361,6 @@ sqlite3_result_blob(sqlite3_context * pCtx,
     )
 {
 	assert(n >= 0);
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	if (sqlite3VdbeMemSetStr(pCtx->pOut, z, n,0, xDel) == SQLITE_TOOBIG) {
 		sqlite3_result_error_toobig(pCtx);
 	}
@@ -380,7 +371,6 @@ sqlite3_result_blob64(sqlite3_context * pCtx,
 		      const void *z, sqlite3_uint64 n, void (*xDel) (void *)
     )
 {
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	assert(xDel != SQLITE_DYNAMIC);
 	if (n > 0x7fffffff) {
 		(void)invokeValueDestructor(z, xDel, pCtx);
@@ -392,14 +382,12 @@ sqlite3_result_blob64(sqlite3_context * pCtx,
 void
 sqlite3_result_double(sqlite3_context * pCtx, double rVal)
 {
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);
 }
 
 void
 sqlite3_result_error(sqlite3_context * pCtx, const char *z, int n)
 {
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	pCtx->isError = SQLITE_ERROR;
 	pCtx->fErrorOrAux = 1;
 	sqlite3VdbeMemSetStr(pCtx->pOut, z, n, 1, SQLITE_TRANSIENT);
@@ -408,21 +396,18 @@ sqlite3_result_error(sqlite3_context * pCtx, const char *z, int n)
 void
 sqlite3_result_int(sqlite3_context * pCtx, int iVal)
 {
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	sqlite3VdbeMemSetInt64(pCtx->pOut, (i64) iVal);
 }
 
 void
 sqlite3_result_int64(sqlite3_context * pCtx, i64 iVal)
 {
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	sqlite3VdbeMemSetInt64(pCtx->pOut, iVal);
 }
 
 void
 sqlite3_result_null(sqlite3_context * pCtx)
 {
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	sqlite3VdbeMemSetNull(pCtx->pOut);
 }
 
@@ -430,7 +415,6 @@ void
 sqlite3_result_subtype(sqlite3_context * pCtx, unsigned int eSubtype)
 {
 	Mem *pOut = pCtx->pOut;
-	assert(sqlite3_mutex_held(pOut->db->mutex));
 	pOut->eSubtype = eSubtype & 0xff;
 	pOut->flags |= MEM_Subtype;
 }
@@ -440,7 +424,6 @@ sqlite3_result_text(sqlite3_context * pCtx,
 		    const char *z, int n, void (*xDel) (void *)
     )
 {
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	setResultStrOrError(pCtx, z, n, xDel);
 }
 
@@ -450,7 +433,6 @@ sqlite3_result_text64(sqlite3_context * pCtx,
 		      sqlite3_uint64 n,
 		      void (*xDel) (void *))
 {
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	assert(xDel != SQLITE_DYNAMIC);
 	if (n > 0x7fffffff) {
 		(void)invokeValueDestructor(z, xDel, pCtx);
@@ -462,14 +444,12 @@ sqlite3_result_text64(sqlite3_context * pCtx,
 void
 sqlite3_result_value(sqlite3_context * pCtx, sqlite3_value * pValue)
 {
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	sqlite3VdbeMemCopy(pCtx->pOut, pValue);
 }
 
 void
 sqlite3_result_zeroblob(sqlite3_context * pCtx, int n)
 {
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n);
 }
 
@@ -477,7 +457,6 @@ int
 sqlite3_result_zeroblob64(sqlite3_context * pCtx, u64 n)
 {
 	Mem *pOut = pCtx->pOut;
-	assert(sqlite3_mutex_held(pOut->db->mutex));
 	if (n > (u64) pOut->db->aLimit[SQLITE_LIMIT_LENGTH]) {
 		return SQLITE_TOOBIG;
 	}
@@ -504,7 +483,6 @@ sqlite3_result_error_code(sqlite3_context * pCtx, int errCode)
 void
 sqlite3_result_error_toobig(sqlite3_context * pCtx)
 {
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	pCtx->isError = SQLITE_TOOBIG;
 	pCtx->fErrorOrAux = 1;
 	sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1, 1,
@@ -515,7 +493,6 @@ sqlite3_result_error_toobig(sqlite3_context * pCtx)
 void
 sqlite3_result_error_nomem(sqlite3_context * pCtx)
 {
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	sqlite3VdbeMemSetNull(pCtx->pOut);
 	pCtx->isError = SQLITE_NOMEM_BKPT;
 	pCtx->fErrorOrAux = 1;
@@ -667,7 +644,6 @@ sqlite3_step(sqlite3_stmt * pStmt)
 		return SQLITE_MISUSE_BKPT;
 	}
 	db = v->db;
-	sqlite3_mutex_enter(db->mutex);
 	v->doingRerun = 0;
 	while ((rc = sqlite3Step(v)) == SQLITE_SCHEMA
 	       && cnt++ < SQLITE_MAX_SCHEMA_RETRY) {
@@ -700,7 +676,6 @@ sqlite3_step(sqlite3_stmt * pStmt)
 		}
 	}
 	rc = sqlite3ApiExit(db, rc);
-	sqlite3_mutex_leave(db->mutex);
 	return rc;
 }
 
@@ -814,7 +789,6 @@ void *
 sqlite3_aggregate_context(sqlite3_context * p, int nByte)
 {
 	assert(p && p->pFunc && p->pFunc->xFinalize);
-	assert(sqlite3_mutex_held(p->pOut->db->mutex));
 	testcase(nByte < 0);
 	if ((p->pMem->flags & MEM_Agg) == 0) {
 		return createAggContext(p, nByte);
@@ -832,7 +806,6 @@ sqlite3_get_auxdata(sqlite3_context * pCtx, int iArg)
 {
 	AuxData *pAuxData;
 
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	if (pCtx->pVdbe == 0)
 		return 0;
 
@@ -858,7 +831,6 @@ sqlite3_set_auxdata(sqlite3_context * pCtx,
 	AuxData *pAuxData;
 	Vdbe *pVdbe = pCtx->pVdbe;
 
-	assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
 	if (iArg < 0)
 		goto failed;
 	if (pVdbe == 0)
@@ -973,7 +945,6 @@ columnMem(sqlite3_stmt * pStmt, int i)
 	if (pVm == 0)
 		return (Mem *) columnNullValue();
 	assert(pVm->db);
-	sqlite3_mutex_enter(pVm->db->mutex);
 	if (pVm->pResultSet != 0 && i < pVm->nResColumn && i >= 0) {
 		pOut = &pVm->pResultSet[i];
 	} else {
@@ -1011,9 +982,7 @@ columnMallocFailure(sqlite3_stmt * pStmt)
 	Vdbe *p = (Vdbe *) pStmt;
 	if (p) {
 		assert(p->db != 0);
-		assert(sqlite3_mutex_held(p->db->mutex));
 		p->rc = sqlite3ApiExit(p->db, p->rc);
-		sqlite3_mutex_leave(p->db->mutex);
 	}
 }
 
@@ -1131,7 +1100,6 @@ columnName(sqlite3_stmt * pStmt,
 	n = sqlite3_column_count(pStmt);
 	if (N < n && N >= 0) {
 		N += useType * n;
-		sqlite3_mutex_enter(db->mutex);
 		assert(db->mallocFailed == 0);
 		ret = xFunc(&p->aColName[N]);
 		/* A malloc may have failed inside of the xFunc() call. If this
@@ -1141,7 +1109,6 @@ columnName(sqlite3_stmt * pStmt,
 			sqlite3OomClear(db);
 			ret = 0;
 		}
-		sqlite3_mutex_leave(db->mutex);
 	}
 	return ret;
 }
@@ -1226,9 +1193,6 @@ sqlite3_column_origin_name(sqlite3_stmt * pStmt, int N)
  * the same as binding a NULL value to the column. If the "i" parameter is
  * out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
  *
- * A successful evaluation of this routine acquires the mutex on p.
- * the mutex is released if any kind of error occurs.
- *
  * The error code stored in database p->db is overwritten with the return
  * value in any case.
  */
@@ -1239,17 +1203,14 @@ vdbeUnbind(Vdbe * p, int i)
 	if (vdbeSafetyNotNull(p)) {
 		return SQLITE_MISUSE_BKPT;
 	}
-	sqlite3_mutex_enter(p->db->mutex);
 	if (p->magic != VDBE_MAGIC_RUN || p->pc >= 0) {
 		sqlite3Error(p->db, SQLITE_MISUSE);
-		sqlite3_mutex_leave(p->db->mutex);
 		sqlite3_log(SQLITE_MISUSE,
 			    "bind on a busy prepared statement: [%s]", p->zSql);
 		return SQLITE_MISUSE_BKPT;
 	}
 	if (i < 1 || i > p->nVar) {
 		sqlite3Error(p->db, SQLITE_RANGE);
-		sqlite3_mutex_leave(p->db->mutex);
 		return SQLITE_RANGE;
 	}
 	i--;
@@ -1299,7 +1260,6 @@ bindText(sqlite3_stmt * pStmt,	/* The statement to bind against */
 			sqlite3Error(p->db, rc);
 			rc = sqlite3ApiExit(p->db, rc);
 		}
-		sqlite3_mutex_leave(p->db->mutex);
 	} else if (xDel != SQLITE_STATIC && xDel != SQLITE_TRANSIENT) {
 		xDel((void *)zData);
 	}
@@ -1344,7 +1304,6 @@ sqlite3_bind_double(sqlite3_stmt * pStmt, int i, double rValue)
 	rc = vdbeUnbind(p, i);
 	if (rc == SQLITE_OK) {
 		sqlite3VdbeMemSetDouble(&p->aVar[i - 1], rValue);
-		sqlite3_mutex_leave(p->db->mutex);
 	}
 	return rc;
 }
@@ -1363,7 +1322,6 @@ sqlite3_bind_int64(sqlite3_stmt * pStmt, int i, sqlite_int64 iValue)
 	rc = vdbeUnbind(p, i);
 	if (rc == SQLITE_OK) {
 		sqlite3VdbeMemSetInt64(&p->aVar[i - 1], iValue);
-		sqlite3_mutex_leave(p->db->mutex);
 	}
 	return rc;
 }
@@ -1374,9 +1332,6 @@ sqlite3_bind_null(sqlite3_stmt * pStmt, int i)
 	int rc;
 	Vdbe *p = (Vdbe *) pStmt;
 	rc = vdbeUnbind(p, i);
-	if (rc == SQLITE_OK) {
-		sqlite3_mutex_leave(p->db->mutex);
-	}
 	return rc;
 }
 
@@ -1448,7 +1403,6 @@ sqlite3_bind_zeroblob(sqlite3_stmt * pStmt, int i, int n)
 	rc = vdbeUnbind(p, i);
 	if (rc == SQLITE_OK) {
 		sqlite3VdbeMemSetZeroBlob(&p->aVar[i - 1], n);
-		sqlite3_mutex_leave(p->db->mutex);
 	}
 	return rc;
 }
@@ -1458,7 +1412,6 @@ sqlite3_bind_zeroblob64(sqlite3_stmt * pStmt, int i, sqlite3_uint64 n)
 {
 	int rc;
 	Vdbe *p = (Vdbe *) pStmt;
-	sqlite3_mutex_enter(p->db->mutex);
 	if (n > (u64) p->db->aLimit[SQLITE_LIMIT_LENGTH]) {
 		rc = SQLITE_TOOBIG;
 	} else {
@@ -1466,7 +1419,6 @@ sqlite3_bind_zeroblob64(sqlite3_stmt * pStmt, int i, sqlite3_uint64 n)
 		rc = sqlite3_bind_zeroblob(pStmt, i, n);
 	}
 	rc = sqlite3ApiExit(p->db, rc);
-	sqlite3_mutex_leave(p->db->mutex);
 	return rc;
 }
 
@@ -1534,11 +1486,9 @@ sqlite3TransferBindings(sqlite3_stmt * pFromStmt, sqlite3_stmt * pToStmt)
 	int i;
 	assert(pTo->db == pFrom->db);
 	assert(pTo->nVar == pFrom->nVar);
-	sqlite3_mutex_enter(pTo->db->mutex);
 	for (i = 0; i < pFrom->nVar; i++) {
 		sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
 	}
-	sqlite3_mutex_leave(pTo->db->mutex);
 	return SQLITE_OK;
 }
 
@@ -1580,13 +1530,11 @@ sqlite3_next_stmt(sqlite3 * pDb, sqlite3_stmt * pStmt)
 		return 0;
 	}
 #endif
-	sqlite3_mutex_enter(pDb->mutex);
 	if (pStmt == 0) {
 		pNext = (sqlite3_stmt *) pDb->pVdbe;
 	} else {
 		pNext = (sqlite3_stmt *) ((Vdbe *) pStmt)->pNext;
 	}
-	sqlite3_mutex_leave(pDb->mutex);
 	return pNext;
 }
 
@@ -1639,9 +1587,7 @@ sqlite3_expanded_sql(sqlite3_stmt * pStmt)
 	const char *zSql = sqlite3_sql(pStmt);
 	if (zSql) {
 		Vdbe *p = (Vdbe *) pStmt;
-		sqlite3_mutex_enter(p->db->mutex);
 		z = sqlite3VdbeExpandSql(p, zSql);
-		sqlite3_mutex_leave(p->db->mutex);
 	}
 	return z;
 #endif
diff --git a/src/box/sql/vdbeaux.c b/src/box/sql/vdbeaux.c
index 92bf994..2b8d858 100644
--- a/src/box/sql/vdbeaux.c
+++ b/src/box/sql/vdbeaux.c
@@ -3000,7 +3000,6 @@ sqlite3VdbeDelete(Vdbe * p)
 	if (NEVER(p == 0))
 		return;
 	db = p->db;
-	assert(sqlite3_mutex_held(db->mutex));
 	sqlite3VdbeClearObject(db, p);
 	if (p->pPrev) {
 		p->pPrev->pNext = p->pNext;
@@ -4165,7 +4164,6 @@ sqlite3VdbeIdxKeyCompare(sqlite3 * db,			/* Database connection */
 void
 sqlite3VdbeSetChanges(sqlite3 * db, int nChange)
 {
-	assert(sqlite3_mutex_held(db->mutex));
 	db->nChange = nChange;
 	db->nTotalChange += nChange;
 }
diff --git a/src/box/sql/vdbemem.c b/src/box/sql/vdbemem.c
index 5dd85b8..9dd254f 100644
--- a/src/box/sql/vdbemem.c
+++ b/src/box/sql/vdbemem.c
@@ -183,7 +183,6 @@ sqlite3VdbeMemClearAndResize(Mem * pMem, int szNew)
 int
 sqlite3VdbeMemMakeWriteable(Mem * pMem)
 {
-	assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex));
 	if ((pMem->flags & (MEM_Str | MEM_Blob)) != 0) {
 		if (ExpandBlob(pMem))
 			return SQLITE_NOMEM;
@@ -215,7 +214,6 @@ sqlite3VdbeMemExpandBlob(Mem * pMem)
 	int nByte;
 	assert(pMem->flags & MEM_Zero);
 	assert(pMem->flags & MEM_Blob);
-	assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex));
 
 	/* Set nByte to the number of bytes required to store the expanded blob. */
 	nByte = pMem->n + pMem->u.nZero;
@@ -255,7 +253,6 @@ vdbeMemAddTerminator(Mem * pMem)
 int
 sqlite3VdbeMemNulTerminate(Mem * pMem)
 {
-	assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex));
 	testcase((pMem->flags & (MEM_Term | MEM_Str)) == (MEM_Term | MEM_Str));
 	testcase((pMem->flags & (MEM_Term | MEM_Str)) == 0);
 	if ((pMem->flags & (MEM_Term | MEM_Str)) != MEM_Str) {
@@ -285,7 +282,6 @@ sqlite3VdbeMemStringify(Mem * pMem, u8 bForce)
 	int fg = pMem->flags;
 	const int nByte = 32;
 
-	assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex));
 	assert(!(fg & MEM_Zero));
 	assert(!(fg & (MEM_Str | MEM_Blob)));
 	assert(fg & (MEM_Int | MEM_Real));
@@ -323,7 +319,6 @@ sqlite3VdbeMemFinalize(Mem * pMem, FuncDef * pFunc)
 		sqlite3_context ctx;
 		Mem t;
 		assert((pMem->flags & MEM_Null) != 0 || pFunc == pMem->u.pDef);
-		assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex));
 		memset(&ctx, 0, sizeof(ctx));
 		memset(&t, 0, sizeof(t));
 		t.flags = MEM_Null;
@@ -353,7 +348,6 @@ sqlite3VdbeMemFinalize(Mem * pMem, FuncDef * pFunc)
 static SQLITE_NOINLINE void
 vdbeMemClearExternAndSetNull(Mem * p)
 {
-	assert(p->db == 0 || sqlite3_mutex_held(p->db->mutex));
 	assert(VdbeMemDynamic(p));
 	if (p->flags & MEM_Agg) {
 		sqlite3VdbeMemFinalize(p, p->u.pDef);
@@ -458,7 +452,6 @@ i64
 sqlite3VdbeIntValue(Mem * pMem)
 {
 	int flags;
-	assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex));
 	assert(EIGHT_BYTE_ALIGNMENT(pMem));
 	flags = pMem->flags;
 	if (flags & MEM_Int) {
@@ -484,7 +477,6 @@ sqlite3VdbeIntValue(Mem * pMem)
 double
 sqlite3VdbeRealValue(Mem * pMem)
 {
-	assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex));
 	assert(EIGHT_BYTE_ALIGNMENT(pMem));
 	if (pMem->flags & MEM_Real) {
 		return pMem->u.r;
@@ -510,7 +502,6 @@ sqlite3VdbeIntegerAffinity(Mem * pMem)
 {
 	i64 ix;
 	assert(pMem->flags & MEM_Real);
-	assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex));
 	assert(EIGHT_BYTE_ALIGNMENT(pMem));
 
 	ix = doubleToInt64(pMem->u.r);
@@ -537,7 +528,6 @@ sqlite3VdbeIntegerAffinity(Mem * pMem)
 int
 sqlite3VdbeMemIntegerify(Mem * pMem)
 {
-	assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex));
 	assert(EIGHT_BYTE_ALIGNMENT(pMem));
 
 	pMem->u.i = sqlite3VdbeIntValue(pMem);
@@ -552,7 +542,6 @@ sqlite3VdbeMemIntegerify(Mem * pMem)
 int
 sqlite3VdbeMemRealify(Mem * pMem)
 {
-	assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex));
 	assert(EIGHT_BYTE_ALIGNMENT(pMem));
 
 	pMem->u.r = sqlite3VdbeRealValue(pMem);
@@ -573,7 +562,6 @@ sqlite3VdbeMemNumerify(Mem * pMem)
 {
 	if ((pMem->flags & (MEM_Int | MEM_Real | MEM_Null)) == 0) {
 		assert((pMem->flags & (MEM_Blob | MEM_Str)) != 0);
-		assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex));
 		if (0 == sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n)) {
 			MemSetTypeFlag(pMem, MEM_Int);
 		} else {
@@ -843,8 +831,6 @@ sqlite3VdbeMemCopy(Mem * pTo, const Mem * pFrom)
 void
 sqlite3VdbeMemMove(Mem * pTo, Mem * pFrom)
 {
-	assert(pFrom->db == 0 || sqlite3_mutex_held(pFrom->db->mutex));
-	assert(pTo->db == 0 || sqlite3_mutex_held(pTo->db->mutex));
 	assert(pFrom->db == 0 || pTo->db == 0 || pFrom->db == pTo->db);
 
 	sqlite3VdbeMemRelease(pTo);
@@ -879,7 +865,6 @@ sqlite3VdbeMemSetStr(Mem * pMem,	/* Memory cell to set to string value */
 	int nByte = n;		/* New value for pMem->n */
 	int iLimit;		/* Maximum allowed string or blob size */
 	u16 flags = 0;		/* New value for pMem->flags */
-	assert(pMem->db == 0 || sqlite3_mutex_held(pMem->db->mutex));
 
 	/* If z is a NULL pointer, set pMem to contain an SQL NULL. */
 	if (!z) {
@@ -1019,7 +1004,6 @@ static SQLITE_NOINLINE const void *
 valueToText(sqlite3_value * pVal)
 {
 	assert(pVal != 0);
-	assert(pVal->db == 0 || sqlite3_mutex_held(pVal->db->mutex));
 	assert((pVal->flags & (MEM_Null)) == 0);
 	if (pVal->flags & (MEM_Blob | MEM_Str)) {
 		if (ExpandBlob(pVal))
@@ -1048,7 +1032,6 @@ sqlite3ValueText(sqlite3_value * pVal)
 {
 	if (!pVal)
 		return 0;
-	assert(pVal->db == 0 || sqlite3_mutex_held(pVal->db->mutex));
 	if ((pVal->flags & (MEM_Str | MEM_Term)) == (MEM_Str | MEM_Term)) {
 		return pVal->z;
 	}
diff --git a/src/box/sql/vdbesort.c b/src/box/sql/vdbesort.c
index 68dbf50..fc10ef6 100644
--- a/src/box/sql/vdbesort.c
+++ b/src/box/sql/vdbesort.c
@@ -863,11 +863,7 @@ sqlite3VdbeSorterInit(sqlite3 * db,	/* Database connection (for malloc()) */
 
 	/* Initialize the upper limit on the number of worker threads */
 #if SQLITE_MAX_WORKER_THREADS>0
-	if (sqlite3TempInMemory(db) || sqlite3GlobalConfig.bCoreMutex == 0) {
-		nWorker = 0;
-	} else {
-		nWorker = db->aLimit[SQLITE_LIMIT_WORKER_THREADS];
-	}
+	nWorker = db->aLimit[SQLITE_LIMIT_WORKER_THREADS];
 #endif
 
 	/* Do not allow the total number of threads (main thread + all workers)
-- 
2.11.0

^ permalink raw reply	[flat|nested] 6+ messages in thread

* [tarantool-patches] [PATCH 3/4] sql: remove dead memory allocation systems
  2018-03-26 15:56 [tarantool-patches] [PATCH 0/4] Cleanup SQL memory and threading subsystems Kirill Yukhin
  2018-03-26 15:56 ` [tarantool-patches] [PATCH 1/4] sql: Remove all references to sqlite3.h Kirill Yukhin
  2018-03-26 15:56 ` [tarantool-patches] [PATCH 2/4] sql: remove mutexes around the code Kirill Yukhin
@ 2018-03-26 15:56 ` Kirill Yukhin
  2018-03-26 15:56 ` [tarantool-patches] [PATCH 4/4] sql: Remove dead defines from sqliteInt.h Kirill Yukhin
  2018-03-27 11:31 ` [tarantool-patches] Re: [PATCH 0/4] Cleanup SQL memory and threading subsystems v.shpilevoy
  4 siblings, 0 replies; 6+ messages in thread
From: Kirill Yukhin @ 2018-03-26 15:56 UTC (permalink / raw)
  To: v.shpilevoy; +Cc: tarantool-patches, Kirill Yukhin

Legacy SQL frontend contained about five different memory
allocators, which were avaiable through dedicated API.
Remove those allocators, limiting to simple malloc().
Remove API as well.
---
 src/box/sql/CMakeLists.txt |    5 -
 src/box/sql/global.c       |    1 -
 src/box/sql/main.c         |   73 +-
 src/box/sql/malloc.c       |  142 +-
 src/box/sql/mem0.c         |  116 -
 src/box/sql/mem1.c         |  314 ---
 src/box/sql/mem2.c         |  602 ----
 src/box/sql/mem3.c         |  767 -----
 src/box/sql/mem5.c         |  648 -----
 src/box/sql/mutex.c        |  211 --
 src/box/sql/mutex.h        |   82 -
 src/box/sql/mutex_noop.c   |  300 --
 src/box/sql/mutex_unix.c   |  442 ---
 src/box/sql/sqlite3.h      | 6728 --------------------------------------------
 src/box/sql/sqliteInt.h    |   48 +-
 src/box/sql/status.c       |    3 +-
 16 files changed, 109 insertions(+), 10373 deletions(-)
 delete mode 100644 src/box/sql/mem0.c
 delete mode 100644 src/box/sql/mem1.c
 delete mode 100644 src/box/sql/mem2.c
 delete mode 100644 src/box/sql/mem3.c
 delete mode 100644 src/box/sql/mem5.c
 delete mode 100644 src/box/sql/mutex.c
 delete mode 100644 src/box/sql/mutex.h
 delete mode 100644 src/box/sql/mutex_noop.c
 delete mode 100644 src/box/sql/mutex_unix.c
 delete mode 100644 src/box/sql/sqlite3.h

diff --git a/src/box/sql/CMakeLists.txt b/src/box/sql/CMakeLists.txt
index 8494e15..678eb4c 100644
--- a/src/box/sql/CMakeLists.txt
+++ b/src/box/sql/CMakeLists.txt
@@ -48,11 +48,6 @@ add_library(sql STATIC
     legacy.c
     main.c
     malloc.c
-    mem0.c
-    mem1.c
-    mem2.c
-    mem3.c
-    mem5.c
     os.c
     os_unix.c
     pragma.c
diff --git a/src/box/sql/global.c b/src/box/sql/global.c
index 6a78550..2304cbb 100644
--- a/src/box/sql/global.c
+++ b/src/box/sql/global.c
@@ -202,7 +202,6 @@ SQLITE_WSD struct Sqlite3Config sqlite3Config = {
 	512,			/* szLookaside */
 	125,			/* nLookaside */
 	0,			/* nStmtSpill */
-	{0, 0, 0, 0, 0, 0, 0, 0},	/* m */
 	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},	/* pcache2 */
 	(void *)0,		/* pHeap */
 	0,			/* nHeap */
diff --git a/src/box/sql/main.c b/src/box/sql/main.c
index 1f8c026..89c028d 100644
--- a/src/box/sql/main.c
+++ b/src/box/sql/main.c
@@ -179,7 +179,7 @@ sqlite3_initialize(void)
 		return SQLITE_OK;
 
 	if (!sqlite3GlobalConfig.isMallocInit)
-		rc = sqlite3MallocInit();
+		sqlite3MallocInit();
 	if (rc == SQLITE_OK)
 		sqlite3GlobalConfig.isMallocInit = 1;
 
@@ -326,29 +326,6 @@ sqlite3_config(int op, ...)
 
 	va_start(ap, op);
 	switch (op) {
-	case SQLITE_CONFIG_MALLOC:{
-			/* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a
-			 * single argument which is a pointer to an instance of the
-			 * sqlite3_mem_methods structure. The argument specifies alternative
-			 * low-level memory allocation routines to be used in place of the memory
-			 * allocation routines built into SQLite.
-			 */
-			sqlite3GlobalConfig.m =
-			    *va_arg(ap, sqlite3_mem_methods *);
-			break;
-		}
-	case SQLITE_CONFIG_GETMALLOC:{
-			/* EVIDENCE-OF: R-51213-46414 The SQLITE_CONFIG_GETMALLOC option takes a
-			 * single argument which is a pointer to an instance of the
-			 * sqlite3_mem_methods structure. The sqlite3_mem_methods structure is
-			 * filled with the currently defined memory allocation routines.
-			 */
-			if (sqlite3GlobalConfig.m.xMalloc == 0)
-				sqlite3MemSetDefault();
-			*va_arg(ap, sqlite3_mem_methods *) =
-			    sqlite3GlobalConfig.m;
-			break;
-		}
 	case SQLITE_CONFIG_MEMSTATUS:{
 			/* EVIDENCE-OF: R-61275-35157 The SQLITE_CONFIG_MEMSTATUS option takes
 			 * single argument of type int, interpreted as a boolean, which enables
@@ -369,54 +346,6 @@ sqlite3_config(int op, ...)
 			break;
 		}
 
-/* EVIDENCE-OF: R-06626-12911 The SQLITE_CONFIG_HEAP option is only
- * available if SQLite is compiled with either SQLITE_ENABLE_MEMSYS3 or
- * SQLITE_ENABLE_MEMSYS5 and returns SQLITE_ERROR if invoked otherwise.
- */
-#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
-	case SQLITE_CONFIG_HEAP:{
-			/* EVIDENCE-OF: R-19854-42126 There are three arguments to
-			 * SQLITE_CONFIG_HEAP: An 8-byte aligned pointer to the memory, the
-			 * number of bytes in the memory buffer, and the minimum allocation size.
-			 */
-			sqlite3GlobalConfig.pHeap = va_arg(ap, void *);
-			sqlite3GlobalConfig.nHeap = va_arg(ap, int);
-			sqlite3GlobalConfig.mnReq = va_arg(ap, int);
-
-			if (sqlite3GlobalConfig.mnReq < 1) {
-				sqlite3GlobalConfig.mnReq = 1;
-			} else if (sqlite3GlobalConfig.mnReq > (1 << 12)) {
-				/* cap min request size at 2^12 */
-				sqlite3GlobalConfig.mnReq = (1 << 12);
-			}
-
-			if (sqlite3GlobalConfig.pHeap == 0) {
-				/* EVIDENCE-OF: R-49920-60189 If the first pointer (the memory pointer)
-				 * is NULL, then SQLite reverts to using its default memory allocator
-				 * (the system malloc() implementation), undoing any prior invocation of
-				 * SQLITE_CONFIG_MALLOC.
-				 *
-				 * Setting sqlite3GlobalConfig.m to all zeros will cause malloc to
-				 * revert to its default implementation when sqlite3_initialize() is run
-				 */
-				memset(&sqlite3GlobalConfig.m, 0,
-				       sizeof(sqlite3GlobalConfig.m));
-			} else {
-				/* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the
-				 * alternative memory allocator is engaged to handle all of SQLites
-				 * memory allocation needs.
-				 */
-#ifdef SQLITE_ENABLE_MEMSYS3
-				sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3();
-#endif
-#ifdef SQLITE_ENABLE_MEMSYS5
-				sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5();
-#endif
-			}
-			break;
-		}
-#endif
-
 	case SQLITE_CONFIG_LOOKASIDE:{
 			sqlite3GlobalConfig.szLookaside = va_arg(ap, int);
 			sqlite3GlobalConfig.nLookaside = va_arg(ap, int);
diff --git a/src/box/sql/malloc.c b/src/box/sql/malloc.c
index 0a8107a..9526cce 100644
--- a/src/box/sql/malloc.c
+++ b/src/box/sql/malloc.c
@@ -37,6 +37,93 @@
 #include <stdarg.h>
 
 /*
+ * Like malloc(), but remember the size of the allocation
+ * so that we can find it later using sqlite3MemSize().
+ *
+ * For this low-level routine, we are guaranteed that nByte>0 because
+ * cases of nByte<=0 will be intercepted and dealt with by higher level
+ * routines.
+ */
+static void *
+sql_sized_malloc(int nByte)
+{
+	sqlite3_int64 *p;
+	assert(nByte > 0);
+	nByte = ROUND8(nByte);
+	p = malloc(nByte + 8);
+	if (p) {
+		p[0] = nByte;
+		p++;
+	} else {
+		testcase(sqlite3GlobalConfig.xLog != 0);
+		sqlite3_log(SQLITE_NOMEM,
+			    "failed to allocate %u bytes of memory", nByte);
+	}
+	return (void *)p;
+}
+
+/*
+ * Like free() but works for allocations obtained from sql_sized_malloc()
+ * or sql_sized_realloc().
+ *
+ * For this low-level routine, we already know that pPrior!=0 since
+ * cases where pPrior==0 will have been intecepted and dealt with
+ * by higher-level routines.
+ */
+static void
+sql_sized_free(void *pPrior)
+{
+	sqlite3_int64 *p = (sqlite3_int64 *) pPrior;
+	assert(pPrior != 0);
+	p--;
+	free(p);
+}
+
+/*
+ * Report the allocated size of a prior return from sql_sized_malloc()
+ * or sql_sized_realloc().
+ */
+static int
+sql_sized_sizeof(void *pPrior)
+{
+	sqlite3_int64 *p;
+	assert(pPrior != 0);
+	p = (sqlite3_int64 *) pPrior;
+	p--;
+	return (int)p[0];
+}
+
+/*
+ * Like realloc().  Resize an allocation previously obtained from
+ * sqlite3MemMalloc().
+ *
+ * For this low-level interface, we know that pPrior!=0.  Cases where
+ * pPrior==0 while have been intercepted by higher-level routine and
+ * redirected to sql_sized_malloc.  Similarly, we know that nByte>0 because
+ * cases where nByte<=0 will have been intercepted by higher-level
+ * routines and redirected to sql_sized_free.
+ */
+static void *
+sql_sized_realloc(void *pPrior, int nByte)
+{
+	sqlite3_int64 *p = (sqlite3_int64 *) pPrior;
+	assert(pPrior != 0 && nByte > 0);
+	assert(nByte == ROUND8(nByte));	/* EV: R-46199-30249 */
+	p--;
+	p = realloc(p, nByte + 8);
+	if (p) {
+		p[0] = nByte;
+		p++;
+	} else {
+		testcase(sqlite3GlobalConfig.xLog != 0);
+		sqlite3_log(SQLITE_NOMEM,
+			    "failed memory resize %u to %u bytes",
+			    sql_sized_sizeof(pPrior), nByte);
+	}
+	return (void *)p;
+}
+
+/*
  * Attempt to release up to n bytes of non-essential memory currently
  * held by SQLite. An example of non-essential memory is memory used to
  * cache database pages that are not currently in use.
@@ -130,13 +217,9 @@ sqlite3_soft_heap_limit(int n)
 /*
  * Initialize the memory allocation subsystem.
  */
-int
+void
 sqlite3MallocInit(void)
 {
-	int rc;
-	if (sqlite3GlobalConfig.m.xMalloc == 0) {
-		sqlite3MemSetDefault();
-	}
 	memset(&mem0, 0, sizeof(mem0));
 	if (sqlite3GlobalConfig.pScratch && sqlite3GlobalConfig.szScratch >= 100
 	    && sqlite3GlobalConfig.nScratch > 0) {
@@ -165,10 +248,6 @@ sqlite3MallocInit(void)
 		sqlite3GlobalConfig.pPage = 0;
 		sqlite3GlobalConfig.szPage = 0;
 	}
-	rc = sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData);
-	if (rc != SQLITE_OK)
-		memset(&mem0, 0, sizeof(mem0));
-	return rc;
 }
 
 /*
@@ -188,9 +267,6 @@ sqlite3HeapNearlyFull(void)
 void
 sqlite3MallocEnd(void)
 {
-	if (sqlite3GlobalConfig.m.xShutdown) {
-		sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData);
-	}
 	memset(&mem0, 0, sizeof(mem0));
 }
 
@@ -238,7 +314,7 @@ mallocWithAlarm(int n, void **pp)
 {
 	int nFull;
 	void *p;
-	nFull = sqlite3GlobalConfig.m.xRoundup(n);
+	nFull = ROUND8(n);
 	sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n);
 	if (mem0.alarmThreshold > 0) {
 		sqlite3_int64 nUsed =
@@ -250,11 +326,11 @@ mallocWithAlarm(int n, void **pp)
 			mem0.nearlyFull = 0;
 		}
 	}
-	p = sqlite3GlobalConfig.m.xMalloc(nFull);
+	p = sql_sized_malloc(nFull);
 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
 	if (p == 0 && mem0.alarmThreshold > 0) {
 		sqlite3MallocAlarm(nFull);
-		p = sqlite3GlobalConfig.m.xMalloc(nFull);
+		p = sql_sized_malloc(nFull);
 	}
 #endif
 	if (p) {
@@ -277,7 +353,7 @@ sqlite3Malloc(u64 n)
 	if (n == 0 || n >= 0x7fffff00) {
 		/* A memory allocation of a number of bytes which is near the maximum
 		 * signed integer value might cause an integer overflow inside of the
-		 * xMalloc().  Hence we limit the maximum size to 0x7fffff00, giving
+		 * sql_sized_malloc().  Hence we limit the maximum size to 0x7fffff00, giving
 		 * 255 bytes of overhead.  SQLite itself will never use anything near
 		 * this amount.  The only way to reach the limit is with sqlite3_malloc()
 		 */
@@ -285,7 +361,7 @@ sqlite3Malloc(u64 n)
 	} else if (sqlite3GlobalConfig.bMemstat) {
 		mallocWithAlarm((int)n, &p);
 	} else {
-		p = sqlite3GlobalConfig.m.xMalloc((int)n);
+		p = sql_sized_malloc((int)n);
 	}
 	assert(EIGHT_BYTE_ALIGNMENT(p));	/* IMP: R-11148-40995 */
 	return p;
@@ -409,10 +485,9 @@ sqlite3ScratchFree(void *p)
 						  iSize);
 				sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT,
 						  1);
-				sqlite3GlobalConfig.m.xFree(p);
-			} else {
-				sqlite3GlobalConfig.m.xFree(p);
-			}
+				sql_sized_free(p);
+			} else
+				sql_sized_free(p);
 		}
 	}
 }
@@ -438,7 +513,7 @@ int
 sqlite3MallocSize(void *p)
 {
 	assert(sqlite3MemdebugHasType(p, MEMTYPE_HEAP));
-	return sqlite3GlobalConfig.m.xSize(p);
+	return sql_sized_sizeof(p);
 }
 
 int
@@ -457,7 +532,7 @@ sqlite3DbMallocSize(sqlite3 * db, void *p)
 			       (p, (u8) ~ (MEMTYPE_LOOKASIDE | MEMTYPE_HEAP)));
 		}
 #endif
-		return sqlite3GlobalConfig.m.xSize(p);
+		return sql_sized_sizeof(p);
 	} else
 		return db->lookaside.sz;
 }
@@ -467,7 +542,7 @@ sqlite3_msize(void *p)
 {
 	assert(sqlite3MemdebugNoType(p, (u8) ~ MEMTYPE_HEAP));
 	assert(sqlite3MemdebugHasType(p, MEMTYPE_HEAP));
-	return p ? sqlite3GlobalConfig.m.xSize(p) : 0;
+	return p ? sql_sized_sizeof(p) : 0;
 }
 
 /*
@@ -484,10 +559,9 @@ sqlite3_free(void *p)
 		sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED,
 				  sqlite3MallocSize(p));
 		sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);
-		sqlite3GlobalConfig.m.xFree(p);
-	} else {
-		sqlite3GlobalConfig.m.xFree(p);
-	}
+		sql_sized_free(p);
+	} else
+		sql_sized_free(p);
 }
 
 /*
@@ -556,11 +630,7 @@ sqlite3Realloc(void *pOld, u64 nBytes)
 		return 0;
 	}
 	nOld = sqlite3MallocSize(pOld);
-	/* IMPLEMENTATION-OF: R-46199-30249 SQLite guarantees that the second
-	 * argument to xRealloc is always a value returned by a prior call to
-	 * xRoundup.
-	 */
-	nNew = sqlite3GlobalConfig.m.xRoundup((int)nBytes);
+	nNew = ROUND8((int)nBytes);
 	if (nOld == nNew) {
 		pNew = pOld;
 	} else if (sqlite3GlobalConfig.bMemstat) {
@@ -571,17 +641,17 @@ sqlite3Realloc(void *pOld, u64 nBytes)
 		    mem0.alarmThreshold - nDiff) {
 			sqlite3MallocAlarm(nDiff);
 		}
-		pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
+		pNew = sql_sized_realloc(pOld, nNew);
 		if (pNew == 0 && mem0.alarmThreshold > 0) {
 			sqlite3MallocAlarm((int)nBytes);
-			pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
+			pNew = sql_sized_realloc(pOld, nNew);
 		}
 		if (pNew) {
 			nNew = sqlite3MallocSize(pNew);
 			sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew - nOld);
 		}
 	} else {
-		pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
+		pNew = sql_sized_realloc(pOld, nNew);
 	}
 	assert(EIGHT_BYTE_ALIGNMENT(pNew));	/* IMP: R-11148-40995 */
 	return pNew;
diff --git a/src/box/sql/mem0.c b/src/box/sql/mem0.c
deleted file mode 100644
index 39b4ab7..0000000
--- a/src/box/sql/mem0.c
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * 1. Redistributions of source code must retain the above
- *    copyright notice, this list of conditions and the
- *    following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
- * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- *
- * This file contains a no-op memory allocation drivers for use when
- * SQLITE_ZERO_MALLOC is defined.  The allocation drivers implemented
- * here always fail.  SQLite will not operate with these drivers.  These
- * are merely placeholders.  Real drivers must be substituted using
- * sqlite3_config() before SQLite will operate.
- */
-#include "sqliteInt.h"
-
-/*
- * This version of the memory allocator is the default.  It is
- * used when no other memory allocator is specified using compile-time
- * macros.
- */
-#ifdef SQLITE_ZERO_MALLOC
-
-/*
- * No-op versions of all memory allocation routines
- */
-static void *
-sqlite3MemMalloc(int nByte)
-{
-	return 0;
-}
-
-static void
-sqlite3MemFree(void *pPrior)
-{
-	return;
-}
-
-static void *
-sqlite3MemRealloc(void *pPrior, int nByte)
-{
-	return 0;
-}
-
-static int
-sqlite3MemSize(void *pPrior)
-{
-	return 0;
-}
-
-static int
-sqlite3MemRoundup(int n)
-{
-	return n;
-}
-
-static int
-sqlite3MemInit(void *NotUsed)
-{
-	return SQLITE_OK;
-}
-
-static void
-sqlite3MemShutdown(void *NotUsed)
-{
-	return;
-}
-
-/*
- * This routine is the only routine in this file with external linkage.
- *
- * Populate the low-level memory allocation function pointers in
- * sqlite3GlobalConfig.m with pointers to the routines in this file.
- */
-void
-sqlite3MemSetDefault(void)
-{
-	static const sqlite3_mem_methods defaultMethods = {
-		sqlite3MemMalloc,
-		sqlite3MemFree,
-		sqlite3MemRealloc,
-		sqlite3MemSize,
-		sqlite3MemRoundup,
-		sqlite3MemInit,
-		sqlite3MemShutdown,
-		0
-	};
-	sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
-}
-
-#endif				/* SQLITE_ZERO_MALLOC */
diff --git a/src/box/sql/mem1.c b/src/box/sql/mem1.c
deleted file mode 100644
index 2ea6731..0000000
--- a/src/box/sql/mem1.c
+++ /dev/null
@@ -1,314 +0,0 @@
-/*
- * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * 1. Redistributions of source code must retain the above
- *    copyright notice, this list of conditions and the
- *    following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
- * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- *
- * This file contains low-level memory allocation drivers for when
- * SQLite will use the standard C-library malloc/realloc/free interface
- * to obtain the memory it needs.
- *
- * This file contains implementations of the low-level memory allocation
- * routines specified in the sqlite3_mem_methods object.  The content of
- * this file is only used if SQLITE_SYSTEM_MALLOC is defined.  The
- * SQLITE_SYSTEM_MALLOC macro is defined automatically if
- * SQLITE_MEMDEBUG macro is not defined.  The
- * default configuration is to use memory allocation routines in this
- * file.
- *
- * C-preprocessor macro summary:
- *
- *    HAVE_MALLOC_USABLE_SIZE     The configure script sets this symbol if
- *                                the malloc_usable_size() interface exists
- *                                on the target platform.  Or, this symbol
- *                                can be set manually, if desired.
- *                                If an equivalent interface exists by
- *                                a different name, using a separate -D
- *                                option to rename it.
- *
- *    SQLITE_WITHOUT_ZONEMALLOC   Some older macs lack support for the zone
- *                                memory allocator.  Set this symbol to enable
- *                                building on older macs.
- *
- */
-#include "sqliteInt.h"
-
-/*
- * This version of the memory allocator is the default.  It is
- * used when no other memory allocator is specified using compile-time
- * macros.
- */
-#ifdef SQLITE_SYSTEM_MALLOC
-#if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC)
-
-/*
- * Use the zone allocator available on apple products unless the
- * SQLITE_WITHOUT_ZONEMALLOC symbol is defined.
- */
-#include <sys/sysctl.h>
-#include <malloc/malloc.h>
-#include <libkern/OSAtomic.h>
-static malloc_zone_t *_sqliteZone_;
-#define SQLITE_MALLOC(x) malloc_zone_malloc(_sqliteZone_, (x))
-#define SQLITE_FREE(x) malloc_zone_free(_sqliteZone_, (x));
-#define SQLITE_REALLOC(x,y) malloc_zone_realloc(_sqliteZone_, (x), (y))
-#define SQLITE_MALLOCSIZE(x) \
-        (_sqliteZone_ ? _sqliteZone_->size(_sqliteZone_,x) : malloc_size(x))
-
-#else				/* if not __APPLE__ */
-
-/*
- * Use standard C library malloc and free on non-Apple systems.
- * Also used by Apple systems if SQLITE_WITHOUT_ZONEMALLOC is defined.
- */
-#define SQLITE_MALLOC(x)             malloc(x)
-#define SQLITE_FREE(x)               free(x)
-#define SQLITE_REALLOC(x,y)          realloc((x),(y))
-
-/*
- * The malloc.h header file is needed for malloc_usable_size() function
- * on some systems (e.g. Linux).
- */
-#if HAVE_MALLOC_H && HAVE_MALLOC_USABLE_SIZE
-#define SQLITE_USE_MALLOC_H 1
-#define SQLITE_USE_MALLOC_USABLE_SIZE 1
-#endif
-
-/*
- * Include the malloc.h header file, if necessary.  Also set define macro
- * SQLITE_MALLOCSIZE to the appropriate function name, which is
- * malloc_usable_size() for most systems (e.g. Linux).
- * The memory size function can always be overridden manually by defining
- * the macro SQLITE_MALLOCSIZE to the desired function name.
- */
-#if defined(SQLITE_USE_MALLOC_H)
-#include <malloc.h>
-#if defined(SQLITE_USE_MALLOC_USABLE_SIZE)
-#if !defined(SQLITE_MALLOCSIZE)
-#define SQLITE_MALLOCSIZE(x)   malloc_usable_size(x)
-#endif
-#elif defined(SQLITE_USE_MSIZE)
-#if !defined(SQLITE_MALLOCSIZE)
-#define SQLITE_MALLOCSIZE      _msize
-#endif
-#endif
-#endif				/* defined(SQLITE_USE_MALLOC_H) */
-
-#endif				/* __APPLE__ or not __APPLE__ */
-
-/*
- * Like malloc(), but remember the size of the allocation
- * so that we can find it later using sqlite3MemSize().
- *
- * For this low-level routine, we are guaranteed that nByte>0 because
- * cases of nByte<=0 will be intercepted and dealt with by higher level
- * routines.
- */
-static void *
-sqlite3MemMalloc(int nByte)
-{
-#ifdef SQLITE_MALLOCSIZE
-	void *p = SQLITE_MALLOC(nByte);
-	if (p == 0) {
-		testcase(sqlite3GlobalConfig.xLog != 0);
-		sqlite3_log(SQLITE_NOMEM,
-			    "failed to allocate %u bytes of memory", nByte);
-	}
-	return p;
-#else
-	sqlite3_int64 *p;
-	assert(nByte > 0);
-	nByte = ROUND8(nByte);
-	p = SQLITE_MALLOC(nByte + 8);
-	if (p) {
-		p[0] = nByte;
-		p++;
-	} else {
-		testcase(sqlite3GlobalConfig.xLog != 0);
-		sqlite3_log(SQLITE_NOMEM,
-			    "failed to allocate %u bytes of memory", nByte);
-	}
-	return (void *)p;
-#endif
-}
-
-/*
- * Like free() but works for allocations obtained from sqlite3MemMalloc()
- * or sqlite3MemRealloc().
- *
- * For this low-level routine, we already know that pPrior!=0 since
- * cases where pPrior==0 will have been intecepted and dealt with
- * by higher-level routines.
- */
-static void
-sqlite3MemFree(void *pPrior)
-{
-#ifdef SQLITE_MALLOCSIZE
-	SQLITE_FREE(pPrior);
-#else
-	sqlite3_int64 *p = (sqlite3_int64 *) pPrior;
-	assert(pPrior != 0);
-	p--;
-	SQLITE_FREE(p);
-#endif
-}
-
-/*
- * Report the allocated size of a prior return from xMalloc()
- * or xRealloc().
- */
-static int
-sqlite3MemSize(void *pPrior)
-{
-#ifdef SQLITE_MALLOCSIZE
-	assert(pPrior != 0);
-	return (int)SQLITE_MALLOCSIZE(pPrior);
-#else
-	sqlite3_int64 *p;
-	assert(pPrior != 0);
-	p = (sqlite3_int64 *) pPrior;
-	p--;
-	return (int)p[0];
-#endif
-}
-
-/*
- * Like realloc().  Resize an allocation previously obtained from
- * sqlite3MemMalloc().
- *
- * For this low-level interface, we know that pPrior!=0.  Cases where
- * pPrior==0 while have been intercepted by higher-level routine and
- * redirected to xMalloc.  Similarly, we know that nByte>0 because
- * cases where nByte<=0 will have been intercepted by higher-level
- * routines and redirected to xFree.
- */
-static void *
-sqlite3MemRealloc(void *pPrior, int nByte)
-{
-#ifdef SQLITE_MALLOCSIZE
-	void *p = SQLITE_REALLOC(pPrior, nByte);
-	if (p == 0) {
-		testcase(sqlite3GlobalConfig.xLog != 0);
-		sqlite3_log(SQLITE_NOMEM,
-			    "failed memory resize %u to %u bytes",
-			    SQLITE_MALLOCSIZE(pPrior), nByte);
-	}
-	return p;
-#else
-	sqlite3_int64 *p = (sqlite3_int64 *) pPrior;
-	assert(pPrior != 0 && nByte > 0);
-	assert(nByte == ROUND8(nByte));	/* EV: R-46199-30249 */
-	p--;
-	p = SQLITE_REALLOC(p, nByte + 8);
-	if (p) {
-		p[0] = nByte;
-		p++;
-	} else {
-		testcase(sqlite3GlobalConfig.xLog != 0);
-		sqlite3_log(SQLITE_NOMEM,
-			    "failed memory resize %u to %u bytes",
-			    sqlite3MemSize(pPrior), nByte);
-	}
-	return (void *)p;
-#endif
-}
-
-/*
- * Round up a request size to the next valid allocation size.
- */
-static int
-sqlite3MemRoundup(int n)
-{
-	return ROUND8(n);
-}
-
-/*
- * Initialize this module.
- */
-static int
-sqlite3MemInit(void *NotUsed)
-{
-#if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC)
-	int cpuCount;
-	size_t len;
-	if (_sqliteZone_) {
-		return SQLITE_OK;
-	}
-	len = sizeof(cpuCount);
-	/* One usually wants to use hw.acctivecpu for MT decisions, but not here */
-	sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0);
-	if (cpuCount > 1) {
-		/* defer MT decisions to system malloc */
-		_sqliteZone_ = malloc_default_zone();
-	} else {
-		/* only 1 core, use our own zone to contention over global locks,
-		 * e.g. we have our own dedicated locks
-		 */
-		malloc_zone_t *newzone = malloc_create_zone(4096, 0);
-		malloc_set_zone_name(newzone, "Sqlite_Heap");
-	}
-#endif
-	UNUSED_PARAMETER(NotUsed);
-	return SQLITE_OK;
-}
-
-/*
- * Deinitialize this module.
- */
-static void
-sqlite3MemShutdown(void *NotUsed)
-{
-	UNUSED_PARAMETER(NotUsed);
-	return;
-}
-
-/*
- * This routine is the only routine in this file with external linkage.
- *
- * Populate the low-level memory allocation function pointers in
- * sqlite3GlobalConfig.m with pointers to the routines in this file.
- */
-void
-sqlite3MemSetDefault(void)
-{
-	static const sqlite3_mem_methods defaultMethods = {
-		sqlite3MemMalloc,
-		sqlite3MemFree,
-		sqlite3MemRealloc,
-		sqlite3MemSize,
-		sqlite3MemRoundup,
-		sqlite3MemInit,
-		sqlite3MemShutdown,
-		0
-	};
-	sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
-}
-
-#endif				/* SQLITE_SYSTEM_MALLOC */
diff --git a/src/box/sql/mem2.c b/src/box/sql/mem2.c
deleted file mode 100644
index 0e8816e..0000000
--- a/src/box/sql/mem2.c
+++ /dev/null
@@ -1,602 +0,0 @@
-/*
- * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * 1. Redistributions of source code must retain the above
- *    copyright notice, this list of conditions and the
- *    following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
- * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- *
- * This file contains low-level memory allocation drivers for when
- * SQLite will use the standard C-library malloc/realloc/free interface
- * to obtain the memory it needs while adding lots of additional debugging
- * information to each allocation in order to help detect and fix memory
- * leaks and memory usage errors.
- *
- * This file contains implementations of the low-level memory allocation
- * routines specified in the sqlite3_mem_methods object.
- */
-#include "sqliteInt.h"
-
-/*
- * This version of the memory allocator is used only if the
- * SQLITE_MEMDEBUG macro is defined
- */
-#ifdef SQLITE_MEMDEBUG
-
-/*
- * The backtrace functionality is only available with GLIBC
- */
-#ifdef __GLIBC__
-extern int backtrace(void **, int);
-extern void backtrace_symbols_fd(void *const *, int, int);
-#else
-#define backtrace(A,B) 1
-#define backtrace_symbols_fd(A,B,C)
-#endif
-#include <stdio.h>
-
-/*
- * Each memory allocation looks like this:
- *
- *  ------------------------------------------------------------------------
- *  | Title |  backtrace pointers |  MemBlockHdr |  allocation |  EndGuard |
- *  ------------------------------------------------------------------------
- *
- * The application code sees only a pointer to the allocation.  We have
- * to back up from the allocation pointer to find the MemBlockHdr.  The
- * MemBlockHdr tells us the size of the allocation and the number of
- * backtrace pointers.  There is also a guard word at the end of the
- * MemBlockHdr.
- */
-struct MemBlockHdr {
-	i64 iSize;		/* Size of this allocation */
-	struct MemBlockHdr *pNext, *pPrev;	/* Linked list of all unfreed memory */
-	char nBacktrace;	/* Number of backtraces on this alloc */
-	char nBacktraceSlots;	/* Available backtrace slots */
-	u8 nTitle;		/* Bytes of title; includes '\0' */
-	u8 eType;		/* Allocation type code */
-	int iForeGuard;		/* Guard word for sanity */
-};
-
-/*
- * Guard words
- */
-#define FOREGUARD 0x80F5E153
-#define REARGUARD 0xE4676B53
-
-/*
- * Number of malloc size increments to track.
- */
-#define NCSIZE  1000
-
-/*
- * All of the static variables used by this module are collected
- * into a single structure named "mem".  This is to keep the
- * static variables organized and to reduce namespace pollution
- * when this module is combined with other in the amalgamation.
- */
-static struct {
-
-	/*
-	 * Mutex to control access to the memory allocation subsystem.
-	 */
-	sqlite3_mutex *mutex;
-
-	/*
-	 * Head and tail of a linked list of all outstanding allocations
-	 */
-	struct MemBlockHdr *pFirst;
-	struct MemBlockHdr *pLast;
-
-	/*
-	 * The number of levels of backtrace to save in new allocations.
-	 */
-	int nBacktrace;
-	void (*xBacktrace) (int, int, void **);
-
-	/*
-	 * Title text to insert in front of each block
-	 */
-	int nTitle;		/* Bytes of zTitle to save.  Includes '\0' and padding */
-	char zTitle[100];	/* The title text */
-
-	/*
-	 * sqlite3MallocDisallow() increments the following counter.
-	 * sqlite3MallocAllow() decrements it.
-	 */
-	int disallow;		/* Do not allow memory allocation */
-
-	/*
-	 * Gather statistics on the sizes of memory allocations.
-	 * nAlloc[i] is the number of allocation attempts of i*8
-	 * bytes.  i==NCSIZE is the number of allocation attempts for
-	 * sizes more than NCSIZE*8 bytes.
-	 */
-	int nAlloc[NCSIZE];	/* Total number of allocations */
-	int nCurrent[NCSIZE];	/* Current number of allocations */
-	int mxCurrent[NCSIZE];	/* Highwater mark for nCurrent */
-
-} mem;
-
-/*
- * Adjust memory usage statistics
- */
-static void
-adjustStats(int iSize, int increment)
-{
-	int i = ROUND8(iSize) / 8;
-	if (i > NCSIZE - 1) {
-		i = NCSIZE - 1;
-	}
-	if (increment > 0) {
-		mem.nAlloc[i]++;
-		mem.nCurrent[i]++;
-		if (mem.nCurrent[i] > mem.mxCurrent[i]) {
-			mem.mxCurrent[i] = mem.nCurrent[i];
-		}
-	} else {
-		mem.nCurrent[i]--;
-		assert(mem.nCurrent[i] >= 0);
-	}
-}
-
-/*
- * Given an allocation, find the MemBlockHdr for that allocation.
- *
- * This routine checks the guards at either end of the allocation and
- * if they are incorrect it asserts.
- */
-static struct MemBlockHdr *
-sqlite3MemsysGetHeader(void *pAllocation)
-{
-	struct MemBlockHdr *p;
-	int *pInt;
-	u8 *pU8;
-	int nReserve;
-
-	p = (struct MemBlockHdr *)pAllocation;
-	p--;
-	assert(p->iForeGuard == (int)FOREGUARD);
-	nReserve = ROUND8(p->iSize);
-	pInt = (int *)pAllocation;
-	pU8 = (u8 *) pAllocation;
-	assert(pInt[nReserve / sizeof(int)] == (int)REARGUARD);
-	/* This checks any of the "extra" bytes allocated due
-	 * to rounding up to an 8 byte boundary to ensure
-	 * they haven't been overwritten.
-	 */
-	while (nReserve-- > p->iSize)
-		assert(pU8[nReserve] == 0x65);
-	return p;
-}
-
-/*
- * Return the number of bytes currently allocated at address p.
- */
-static int
-sqlite3MemSize(void *p)
-{
-	struct MemBlockHdr *pHdr;
-	if (!p) {
-		return 0;
-	}
-	pHdr = sqlite3MemsysGetHeader(p);
-	return (int)pHdr->iSize;
-}
-
-/*
- * Initialize the memory allocation subsystem.
- */
-static int
-sqlite3MemInit(void *NotUsed)
-{
-	UNUSED_PARAMETER(NotUsed);
-	assert((sizeof(struct MemBlockHdr) & 7) == 0);
-	if (!sqlite3GlobalConfig.bMemstat) {
-		/* If memory status is enabled, then the malloc.c wrapper will already
-		 * hold the STATIC_MEM mutex when the routines here are invoked.
-		 */
-		mem.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
-	}
-	return SQLITE_OK;
-}
-
-/*
- * Deinitialize the memory allocation subsystem.
- */
-static void
-sqlite3MemShutdown(void *NotUsed)
-{
-	UNUSED_PARAMETER(NotUsed);
-	mem.mutex = 0;
-}
-
-/*
- * Round up a request size to the next valid allocation size.
- */
-static int
-sqlite3MemRoundup(int n)
-{
-	return ROUND8(n);
-}
-
-/*
- * Fill a buffer with pseudo-random bytes.  This is used to preset
- * the content of a new memory allocation to unpredictable values and
- * to clear the content of a freed allocation to unpredictable values.
- */
-static void
-randomFill(char *pBuf, int nByte)
-{
-	unsigned int x, y, r;
-	x = SQLITE_PTR_TO_INT(pBuf);
-	y = nByte | 1;
-	while (nByte >= 4) {
-		x = (x >> 1) ^ (-(int)(x & 1) & 0xd0000001);
-		y = y * 1103515245 + 12345;
-		r = x ^ y;
-		*(int *)pBuf = r;
-		pBuf += 4;
-		nByte -= 4;
-	}
-	while (nByte-- > 0) {
-		x = (x >> 1) ^ (-(int)(x & 1) & 0xd0000001);
-		y = y * 1103515245 + 12345;
-		r = x ^ y;
-		*(pBuf++) = r & 0xff;
-	}
-}
-
-/*
- * Allocate nByte bytes of memory.
- */
-static void *
-sqlite3MemMalloc(int nByte)
-{
-	struct MemBlockHdr *pHdr;
-	void **pBt;
-	char *z;
-	int *pInt;
-	void *p = 0;
-	int totalSize;
-	int nReserve;
-	sqlite3_mutex_enter(mem.mutex);
-	assert(mem.disallow == 0);
-	nReserve = ROUND8(nByte);
-	totalSize = nReserve + sizeof(*pHdr) + sizeof(int) +
-	    mem.nBacktrace * sizeof(void *) + mem.nTitle;
-	p = malloc(totalSize);
-	if (p) {
-		z = p;
-		pBt = (void **)&z[mem.nTitle];
-		pHdr = (struct MemBlockHdr *)&pBt[mem.nBacktrace];
-		pHdr->pNext = 0;
-		pHdr->pPrev = mem.pLast;
-		if (mem.pLast) {
-			mem.pLast->pNext = pHdr;
-		} else {
-			mem.pFirst = pHdr;
-		}
-		mem.pLast = pHdr;
-		pHdr->iForeGuard = FOREGUARD;
-		pHdr->eType = MEMTYPE_HEAP;
-		pHdr->nBacktraceSlots = mem.nBacktrace;
-		pHdr->nTitle = mem.nTitle;
-		if (mem.nBacktrace) {
-			void *aAddr[40];
-			pHdr->nBacktrace =
-			    backtrace(aAddr, mem.nBacktrace + 1) - 1;
-			memcpy(pBt, &aAddr[1],
-			       pHdr->nBacktrace * sizeof(void *));
-			assert(pBt[0]);
-			if (mem.xBacktrace) {
-				mem.xBacktrace(nByte, pHdr->nBacktrace - 1,
-					       &aAddr[1]);
-			}
-		} else {
-			pHdr->nBacktrace = 0;
-		}
-		if (mem.nTitle) {
-			memcpy(z, mem.zTitle, mem.nTitle);
-		}
-		pHdr->iSize = nByte;
-		adjustStats(nByte, +1);
-		pInt = (int *)&pHdr[1];
-		pInt[nReserve / sizeof(int)] = REARGUARD;
-		randomFill((char *)pInt, nByte);
-		memset(((char *)pInt) + nByte, 0x65, nReserve - nByte);
-		p = (void *)pInt;
-	}
-	sqlite3_mutex_leave(mem.mutex);
-	return p;
-}
-
-/*
- * Free memory.
- */
-static void
-sqlite3MemFree(void *pPrior)
-{
-	struct MemBlockHdr *pHdr;
-	void **pBt;
-	char *z;
-	assert(sqlite3GlobalConfig.bMemstat
-	       || sqlite3GlobalConfig.bCoreMutex == 0 || mem.mutex != 0);
-	pHdr = sqlite3MemsysGetHeader(pPrior);
-	pBt = (void **)pHdr;
-	pBt -= pHdr->nBacktraceSlots;
-	sqlite3_mutex_enter(mem.mutex);
-	if (pHdr->pPrev) {
-		assert(pHdr->pPrev->pNext == pHdr);
-		pHdr->pPrev->pNext = pHdr->pNext;
-	} else {
-		assert(mem.pFirst == pHdr);
-		mem.pFirst = pHdr->pNext;
-	}
-	if (pHdr->pNext) {
-		assert(pHdr->pNext->pPrev == pHdr);
-		pHdr->pNext->pPrev = pHdr->pPrev;
-	} else {
-		assert(mem.pLast == pHdr);
-		mem.pLast = pHdr->pPrev;
-	}
-	z = (char *)pBt;
-	z -= pHdr->nTitle;
-	adjustStats((int)pHdr->iSize, -1);
-	randomFill(z, sizeof(void *) * pHdr->nBacktraceSlots + sizeof(*pHdr) +
-		   (int)pHdr->iSize + sizeof(int) + pHdr->nTitle);
-	free(z);
-	sqlite3_mutex_leave(mem.mutex);
-}
-
-/*
- * Change the size of an existing memory allocation.
- *
- * For this debugging implementation, we *always* make a copy of the
- * allocation into a new place in memory.  In this way, if the
- * higher level code is using pointer to the old allocation, it is
- * much more likely to break and we are much more liking to find
- * the error.
- */
-static void *
-sqlite3MemRealloc(void *pPrior, int nByte)
-{
-	struct MemBlockHdr *pOldHdr;
-	void *pNew;
-	assert(mem.disallow == 0);
-	assert((nByte & 7) == 0);	/* EV: R-46199-30249 */
-	pOldHdr = sqlite3MemsysGetHeader(pPrior);
-	pNew = sqlite3MemMalloc(nByte);
-	if (pNew) {
-		memcpy(pNew, pPrior,
-		       (int)(nByte < pOldHdr->iSize ? nByte : pOldHdr->iSize));
-		if (nByte > pOldHdr->iSize) {
-			randomFill(&((char *)pNew)[pOldHdr->iSize],
-				   nByte - (int)pOldHdr->iSize);
-		}
-		sqlite3MemFree(pPrior);
-	}
-	return pNew;
-}
-
-/*
- * Populate the low-level memory allocation function pointers in
- * sqlite3GlobalConfig.m with pointers to the routines in this file.
- */
-void
-sqlite3MemSetDefault(void)
-{
-	static const sqlite3_mem_methods defaultMethods = {
-		sqlite3MemMalloc,
-		sqlite3MemFree,
-		sqlite3MemRealloc,
-		sqlite3MemSize,
-		sqlite3MemRoundup,
-		sqlite3MemInit,
-		sqlite3MemShutdown,
-		0
-	};
-	sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
-}
-
-/*
- * Set the "type" of an allocation.
- */
-void
-sqlite3MemdebugSetType(void *p, u8 eType)
-{
-	if (p && sqlite3GlobalConfig.m.xMalloc == sqlite3MemMalloc) {
-		struct MemBlockHdr *pHdr;
-		pHdr = sqlite3MemsysGetHeader(p);
-		assert(pHdr->iForeGuard == FOREGUARD);
-		pHdr->eType = eType;
-	}
-}
-
-/*
- * Return TRUE if the mask of type in eType matches the type of the
- * allocation p.  Also return true if p==NULL.
- *
- * This routine is designed for use within an assert() statement, to
- * verify the type of an allocation.  For example:
- *
- *     assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
- */
-int
-sqlite3MemdebugHasType(void *p, u8 eType)
-{
-	int rc = 1;
-	if (p && sqlite3GlobalConfig.m.xMalloc == sqlite3MemMalloc) {
-		struct MemBlockHdr *pHdr;
-		pHdr = sqlite3MemsysGetHeader(p);
-		assert(pHdr->iForeGuard == FOREGUARD);	/* Allocation is valid */
-		if ((pHdr->eType & eType) == 0) {
-			rc = 0;
-		}
-	}
-	return rc;
-}
-
-/*
- * Return TRUE if the mask of type in eType matches no bits of the type of the
- * allocation p.  Also return true if p==NULL.
- *
- * This routine is designed for use within an assert() statement, to
- * verify the type of an allocation.  For example:
- *
- *     assert( sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
- */
-int
-sqlite3MemdebugNoType(void *p, u8 eType)
-{
-	int rc = 1;
-	if (p && sqlite3GlobalConfig.m.xMalloc == sqlite3MemMalloc) {
-		struct MemBlockHdr *pHdr;
-		pHdr = sqlite3MemsysGetHeader(p);
-		assert(pHdr->iForeGuard == FOREGUARD);	/* Allocation is valid */
-		if ((pHdr->eType & eType) != 0) {
-			rc = 0;
-		}
-	}
-	return rc;
-}
-
-/*
- * Set the number of backtrace levels kept for each allocation.
- * A value of zero turns off backtracing.  The number is always rounded
- * up to a multiple of 2.
- */
-void
-sqlite3MemdebugBacktrace(int depth)
-{
-	if (depth < 0) {
-		depth = 0;
-	}
-	if (depth > 20) {
-		depth = 20;
-	}
-	depth = (depth + 1) & 0xfe;
-	mem.nBacktrace = depth;
-}
-
-void
-sqlite3MemdebugBacktraceCallback(void (*xBacktrace) (int, int, void **))
-{
-	mem.xBacktrace = xBacktrace;
-}
-
-/*
- * Set the title string for subsequent allocations.
- */
-void
-sqlite3MemdebugSettitle(const char *zTitle)
-{
-	unsigned int n = sqlite3Strlen30(zTitle) + 1;
-	sqlite3_mutex_enter(mem.mutex);
-	if (n >= sizeof(mem.zTitle))
-		n = sizeof(mem.zTitle) - 1;
-	memcpy(mem.zTitle, zTitle, n);
-	mem.zTitle[n] = 0;
-	mem.nTitle = ROUND8(n);
-	sqlite3_mutex_leave(mem.mutex);
-}
-
-void
-sqlite3MemdebugSync()
-{
-	struct MemBlockHdr *pHdr;
-	for (pHdr = mem.pFirst; pHdr; pHdr = pHdr->pNext) {
-		void **pBt = (void **)pHdr;
-		pBt -= pHdr->nBacktraceSlots;
-		mem.xBacktrace((int)pHdr->iSize, pHdr->nBacktrace - 1, &pBt[1]);
-	}
-}
-
-/*
- * Open the file indicated and write a log of all unfreed memory
- * allocations into that log.
- */
-void
-sqlite3MemdebugDump(const char *zFilename)
-{
-	FILE *out;
-	struct MemBlockHdr *pHdr;
-	void **pBt;
-	int i;
-	out = fopen(zFilename, "w");
-	if (out == 0) {
-		fprintf(stderr,
-			"** Unable to output memory debug output log: %s **\n",
-			zFilename);
-		return;
-	}
-	for (pHdr = mem.pFirst; pHdr; pHdr = pHdr->pNext) {
-		char *z = (char *)pHdr;
-		z -= pHdr->nBacktraceSlots * sizeof(void *) + pHdr->nTitle;
-		fprintf(out, "**** %lld bytes at %p from %s ****\n",
-			pHdr->iSize, &pHdr[1], pHdr->nTitle ? z : "???");
-		if (pHdr->nBacktrace) {
-			fflush(out);
-			pBt = (void **)pHdr;
-			pBt -= pHdr->nBacktraceSlots;
-			backtrace_symbols_fd(pBt, pHdr->nBacktrace,
-					     fileno(out));
-			fprintf(out, "\n");
-		}
-	}
-	fprintf(out, "COUNTS:\n");
-	for (i = 0; i < NCSIZE - 1; i++) {
-		if (mem.nAlloc[i]) {
-			fprintf(out, "   %5d: %10d %10d %10d\n",
-				i * 8, mem.nAlloc[i], mem.nCurrent[i],
-				mem.mxCurrent[i]);
-		}
-	}
-	if (mem.nAlloc[NCSIZE - 1]) {
-		fprintf(out, "   %5d: %10d %10d %10d\n",
-			NCSIZE * 8 - 8, mem.nAlloc[NCSIZE - 1],
-			mem.nCurrent[NCSIZE - 1], mem.mxCurrent[NCSIZE - 1]);
-	}
-	fclose(out);
-}
-
-/*
- * Return the number of times sqlite3MemMalloc() has been called.
- */
-int
-sqlite3MemdebugMallocCount()
-{
-	int i;
-	int nTotal = 0;
-	for (i = 0; i < NCSIZE; i++) {
-		nTotal += mem.nAlloc[i];
-	}
-	return nTotal;
-}
-
-#endif				/* SQLITE_MEMDEBUG */
diff --git a/src/box/sql/mem3.c b/src/box/sql/mem3.c
deleted file mode 100644
index b9f0b8c..0000000
--- a/src/box/sql/mem3.c
+++ /dev/null
@@ -1,767 +0,0 @@
-/*
- * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * 1. Redistributions of source code must retain the above
- *    copyright notice, this list of conditions and the
- *    following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
- * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- * This file contains the C functions that implement a memory
- * allocation subsystem for use by SQLite.
- *
- * This version of the memory allocation subsystem omits all
- * use of malloc(). The SQLite user supplies a block of memory
- * before calling sqlite3_initialize() from which allocations
- * are made and returned by the xMalloc() and xRealloc()
- * implementations. Once sqlite3_initialize() has been called,
- * the amount of memory available to SQLite is fixed and cannot
- * be changed.
- *
- * This version of the memory allocation subsystem is included
- * in the build only if SQLITE_ENABLE_MEMSYS3 is defined.
- */
-#include "sqliteInt.h"
-
-/*
- * This version of the memory allocator is only built into the library
- * SQLITE_ENABLE_MEMSYS3 is defined. Defining this symbol does not
- * mean that the library will use a memory-pool by default, just that
- * it is available. The mempool allocator is activated by calling
- * sqlite3_config().
- */
-#ifdef SQLITE_ENABLE_MEMSYS3
-
-/*
- * Maximum size (in Mem3Blocks) of a "small" chunk.
- */
-#define MX_SMALL 10
-
-/*
- * Number of freelist hash slots
- */
-#define N_HASH  61
-
-/*
- * A memory allocation (also called a "chunk") consists of two or
- * more blocks where each block is 8 bytes.  The first 8 bytes are
- * a header that is not returned to the user.
- *
- * A chunk is two or more blocks that is either checked out or
- * free.  The first block has format u.hdr.  u.hdr.size4x is 4 times the
- * size of the allocation in blocks if the allocation is free.
- * The u.hdr.size4x&1 bit is true if the chunk is checked out and
- * false if the chunk is on the freelist.  The u.hdr.size4x&2 bit
- * is true if the previous chunk is checked out and false if the
- * previous chunk is free.  The u.hdr.prevSize field is the size of
- * the previous chunk in blocks if the previous chunk is on the
- * freelist. If the previous chunk is checked out, then
- * u.hdr.prevSize can be part of the data for that chunk and should
- * not be read or written.
- *
- * We often identify a chunk by its index in mem3.aPool[].  When
- * this is done, the chunk index refers to the second block of
- * the chunk.  In this way, the first chunk has an index of 1.
- * A chunk index of 0 means "no such chunk" and is the equivalent
- * of a NULL pointer.
- *
- * The second block of free chunks is of the form u.list.  The
- * two fields form a double-linked list of chunks of related sizes.
- * Pointers to the head of the list are stored in mem3.aiSmall[]
- * for smaller chunks and mem3.aiHash[] for larger chunks.
- *
- * The second block of a chunk is user data if the chunk is checked
- * out.  If a chunk is checked out, the user data may extend into
- * the u.hdr.prevSize value of the following chunk.
- */
-typedef struct Mem3Block Mem3Block;
-struct Mem3Block {
-	union {
-		struct {
-			u32 prevSize;	/* Size of previous chunk in Mem3Block elements */
-			u32 size4x;	/* 4x the size of current chunk in Mem3Block elements */
-		} hdr;
-		struct {
-			u32 next;	/* Index in mem3.aPool[] of next free chunk */
-			u32 prev;	/* Index in mem3.aPool[] of previous free chunk */
-		} list;
-	} u;
-};
-
-/*
- * All of the static variables used by this module are collected
- * into a single structure named "mem3".  This is to keep the
- * static variables organized and to reduce namespace pollution
- * when this module is combined with other in the amalgamation.
- */
-static SQLITE_WSD struct Mem3Global {
-	/*
-	 * Memory available for allocation. nPool is the size of the array
-	 * (in Mem3Blocks) pointed to by aPool less 2.
-	 */
-	u32 nPool;
-	Mem3Block *aPool;
-
-	/*
-	 * True if we are evaluating an out-of-memory callback.
-	 */
-	int alarmBusy;
-
-	/*
-	 * Mutex to control access to the memory allocation subsystem.
-	 */
-	sqlite3_mutex *mutex;
-
-	/*
-	 * The minimum amount of free space that we have seen.
-	 */
-	u32 mnMaster;
-
-	/*
-	 * iMaster is the index of the master chunk.  Most new allocations
-	 * occur off of this chunk.  szMaster is the size (in Mem3Blocks)
-	 * of the current master.  iMaster is 0 if there is not master chunk.
-	 * The master chunk is not in either the aiHash[] or aiSmall[].
-	 */
-	u32 iMaster;
-	u32 szMaster;
-
-	/*
-	 * Array of lists of free blocks according to the block size
-	 * for smaller chunks, or a hash on the block size for larger
-	 * chunks.
-	 */
-	u32 aiSmall[MX_SMALL - 1];	/* For sizes 2 through MX_SMALL, inclusive */
-	u32 aiHash[N_HASH];	/* For sizes MX_SMALL+1 and larger */
-} mem3 = {
-97535575};
-
-#define mem3 GLOBAL(struct Mem3Global, mem3)
-
-/*
- * Unlink the chunk at mem3.aPool[i] from list it is currently
- * on.  *pRoot is the list that i is a member of.
- */
-static void
-memsys3UnlinkFromList(u32 i, u32 * pRoot)
-{
-	u32 next = mem3.aPool[i].u.list.next;
-	u32 prev = mem3.aPool[i].u.list.prev;
-	assert(sqlite3_mutex_held(mem3.mutex));
-	if (prev == 0) {
-		*pRoot = next;
-	} else {
-		mem3.aPool[prev].u.list.next = next;
-	}
-	if (next) {
-		mem3.aPool[next].u.list.prev = prev;
-	}
-	mem3.aPool[i].u.list.next = 0;
-	mem3.aPool[i].u.list.prev = 0;
-}
-
-/*
- * Unlink the chunk at index i from
- * whatever list is currently a member of.
- */
-static void
-memsys3Unlink(u32 i)
-{
-	u32 size, hash;
-	assert(sqlite3_mutex_held(mem3.mutex));
-	assert((mem3.aPool[i - 1].u.hdr.size4x & 1) == 0);
-	assert(i >= 1);
-	size = mem3.aPool[i - 1].u.hdr.size4x / 4;
-	assert(size == mem3.aPool[i + size - 1].u.hdr.prevSize);
-	assert(size >= 2);
-	if (size <= MX_SMALL) {
-		memsys3UnlinkFromList(i, &mem3.aiSmall[size - 2]);
-	} else {
-		hash = size % N_HASH;
-		memsys3UnlinkFromList(i, &mem3.aiHash[hash]);
-	}
-}
-
-/*
- * Link the chunk at mem3.aPool[i] so that is on the list rooted
- * at *pRoot.
- */
-static void
-memsys3LinkIntoList(u32 i, u32 * pRoot)
-{
-	assert(sqlite3_mutex_held(mem3.mutex));
-	mem3.aPool[i].u.list.next = *pRoot;
-	mem3.aPool[i].u.list.prev = 0;
-	if (*pRoot) {
-		mem3.aPool[*pRoot].u.list.prev = i;
-	}
-	*pRoot = i;
-}
-
-/*
- * Link the chunk at index i into either the appropriate
- * small chunk list, or into the large chunk hash table.
- */
-static void
-memsys3Link(u32 i)
-{
-	u32 size, hash;
-	assert(sqlite3_mutex_held(mem3.mutex));
-	assert(i >= 1);
-	assert((mem3.aPool[i - 1].u.hdr.size4x & 1) == 0);
-	size = mem3.aPool[i - 1].u.hdr.size4x / 4;
-	assert(size == mem3.aPool[i + size - 1].u.hdr.prevSize);
-	assert(size >= 2);
-	if (size <= MX_SMALL) {
-		memsys3LinkIntoList(i, &mem3.aiSmall[size - 2]);
-	} else {
-		hash = size % N_HASH;
-		memsys3LinkIntoList(i, &mem3.aiHash[hash]);
-	}
-}
-
-/*
- * If the STATIC_MEM mutex is not already held, obtain it now. The mutex
- * will already be held (obtained by code in malloc.c) if
- * sqlite3GlobalConfig.bMemStat is true.
- */
-static void
-memsys3Enter(void)
-{
-	if (sqlite3GlobalConfig.bMemstat == 0 && mem3.mutex == 0) {
-		mem3.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
-	}
-	sqlite3_mutex_enter(mem3.mutex);
-}
-
-static void
-memsys3Leave(void)
-{
-	sqlite3_mutex_leave(mem3.mutex);
-}
-
-/*
- * Called when we are unable to satisfy an allocation of nBytes.
- */
-static void
-memsys3OutOfMemory(int nByte)
-{
-	if (!mem3.alarmBusy) {
-		mem3.alarmBusy = 1;
-		assert(sqlite3_mutex_held(mem3.mutex));
-		sqlite3_mutex_leave(mem3.mutex);
-		sqlite3_release_memory(nByte);
-		sqlite3_mutex_enter(mem3.mutex);
-		mem3.alarmBusy = 0;
-	}
-}
-
-/*
- * Chunk i is a free chunk that has been unlinked.  Adjust its
- * size parameters for check-out and return a pointer to the
- * user portion of the chunk.
- */
-static void *
-memsys3Checkout(u32 i, u32 nBlock)
-{
-	u32 x;
-	assert(sqlite3_mutex_held(mem3.mutex));
-	assert(i >= 1);
-	assert(mem3.aPool[i - 1].u.hdr.size4x / 4 == nBlock);
-	assert(mem3.aPool[i + nBlock - 1].u.hdr.prevSize == nBlock);
-	x = mem3.aPool[i - 1].u.hdr.size4x;
-	mem3.aPool[i - 1].u.hdr.size4x = nBlock * 4 | 1 | (x & 2);
-	mem3.aPool[i + nBlock - 1].u.hdr.prevSize = nBlock;
-	mem3.aPool[i + nBlock - 1].u.hdr.size4x |= 2;
-	return &mem3.aPool[i];
-}
-
-/*
- * Carve a piece off of the end of the mem3.iMaster free chunk.
- * Return a pointer to the new allocation.  Or, if the master chunk
- * is not large enough, return 0.
- */
-static void *
-memsys3FromMaster(u32 nBlock)
-{
-	assert(sqlite3_mutex_held(mem3.mutex));
-	assert(mem3.szMaster >= nBlock);
-	if (nBlock >= mem3.szMaster - 1) {
-		/* Use the entire master */
-		void *p = memsys3Checkout(mem3.iMaster, mem3.szMaster);
-		mem3.iMaster = 0;
-		mem3.szMaster = 0;
-		mem3.mnMaster = 0;
-		return p;
-	} else {
-		/* Split the master block.  Return the tail. */
-		u32 newi, x;
-		newi = mem3.iMaster + mem3.szMaster - nBlock;
-		assert(newi > mem3.iMaster + 1);
-		mem3.aPool[mem3.iMaster + mem3.szMaster - 1].u.hdr.prevSize =
-		    nBlock;
-		mem3.aPool[mem3.iMaster + mem3.szMaster - 1].u.hdr.size4x |= 2;
-		mem3.aPool[newi - 1].u.hdr.size4x = nBlock * 4 + 1;
-		mem3.szMaster -= nBlock;
-		mem3.aPool[newi - 1].u.hdr.prevSize = mem3.szMaster;
-		x = mem3.aPool[mem3.iMaster - 1].u.hdr.size4x & 2;
-		mem3.aPool[mem3.iMaster - 1].u.hdr.size4x =
-		    mem3.szMaster * 4 | x;
-		if (mem3.szMaster < mem3.mnMaster) {
-			mem3.mnMaster = mem3.szMaster;
-		}
-		return (void *)&mem3.aPool[newi];
-	}
-}
-
-/*
- * *pRoot is the head of a list of free chunks of the same size
- * or same size hash.  In other words, *pRoot is an entry in either
- * mem3.aiSmall[] or mem3.aiHash[].
- *
- * This routine examines all entries on the given list and tries
- * to coalesce each entries with adjacent free chunks.
- *
- * If it sees a chunk that is larger than mem3.iMaster, it replaces
- * the current mem3.iMaster with the new larger chunk.  In order for
- * this mem3.iMaster replacement to work, the master chunk must be
- * linked into the hash tables.  That is not the normal state of
- * affairs, of course.  The calling routine must link the master
- * chunk before invoking this routine, then must unlink the (possibly
- * changed) master chunk once this routine has finished.
- */
-static void
-memsys3Merge(u32 * pRoot)
-{
-	u32 iNext, prev, size, i, x;
-
-	assert(sqlite3_mutex_held(mem3.mutex));
-	for (i = *pRoot; i > 0; i = iNext) {
-		iNext = mem3.aPool[i].u.list.next;
-		size = mem3.aPool[i - 1].u.hdr.size4x;
-		assert((size & 1) == 0);
-		if ((size & 2) == 0) {
-			memsys3UnlinkFromList(i, pRoot);
-			assert(i > mem3.aPool[i - 1].u.hdr.prevSize);
-			prev = i - mem3.aPool[i - 1].u.hdr.prevSize;
-			if (prev == iNext) {
-				iNext = mem3.aPool[prev].u.list.next;
-			}
-			memsys3Unlink(prev);
-			size = i + size / 4 - prev;
-			x = mem3.aPool[prev - 1].u.hdr.size4x & 2;
-			mem3.aPool[prev - 1].u.hdr.size4x = size * 4 | x;
-			mem3.aPool[prev + size - 1].u.hdr.prevSize = size;
-			memsys3Link(prev);
-			i = prev;
-		} else {
-			size /= 4;
-		}
-		if (size > mem3.szMaster) {
-			mem3.iMaster = i;
-			mem3.szMaster = size;
-		}
-	}
-}
-
-/*
- * Return a block of memory of at least nBytes in size.
- * Return NULL if unable.
- *
- * This function assumes that the necessary mutexes, if any, are
- * already held by the caller. Hence "Unsafe".
- */
-static void *
-memsys3MallocUnsafe(int nByte)
-{
-	u32 i;
-	u32 nBlock;
-	u32 toFree;
-
-	assert(sqlite3_mutex_held(mem3.mutex));
-	assert(sizeof(Mem3Block) == 8);
-	if (nByte <= 12) {
-		nBlock = 2;
-	} else {
-		nBlock = (nByte + 11) / 8;
-	}
-	assert(nBlock >= 2);
-
-	/* STEP 1:
-	 * Look for an entry of the correct size in either the small
-	 * chunk table or in the large chunk hash table.  This is
-	 * successful most of the time (about 9 times out of 10).
-	 */
-	if (nBlock <= MX_SMALL) {
-		i = mem3.aiSmall[nBlock - 2];
-		if (i > 0) {
-			memsys3UnlinkFromList(i, &mem3.aiSmall[nBlock - 2]);
-			return memsys3Checkout(i, nBlock);
-		}
-	} else {
-		int hash = nBlock % N_HASH;
-		for (i = mem3.aiHash[hash]; i > 0;
-		     i = mem3.aPool[i].u.list.next) {
-			if (mem3.aPool[i - 1].u.hdr.size4x / 4 == nBlock) {
-				memsys3UnlinkFromList(i, &mem3.aiHash[hash]);
-				return memsys3Checkout(i, nBlock);
-			}
-		}
-	}
-
-	/* STEP 2:
-	 * Try to satisfy the allocation by carving a piece off of the end
-	 * of the master chunk.  This step usually works if step 1 fails.
-	 */
-	if (mem3.szMaster >= nBlock) {
-		return memsys3FromMaster(nBlock);
-	}
-
-	/* STEP 3:
-	 * Loop through the entire memory pool.  Coalesce adjacent free
-	 * chunks.  Recompute the master chunk as the largest free chunk.
-	 * Then try again to satisfy the allocation by carving a piece off
-	 * of the end of the master chunk.  This step happens very
-	 * rarely (we hope!)
-	 */
-	for (toFree = nBlock * 16; toFree < (mem3.nPool * 16); toFree *= 2) {
-		memsys3OutOfMemory(toFree);
-		if (mem3.iMaster) {
-			memsys3Link(mem3.iMaster);
-			mem3.iMaster = 0;
-			mem3.szMaster = 0;
-		}
-		for (i = 0; i < N_HASH; i++) {
-			memsys3Merge(&mem3.aiHash[i]);
-		}
-		for (i = 0; i < MX_SMALL - 1; i++) {
-			memsys3Merge(&mem3.aiSmall[i]);
-		}
-		if (mem3.szMaster) {
-			memsys3Unlink(mem3.iMaster);
-			if (mem3.szMaster >= nBlock) {
-				return memsys3FromMaster(nBlock);
-			}
-		}
-	}
-
-	/* If none of the above worked, then we fail. */
-	return 0;
-}
-
-/*
- * Free an outstanding memory allocation.
- *
- * This function assumes that the necessary mutexes, if any, are
- * already held by the caller. Hence "Unsafe".
- */
-static void
-memsys3FreeUnsafe(void *pOld)
-{
-	Mem3Block *p = (Mem3Block *) pOld;
-	int i;
-	u32 size, x;
-	assert(sqlite3_mutex_held(mem3.mutex));
-	assert(p > mem3.aPool && p < &mem3.aPool[mem3.nPool]);
-	i = p - mem3.aPool;
-	assert((mem3.aPool[i - 1].u.hdr.size4x & 1) == 1);
-	size = mem3.aPool[i - 1].u.hdr.size4x / 4;
-	assert(i + size <= mem3.nPool + 1);
-	mem3.aPool[i - 1].u.hdr.size4x &= ~1;
-	mem3.aPool[i + size - 1].u.hdr.prevSize = size;
-	mem3.aPool[i + size - 1].u.hdr.size4x &= ~2;
-	memsys3Link(i);
-
-	/* Try to expand the master using the newly freed chunk */
-	if (mem3.iMaster) {
-		while ((mem3.aPool[mem3.iMaster - 1].u.hdr.size4x & 2) == 0) {
-			size = mem3.aPool[mem3.iMaster - 1].u.hdr.prevSize;
-			mem3.iMaster -= size;
-			mem3.szMaster += size;
-			memsys3Unlink(mem3.iMaster);
-			x = mem3.aPool[mem3.iMaster - 1].u.hdr.size4x & 2;
-			mem3.aPool[mem3.iMaster - 1].u.hdr.size4x =
-			    mem3.szMaster * 4 | x;
-			mem3.aPool[mem3.iMaster + mem3.szMaster -
-				   1].u.hdr.prevSize = mem3.szMaster;
-		}
-		x = mem3.aPool[mem3.iMaster - 1].u.hdr.size4x & 2;
-		while ((mem3.aPool[mem3.iMaster + mem3.szMaster - 1].u.hdr.
-			size4x & 1) == 0) {
-			memsys3Unlink(mem3.iMaster + mem3.szMaster);
-			mem3.szMaster +=
-			    mem3.aPool[mem3.iMaster + mem3.szMaster -
-				       1].u.hdr.size4x / 4;
-			mem3.aPool[mem3.iMaster - 1].u.hdr.size4x =
-			    mem3.szMaster * 4 | x;
-			mem3.aPool[mem3.iMaster + mem3.szMaster -
-				   1].u.hdr.prevSize = mem3.szMaster;
-		}
-	}
-}
-
-/*
- * Return the size of an outstanding allocation, in bytes.  The
- * size returned omits the 8-byte header overhead.  This only
- * works for chunks that are currently checked out.
- */
-static int
-memsys3Size(void *p)
-{
-	Mem3Block *pBlock;
-	assert(p != 0);
-	pBlock = (Mem3Block *) p;
-	assert((pBlock[-1].u.hdr.size4x & 1) != 0);
-	return (pBlock[-1].u.hdr.size4x & ~3) * 2 - 4;
-}
-
-/*
- * Round up a request size to the next valid allocation size.
- */
-static int
-memsys3Roundup(int n)
-{
-	if (n <= 12) {
-		return 12;
-	} else {
-		return ((n + 11) & ~7) - 4;
-	}
-}
-
-/*
- * Allocate nBytes of memory.
- */
-static void *
-memsys3Malloc(int nBytes)
-{
-	sqlite3_int64 *p;
-	assert(nBytes > 0);	/* malloc.c filters out 0 byte requests */
-	memsys3Enter();
-	p = memsys3MallocUnsafe(nBytes);
-	memsys3Leave();
-	return (void *)p;
-}
-
-/*
- * Free memory.
- */
-static void
-memsys3Free(void *pPrior)
-{
-	assert(pPrior);
-	memsys3Enter();
-	memsys3FreeUnsafe(pPrior);
-	memsys3Leave();
-}
-
-/*
- * Change the size of an existing memory allocation
- */
-static void *
-memsys3Realloc(void *pPrior, int nBytes)
-{
-	int nOld;
-	void *p;
-	if (pPrior == 0) {
-		return sqlite3_malloc(nBytes);
-	}
-	if (nBytes <= 0) {
-		sqlite3_free(pPrior);
-		return 0;
-	}
-	nOld = memsys3Size(pPrior);
-	if (nBytes <= nOld && nBytes >= nOld - 128) {
-		return pPrior;
-	}
-	memsys3Enter();
-	p = memsys3MallocUnsafe(nBytes);
-	if (p) {
-		if (nOld < nBytes) {
-			memcpy(p, pPrior, nOld);
-		} else {
-			memcpy(p, pPrior, nBytes);
-		}
-		memsys3FreeUnsafe(pPrior);
-	}
-	memsys3Leave();
-	return p;
-}
-
-/*
- * Initialize this module.
- */
-static int
-memsys3Init(void *NotUsed)
-{
-	UNUSED_PARAMETER(NotUsed);
-	if (!sqlite3GlobalConfig.pHeap) {
-		return SQLITE_ERROR;
-	}
-
-	/* Store a pointer to the memory block in global structure mem3. */
-	assert(sizeof(Mem3Block) == 8);
-	mem3.aPool = (Mem3Block *) sqlite3GlobalConfig.pHeap;
-	mem3.nPool = (sqlite3GlobalConfig.nHeap / sizeof(Mem3Block)) - 2;
-
-	/* Initialize the master block. */
-	mem3.szMaster = mem3.nPool;
-	mem3.mnMaster = mem3.szMaster;
-	mem3.iMaster = 1;
-	mem3.aPool[0].u.hdr.size4x = (mem3.szMaster << 2) + 2;
-	mem3.aPool[mem3.nPool].u.hdr.prevSize = mem3.nPool;
-	mem3.aPool[mem3.nPool].u.hdr.size4x = 1;
-
-	return SQLITE_OK;
-}
-
-/*
- * Deinitialize this module.
- */
-static void
-memsys3Shutdown(void *NotUsed)
-{
-	UNUSED_PARAMETER(NotUsed);
-	mem3.mutex = 0;
-	return;
-}
-
-/*
- * Open the file indicated and write a log of all unfreed memory
- * allocations into that log.
- */
-void
-sqlite3Memsys3Dump(const char *zFilename)
-{
-#ifdef SQLITE_DEBUG
-	FILE *out;
-	u32 i, j;
-	u32 size;
-	if (zFilename == 0 || zFilename[0] == 0) {
-		out = stdout;
-	} else {
-		out = fopen(zFilename, "w");
-		if (out == 0) {
-			fprintf(stderr,
-				"** Unable to output memory debug output log: %s **\n",
-				zFilename);
-			return;
-		}
-	}
-	memsys3Enter();
-	fprintf(out, "CHUNKS:\n");
-	for (i = 1; i <= mem3.nPool; i += size / 4) {
-		size = mem3.aPool[i - 1].u.hdr.size4x;
-		if (size / 4 <= 1) {
-			fprintf(out, "%p size error\n", &mem3.aPool[i]);
-			assert(0);
-			break;
-		}
-		if ((size & 1) == 0
-		    && mem3.aPool[i + size / 4 - 1].u.hdr.prevSize !=
-		    size / 4) {
-			fprintf(out, "%p tail size does not match\n",
-				&mem3.aPool[i]);
-			assert(0);
-			break;
-		}
-		if (((mem3.aPool[i + size / 4 - 1].u.hdr.size4x & 2) >> 1) !=
-		    (size & 1)) {
-			fprintf(out, "%p tail checkout bit is incorrect\n",
-				&mem3.aPool[i]);
-			assert(0);
-			break;
-		}
-		if (size & 1) {
-			fprintf(out, "%p %6d bytes checked out\n",
-				&mem3.aPool[i], (size / 4) * 8 - 8);
-		} else {
-			fprintf(out, "%p %6d bytes free%s\n", &mem3.aPool[i],
-				(size / 4) * 8 - 8,
-				i == mem3.iMaster ? " **master**" : "");
-		}
-	}
-	for (i = 0; i < MX_SMALL - 1; i++) {
-		if (mem3.aiSmall[i] == 0)
-			continue;
-		fprintf(out, "small(%2d):", i);
-		for (j = mem3.aiSmall[i]; j > 0; j = mem3.aPool[j].u.list.next) {
-			fprintf(out, " %p(%d)", &mem3.aPool[j],
-				(mem3.aPool[j - 1].u.hdr.size4x / 4) * 8 - 8);
-		}
-		fprintf(out, "\n");
-	}
-	for (i = 0; i < N_HASH; i++) {
-		if (mem3.aiHash[i] == 0)
-			continue;
-		fprintf(out, "hash(%2d):", i);
-		for (j = mem3.aiHash[i]; j > 0; j = mem3.aPool[j].u.list.next) {
-			fprintf(out, " %p(%d)", &mem3.aPool[j],
-				(mem3.aPool[j - 1].u.hdr.size4x / 4) * 8 - 8);
-		}
-		fprintf(out, "\n");
-	}
-	fprintf(out, "master=%d\n", mem3.iMaster);
-	fprintf(out, "nowUsed=%d\n", mem3.nPool * 8 - mem3.szMaster * 8);
-	fprintf(out, "mxUsed=%d\n", mem3.nPool * 8 - mem3.mnMaster * 8);
-	sqlite3_mutex_leave(mem3.mutex);
-	if (out == stdout) {
-		fflush(stdout);
-	} else {
-		fclose(out);
-	}
-#else
-	UNUSED_PARAMETER(zFilename);
-#endif
-}
-
-/*
- * This routine is the only routine in this file with external
- * linkage.
- *
- * Populate the low-level memory allocation function pointers in
- * sqlite3GlobalConfig.m with pointers to the routines in this file. The
- * arguments specify the block of memory to manage.
- *
- * This routine is only called by sqlite3_config(), and therefore
- * is not required to be threadsafe (it is not).
- */
-const sqlite3_mem_methods *
-sqlite3MemGetMemsys3(void)
-{
-	static const sqlite3_mem_methods mempoolMethods = {
-		memsys3Malloc,
-		memsys3Free,
-		memsys3Realloc,
-		memsys3Size,
-		memsys3Roundup,
-		memsys3Init,
-		memsys3Shutdown,
-		0
-	};
-	return &mempoolMethods;
-}
-
-#endif				/* SQLITE_ENABLE_MEMSYS3 */
diff --git a/src/box/sql/mem5.c b/src/box/sql/mem5.c
deleted file mode 100644
index 73adde0..0000000
--- a/src/box/sql/mem5.c
+++ /dev/null
@@ -1,648 +0,0 @@
-/*
- * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * 1. Redistributions of source code must retain the above
- *    copyright notice, this list of conditions and the
- *    following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
- * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- * This file contains the C functions that implement a memory
- * allocation subsystem for use by SQLite.
- *
- * This version of the memory allocation subsystem omits all
- * use of malloc(). The application gives SQLite a block of memory
- * before calling sqlite3_initialize() from which allocations
- * are made and returned by the xMalloc() and xRealloc()
- * implementations. Once sqlite3_initialize() has been called,
- * the amount of memory available to SQLite is fixed and cannot
- * be changed.
- *
- * This version of the memory allocation subsystem is included
- * in the build only if SQLITE_ENABLE_MEMSYS5 is defined.
- *
- * This memory allocator uses the following algorithm:
- *
- *   1.  All memory allocation sizes are rounded up to a power of 2.
- *
- *   2.  If two adjacent free blocks are the halves of a larger block,
- *       then the two blocks are coalesced into the single larger block.
- *
- *   3.  New memory is allocated from the first available free block.
- *
- * This algorithm is described in: J. M. Robson. "Bounds for Some Functions
- * Concerning Dynamic Storage Allocation". Journal of the Association for
- * Computing Machinery, Volume 21, Number 8, July 1974, pages 491-499.
- *
- * Let n be the size of the largest allocation divided by the minimum
- * allocation size (after rounding all sizes up to a power of 2.)  Let M
- * be the maximum amount of memory ever outstanding at one time.  Let
- * N be the total amount of memory available for allocation.  Robson
- * proved that this memory allocator will never breakdown due to
- * fragmentation as long as the following constraint holds:
- *
- *      N >=  M*(1 + log2(n)/2) - n + 1
- *
- * The sqlite3_status() logic tracks the maximum values of n and M so
- * that an application can, at any time, verify this constraint.
- */
-#include "sqliteInt.h"
-
-/*
- * This version of the memory allocator is used only when
- * SQLITE_ENABLE_MEMSYS5 is defined.
- */
-#ifdef SQLITE_ENABLE_MEMSYS5
-
-/*
- * A minimum allocation is an instance of the following structure.
- * Larger allocations are an array of these structures where the
- * size of the array is a power of 2.
- *
- * The size of this object must be a power of two.  That fact is
- * verified in memsys5Init().
- */
-typedef struct Mem5Link Mem5Link;
-struct Mem5Link {
-	int next;		/* Index of next free chunk */
-	int prev;		/* Index of previous free chunk */
-};
-
-/*
- * Maximum size of any allocation is ((1<<LOGMAX)*mem5.szAtom). Since
- * mem5.szAtom is always at least 8 and 32-bit integers are used,
- * it is not actually possible to reach this limit.
- */
-#define LOGMAX 30
-
-/*
- * Masks used for mem5.aCtrl[] elements.
- */
-#define CTRL_LOGSIZE  0x1f	/* Log2 Size of this block */
-#define CTRL_FREE     0x20	/* True if not checked out */
-
-/*
- * All of the static variables used by this module are collected
- * into a single structure named "mem5".  This is to keep the
- * static variables organized and to reduce namespace pollution
- * when this module is combined with other in the amalgamation.
- */
-static SQLITE_WSD struct Mem5Global {
-	/*
-	 * Memory available for allocation
-	 */
-	int szAtom;		/* Smallest possible allocation in bytes */
-	int nBlock;		/* Number of szAtom sized blocks in zPool */
-	u8 *zPool;		/* Memory available to be allocated */
-
-	/*
-	 * Mutex to control access to the memory allocation subsystem.
-	 */
-	sqlite3_mutex *mutex;
-
-#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
-	/*
-	 * Performance statistics
-	 */
-	u64 nAlloc;		/* Total number of calls to malloc */
-	u64 totalAlloc;		/* Total of all malloc calls - includes internal frag */
-	u64 totalExcess;	/* Total internal fragmentation */
-	u32 currentOut;		/* Current checkout, including internal fragmentation */
-	u32 currentCount;	/* Current number of distinct checkouts */
-	u32 maxOut;		/* Maximum instantaneous currentOut */
-	u32 maxCount;		/* Maximum instantaneous currentCount */
-	u32 maxRequest;		/* Largest allocation (exclusive of internal frag) */
-#endif
-
-	/*
-	 * Lists of free blocks.  aiFreelist[0] is a list of free blocks of
-	 * size mem5.szAtom.  aiFreelist[1] holds blocks of size szAtom*2.
-	 * aiFreelist[2] holds free blocks of size szAtom*4.  And so forth.
-	 */
-	int aiFreelist[LOGMAX + 1];
-
-	/*
-	 * Space for tracking which blocks are checked out and the size
-	 * of each block.  One byte per block.
-	 */
-	u8 *aCtrl;
-
-} mem5;
-
-/*
- * Access the static variable through a macro for SQLITE_OMIT_WSD.
- */
-#define mem5 GLOBAL(struct Mem5Global, mem5)
-
-/*
- * Assuming mem5.zPool is divided up into an array of Mem5Link
- * structures, return a pointer to the idx-th such link.
- */
-#define MEM5LINK(idx) ((Mem5Link *)(&mem5.zPool[(idx)*mem5.szAtom]))
-
-/*
- * Unlink the chunk at mem5.aPool[i] from list it is currently
- * on.  It should be found on mem5.aiFreelist[iLogsize].
- */
-static void
-memsys5Unlink(int i, int iLogsize)
-{
-	int next, prev;
-	assert(i >= 0 && i < mem5.nBlock);
-	assert(iLogsize >= 0 && iLogsize <= LOGMAX);
-	assert((mem5.aCtrl[i] & CTRL_LOGSIZE) == iLogsize);
-
-	next = MEM5LINK(i)->next;
-	prev = MEM5LINK(i)->prev;
-	if (prev < 0) {
-		mem5.aiFreelist[iLogsize] = next;
-	} else {
-		MEM5LINK(prev)->next = next;
-	}
-	if (next >= 0) {
-		MEM5LINK(next)->prev = prev;
-	}
-}
-
-/*
- * Link the chunk at mem5.aPool[i] so that is on the iLogsize
- * free list.
- */
-static void
-memsys5Link(int i, int iLogsize)
-{
-	int x;
-	assert(sqlite3_mutex_held(mem5.mutex));
-	assert(i >= 0 && i < mem5.nBlock);
-	assert(iLogsize >= 0 && iLogsize <= LOGMAX);
-	assert((mem5.aCtrl[i] & CTRL_LOGSIZE) == iLogsize);
-
-	x = MEM5LINK(i)->next = mem5.aiFreelist[iLogsize];
-	MEM5LINK(i)->prev = -1;
-	if (x >= 0) {
-		assert(x < mem5.nBlock);
-		MEM5LINK(x)->prev = i;
-	}
-	mem5.aiFreelist[iLogsize] = i;
-}
-
-/*
- * Obtain or release the mutex needed to access global data structures.
- */
-static void
-memsys5Enter(void)
-{
-	sqlite3_mutex_enter(mem5.mutex);
-}
-
-static void
-memsys5Leave(void)
-{
-	sqlite3_mutex_leave(mem5.mutex);
-}
-
-/*
- * Return the size of an outstanding allocation, in bytes.
- * This only works for chunks that are currently checked out.
- */
-static int
-memsys5Size(void *p)
-{
-	int iSize, i;
-	assert(p != 0);
-	i = (int)(((u8 *) p - mem5.zPool) / mem5.szAtom);
-	assert(i >= 0 && i < mem5.nBlock);
-	iSize = mem5.szAtom * (1 << (mem5.aCtrl[i] & CTRL_LOGSIZE));
-	return iSize;
-}
-
-/*
- * Return a block of memory of at least nBytes in size.
- * Return NULL if unable.  Return NULL if nBytes==0.
- *
- * The caller guarantees that nByte is positive.
- *
- * The caller has obtained a mutex prior to invoking this
- * routine so there is never any chance that two or more
- * threads can be in this routine at the same time.
- */
-static void *
-memsys5MallocUnsafe(int nByte)
-{
-	int i;			/* Index of a mem5.aPool[] slot */
-	int iBin;		/* Index into mem5.aiFreelist[] */
-	int iFullSz;		/* Size of allocation rounded up to power of 2 */
-	int iLogsize;		/* Log2 of iFullSz/POW2_MIN */
-
-	/* nByte must be a positive */
-	assert(nByte > 0);
-
-	/* No more than 1GiB per allocation */
-	if (nByte > 0x40000000)
-		return 0;
-
-#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
-	/* Keep track of the maximum allocation request.  Even unfulfilled
-	 * requests are counted
-	 */
-	if ((u32) nByte > mem5.maxRequest) {
-		mem5.maxRequest = nByte;
-	}
-#endif
-
-	/* Round nByte up to the next valid power of two */
-	for (iFullSz = mem5.szAtom, iLogsize = 0; iFullSz < nByte;
-	     iFullSz *= 2, iLogsize++) {
-	}
-
-	/* Make sure mem5.aiFreelist[iLogsize] contains at least one free
-	 * block.  If not, then split a block of the next larger power of
-	 * two in order to create a new free block of size iLogsize.
-	 */
-	for (iBin = iLogsize; iBin <= LOGMAX && mem5.aiFreelist[iBin] < 0;
-	     iBin++) {
-	}
-	if (iBin > LOGMAX) {
-		testcase(sqlite3GlobalConfig.xLog != 0);
-		sqlite3_log(SQLITE_NOMEM, "failed to allocate %u bytes", nByte);
-		return 0;
-	}
-	i = mem5.aiFreelist[iBin];
-	memsys5Unlink(i, iBin);
-	while (iBin > iLogsize) {
-		int newSize;
-
-		iBin--;
-		newSize = 1 << iBin;
-		mem5.aCtrl[i + newSize] = CTRL_FREE | iBin;
-		memsys5Link(i + newSize, iBin);
-	}
-	mem5.aCtrl[i] = iLogsize;
-
-#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
-	/* Update allocator performance statistics. */
-	mem5.nAlloc++;
-	mem5.totalAlloc += iFullSz;
-	mem5.totalExcess += iFullSz - nByte;
-	mem5.currentCount++;
-	mem5.currentOut += iFullSz;
-	if (mem5.maxCount < mem5.currentCount)
-		mem5.maxCount = mem5.currentCount;
-	if (mem5.maxOut < mem5.currentOut)
-		mem5.maxOut = mem5.currentOut;
-#endif
-
-#ifdef SQLITE_DEBUG
-	/* Make sure the allocated memory does not assume that it is set to zero
-	 * or retains a value from a previous allocation
-	 */
-	memset(&mem5.zPool[i * mem5.szAtom], 0xAA, iFullSz);
-#endif
-
-	/* Return a pointer to the allocated memory. */
-	return (void *)&mem5.zPool[i * mem5.szAtom];
-}
-
-/*
- * Free an outstanding memory allocation.
- */
-static void
-memsys5FreeUnsafe(void *pOld)
-{
-	u32 size, iLogsize;
-	int iBlock;
-
-	/* Set iBlock to the index of the block pointed to by pOld in
-	 * the array of mem5.szAtom byte blocks pointed to by mem5.zPool.
-	 */
-	iBlock = (int)(((u8 *) pOld - mem5.zPool) / mem5.szAtom);
-
-	/* Check that the pointer pOld points to a valid, non-free block. */
-	assert(iBlock >= 0 && iBlock < mem5.nBlock);
-	assert(((u8 *) pOld - mem5.zPool) % mem5.szAtom == 0);
-	assert((mem5.aCtrl[iBlock] & CTRL_FREE) == 0);
-
-	iLogsize = mem5.aCtrl[iBlock] & CTRL_LOGSIZE;
-	size = 1 << iLogsize;
-	assert(iBlock + size - 1 < (u32) mem5.nBlock);
-
-	mem5.aCtrl[iBlock] |= CTRL_FREE;
-	mem5.aCtrl[iBlock + size - 1] |= CTRL_FREE;
-
-#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
-	assert(mem5.currentCount > 0);
-	assert(mem5.currentOut >= (size * mem5.szAtom));
-	mem5.currentCount--;
-	mem5.currentOut -= size * mem5.szAtom;
-	assert(mem5.currentOut > 0 || mem5.currentCount == 0);
-	assert(mem5.currentCount > 0 || mem5.currentOut == 0);
-#endif
-
-	mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
-	while (ALWAYS(iLogsize < LOGMAX)) {
-		int iBuddy;
-		if ((iBlock >> iLogsize) & 1) {
-			iBuddy = iBlock - size;
-			assert(iBuddy >= 0);
-		} else {
-			iBuddy = iBlock + size;
-			if (iBuddy >= mem5.nBlock)
-				break;
-		}
-		if (mem5.aCtrl[iBuddy] != (CTRL_FREE | iLogsize))
-			break;
-		memsys5Unlink(iBuddy, iLogsize);
-		iLogsize++;
-		if (iBuddy < iBlock) {
-			mem5.aCtrl[iBuddy] = CTRL_FREE | iLogsize;
-			mem5.aCtrl[iBlock] = 0;
-			iBlock = iBuddy;
-		} else {
-			mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
-			mem5.aCtrl[iBuddy] = 0;
-		}
-		size *= 2;
-	}
-
-#ifdef SQLITE_DEBUG
-	/* Overwrite freed memory with the 0x55 bit pattern to verify that it is
-	 * not used after being freed
-	 */
-	memset(&mem5.zPool[iBlock * mem5.szAtom], 0x55, size);
-#endif
-
-	memsys5Link(iBlock, iLogsize);
-}
-
-/*
- * Allocate nBytes of memory.
- */
-static void *
-memsys5Malloc(int nBytes)
-{
-	sqlite3_int64 *p = 0;
-	if (nBytes > 0) {
-		memsys5Enter();
-		p = memsys5MallocUnsafe(nBytes);
-		memsys5Leave();
-	}
-	return (void *)p;
-}
-
-/*
- * Free memory.
- *
- * The outer layer memory allocator prevents this routine from
- * being called with pPrior==0.
- */
-static void
-memsys5Free(void *pPrior)
-{
-	assert(pPrior != 0);
-	memsys5Enter();
-	memsys5FreeUnsafe(pPrior);
-	memsys5Leave();
-}
-
-/*
- * Change the size of an existing memory allocation.
- *
- * The outer layer memory allocator prevents this routine from
- * being called with pPrior==0.
- *
- * nBytes is always a value obtained from a prior call to
- * memsys5Round().  Hence nBytes is always a non-negative power
- * of two.  If nBytes==0 that means that an oversize allocation
- * (an allocation larger than 0x40000000) was requested and this
- * routine should return 0 without freeing pPrior.
- */
-static void *
-memsys5Realloc(void *pPrior, int nBytes)
-{
-	int nOld;
-	void *p;
-	assert(pPrior != 0);
-	assert((nBytes & (nBytes - 1)) == 0);	/* EV: R-46199-30249 */
-	assert(nBytes >= 0);
-	if (nBytes == 0) {
-		return 0;
-	}
-	nOld = memsys5Size(pPrior);
-	if (nBytes <= nOld) {
-		return pPrior;
-	}
-	p = memsys5Malloc(nBytes);
-	if (p) {
-		memcpy(p, pPrior, nOld);
-		memsys5Free(pPrior);
-	}
-	return p;
-}
-
-/*
- * Round up a request size to the next valid allocation size.  If
- * the allocation is too large to be handled by this allocation system,
- * return 0.
- *
- * All allocations must be a power of two and must be expressed by a
- * 32-bit signed integer.  Hence the largest allocation is 0x40000000
- * or 1073741824 bytes.
- */
-static int
-memsys5Roundup(int n)
-{
-	int iFullSz;
-	if (n > 0x40000000)
-		return 0;
-	for (iFullSz = mem5.szAtom; iFullSz < n; iFullSz *= 2) ;
-	return iFullSz;
-}
-
-/*
- * Return the ceiling of the logarithm base 2 of iValue.
- *
- * Examples:   memsys5Log(1) -> 0
- *             memsys5Log(2) -> 1
- *             memsys5Log(4) -> 2
- *             memsys5Log(5) -> 3
- *             memsys5Log(8) -> 3
- *             memsys5Log(9) -> 4
- */
-static int
-memsys5Log(int iValue)
-{
-	int iLog;
-	for (iLog = 0;
-	     (iLog < (int)((sizeof(int) * 8) - 1)) && (1 << iLog) < iValue;
-	     iLog++) ;
-	return iLog;
-}
-
-/*
- * Initialize the memory allocator.
- *
- * This routine is not threadsafe.  The caller must be holding a mutex
- * to prevent multiple threads from entering at the same time.
- */
-static int
-memsys5Init(void *NotUsed)
-{
-	int ii;			/* Loop counter */
-	int nByte;		/* Number of bytes of memory available to this allocator */
-	u8 *zByte;		/* Memory usable by this allocator */
-	int nMinLog;		/* Log base 2 of minimum allocation size in bytes */
-	int iOffset;		/* An offset into mem5.aCtrl[] */
-
-	UNUSED_PARAMETER(NotUsed);
-
-	/* For the purposes of this routine, disable the mutex */
-	mem5.mutex = 0;
-
-	/* The size of a Mem5Link object must be a power of two.  Verify that
-	 * this is case.
-	 */
-	assert((sizeof(Mem5Link) & (sizeof(Mem5Link) - 1)) == 0);
-
-	nByte = sqlite3GlobalConfig.nHeap;
-	zByte = (u8 *) sqlite3GlobalConfig.pHeap;
-	assert(zByte != 0);	/* sqlite3_config() does not allow otherwise */
-
-	/* boundaries on sqlite3GlobalConfig.mnReq are enforced in sqlite3_config() */
-	nMinLog = memsys5Log(sqlite3GlobalConfig.mnReq);
-	mem5.szAtom = (1 << nMinLog);
-	while ((int)sizeof(Mem5Link) > mem5.szAtom) {
-		mem5.szAtom = mem5.szAtom << 1;
-	}
-
-	mem5.nBlock = (nByte / (mem5.szAtom + sizeof(u8)));
-	mem5.zPool = zByte;
-	mem5.aCtrl = (u8 *) & mem5.zPool[mem5.nBlock * mem5.szAtom];
-
-	for (ii = 0; ii <= LOGMAX; ii++) {
-		mem5.aiFreelist[ii] = -1;
-	}
-
-	iOffset = 0;
-	for (ii = LOGMAX; ii >= 0; ii--) {
-		int nAlloc = (1 << ii);
-		if ((iOffset + nAlloc) <= mem5.nBlock) {
-			mem5.aCtrl[iOffset] = ii | CTRL_FREE;
-			memsys5Link(iOffset, ii);
-			iOffset += nAlloc;
-		}
-		assert((iOffset + nAlloc) > mem5.nBlock);
-	}
-
-	/* If a mutex is required for normal operation, allocate one */
-	if (sqlite3GlobalConfig.bMemstat == 0) {
-		mem5.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
-	}
-
-	return SQLITE_OK;
-}
-
-/*
- * Deinitialize this module.
- */
-static void
-memsys5Shutdown(void *NotUsed)
-{
-	UNUSED_PARAMETER(NotUsed);
-	mem5.mutex = 0;
-	return;
-}
-
-#ifdef SQLITE_TEST
-/*
- * Open the file indicated and write a log of all unfreed memory
- * allocations into that log.
- */
-void
-sqlite3Memsys5Dump(const char *zFilename)
-{
-	FILE *out;
-	int i, j, n;
-	int nMinLog;
-
-	if (zFilename == 0 || zFilename[0] == 0) {
-		out = stdout;
-	} else {
-		out = fopen(zFilename, "w");
-		if (out == 0) {
-			fprintf(stderr,
-				"** Unable to output memory debug output log: %s **\n",
-				zFilename);
-			return;
-		}
-	}
-	memsys5Enter();
-	nMinLog = memsys5Log(mem5.szAtom);
-	for (i = 0; i <= LOGMAX && i + nMinLog < 32; i++) {
-		for (n = 0, j = mem5.aiFreelist[i]; j >= 0;
-		     j = MEM5LINK(j)->next, n++) {
-		}
-		fprintf(out, "freelist items of size %d: %d\n",
-			mem5.szAtom << i, n);
-	}
-	fprintf(out, "mem5.nAlloc       = %llu\n", mem5.nAlloc);
-	fprintf(out, "mem5.totalAlloc   = %llu\n", mem5.totalAlloc);
-	fprintf(out, "mem5.totalExcess  = %llu\n", mem5.totalExcess);
-	fprintf(out, "mem5.currentOut   = %u\n", mem5.currentOut);
-	fprintf(out, "mem5.currentCount = %u\n", mem5.currentCount);
-	fprintf(out, "mem5.maxOut       = %u\n", mem5.maxOut);
-	fprintf(out, "mem5.maxCount     = %u\n", mem5.maxCount);
-	fprintf(out, "mem5.maxRequest   = %u\n", mem5.maxRequest);
-	memsys5Leave();
-	if (out == stdout) {
-		fflush(stdout);
-	} else {
-		fclose(out);
-	}
-}
-#endif
-
-/*
- * This routine is the only routine in this file with external
- * linkage. It returns a pointer to a static sqlite3_mem_methods
- * struct populated with the memsys5 methods.
- */
-const sqlite3_mem_methods *
-sqlite3MemGetMemsys5(void)
-{
-	static const sqlite3_mem_methods memsys5Methods = {
-		memsys5Malloc,
-		memsys5Free,
-		memsys5Realloc,
-		memsys5Size,
-		memsys5Roundup,
-		memsys5Init,
-		memsys5Shutdown,
-		0
-	};
-	return &memsys5Methods;
-}
-
-#endif				/* SQLITE_ENABLE_MEMSYS5 */
diff --git a/src/box/sql/mutex.c b/src/box/sql/mutex.c
deleted file mode 100644
index 56c8c17..0000000
--- a/src/box/sql/mutex.c
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * 1. Redistributions of source code must retain the above
- *    copyright notice, this list of conditions and the
- *    following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
- * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- * This file contains the C functions that implement mutexes.
- *
- * This file contains code that is common across all mutex implementations.
- */
-#include "sqliteInt.h"
-
-#if defined(SQLITE_DEBUG) && !defined(SQLITE_MUTEX_OMIT)
-/*
- * For debugging purposes, record when the mutex subsystem is initialized
- * and uninitialized so that we can assert() if there is an attempt to
- * allocate a mutex while the system is uninitialized.
- */
-static SQLITE_WSD int mutexIsInit = 0;
-#endif				/* SQLITE_DEBUG && !defined(SQLITE_MUTEX_OMIT) */
-
-#ifndef SQLITE_MUTEX_OMIT
-/*
- * Initialize the mutex system.
- */
-int
-sqlite3MutexInit(void)
-{
-	int rc = SQLITE_OK;
-	if (!sqlite3GlobalConfig.mutex.xMutexAlloc) {
-		/* If the xMutexAlloc method has not been set, then the user did not
-		 * install a mutex implementation via sqlite3_config() prior to
-		 * sqlite3_initialize() being called. This block copies pointers to
-		 * the default implementation into the sqlite3GlobalConfig structure.
-		 */
-		sqlite3_mutex_methods const *pFrom;
-		sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;
-
-		if (sqlite3GlobalConfig.bCoreMutex) {
-			pFrom = sqlite3DefaultMutex();
-		} else {
-			pFrom = sqlite3NoopMutex();
-		}
-		pTo->xMutexInit = pFrom->xMutexInit;
-		pTo->xMutexEnd = pFrom->xMutexEnd;
-		pTo->xMutexFree = pFrom->xMutexFree;
-		pTo->xMutexEnter = pFrom->xMutexEnter;
-		pTo->xMutexTry = pFrom->xMutexTry;
-		pTo->xMutexLeave = pFrom->xMutexLeave;
-		pTo->xMutexHeld = pFrom->xMutexHeld;
-		pTo->xMutexNotheld = pFrom->xMutexNotheld;
-		sqlite3MemoryBarrier();
-		pTo->xMutexAlloc = pFrom->xMutexAlloc;
-	}
-	assert(sqlite3GlobalConfig.mutex.xMutexInit);
-	rc = sqlite3GlobalConfig.mutex.xMutexInit();
-
-#ifdef SQLITE_DEBUG
-	GLOBAL(int, mutexIsInit) = 1;
-#endif
-
-	return rc;
-}
-
-/*
- * Shutdown the mutex system. This call frees resources allocated by
- * sqlite3MutexInit().
- */
-int
-sqlite3MutexEnd(void)
-{
-	int rc = SQLITE_OK;
-	if (sqlite3GlobalConfig.mutex.xMutexEnd) {
-		rc = sqlite3GlobalConfig.mutex.xMutexEnd();
-	}
-#ifdef SQLITE_DEBUG
-	GLOBAL(int, mutexIsInit) = 0;
-#endif
-
-	return rc;
-}
-
-/*
- * Retrieve a pointer to a static mutex or allocate a new dynamic one.
- */
-sqlite3_mutex *
-sqlite3_mutex_alloc(int id)
-{
-#ifndef SQLITE_OMIT_AUTOINIT
-	if (id <= SQLITE_MUTEX_RECURSIVE && sqlite3_initialize())
-		return 0;
-	if (id > SQLITE_MUTEX_RECURSIVE && sqlite3MutexInit())
-		return 0;
-#endif
-	assert(sqlite3GlobalConfig.mutex.xMutexAlloc);
-	return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
-}
-
-sqlite3_mutex *
-sqlite3MutexAlloc(int id)
-{
-	if (!sqlite3GlobalConfig.bCoreMutex) {
-		return 0;
-	}
-	assert(GLOBAL(int, mutexIsInit));
-	assert(sqlite3GlobalConfig.mutex.xMutexAlloc);
-	return sqlite3GlobalConfig.mutex.xMutexAlloc(id);
-}
-
-/*
- * Free a dynamic mutex.
- */
-void
-sqlite3_mutex_free(sqlite3_mutex * p)
-{
-	if (p) {
-		assert(sqlite3GlobalConfig.mutex.xMutexFree);
-		sqlite3GlobalConfig.mutex.xMutexFree(p);
-	}
-}
-
-/*
- * Obtain the mutex p. If some other thread already has the mutex, block
- * until it can be obtained.
- */
-void
-sqlite3_mutex_enter(sqlite3_mutex * p)
-{
-	if (p) {
-		assert(sqlite3GlobalConfig.mutex.xMutexEnter);
-		sqlite3GlobalConfig.mutex.xMutexEnter(p);
-	}
-}
-
-/*
- * Obtain the mutex p. If successful, return SQLITE_OK. Otherwise, if another
- * thread holds the mutex and it cannot be obtained, return SQLITE_BUSY.
- */
-int
-sqlite3_mutex_try(sqlite3_mutex * p)
-{
-	int rc = SQLITE_OK;
-	if (p) {
-		assert(sqlite3GlobalConfig.mutex.xMutexTry);
-		return sqlite3GlobalConfig.mutex.xMutexTry(p);
-	}
-	return rc;
-}
-
-/*
- * The sqlite3_mutex_leave() routine exits a mutex that was previously
- * entered by the same thread.  The behavior is undefined if the mutex
- * is not currently entered. If a NULL pointer is passed as an argument
- * this function is a no-op.
- */
-void
-sqlite3_mutex_leave(sqlite3_mutex * p)
-{
-	if (p) {
-		assert(sqlite3GlobalConfig.mutex.xMutexLeave);
-		sqlite3GlobalConfig.mutex.xMutexLeave(p);
-	}
-}
-
-#ifndef NDEBUG
-/*
- * The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
- * intended for use inside assert() statements.
- */
-int
-sqlite3_mutex_held(sqlite3_mutex * p)
-{
-	assert(p == 0 || sqlite3GlobalConfig.mutex.xMutexHeld);
-	return p == 0 || sqlite3GlobalConfig.mutex.xMutexHeld(p);
-}
-
-int
-sqlite3_mutex_notheld(sqlite3_mutex * p)
-{
-	assert(p == 0 || sqlite3GlobalConfig.mutex.xMutexNotheld);
-	return p == 0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p);
-}
-#endif
-
-#endif				/* !defined(SQLITE_MUTEX_OMIT) */
diff --git a/src/box/sql/mutex.h b/src/box/sql/mutex.h
deleted file mode 100644
index 10bf772..0000000
--- a/src/box/sql/mutex.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * 1. Redistributions of source code must retain the above
- *    copyright notice, this list of conditions and the
- *    following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
- * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- *
- * This file contains the common header for all mutex implementations.
- * The sqliteInt.h header #includes this file so that it is available
- * to all source files.  We break it out in an effort to keep the code
- * better organized.
- *
- * NOTE:  source files should *not* #include this header file directly.
- * Source files should #include the sqliteInt.h file and let that file
- * include this one indirectly.
- */
-
-/*
- * Figure out what version of the code to use.  The choices are
- *
- *   SQLITE_MUTEX_OMIT         No mutex logic.  Not even stubs.  The
- *                             mutexes implementation cannot be overridden
- *                             at start-time.
- *
- *   SQLITE_MUTEX_NOOP         For single-threaded applications.  No
- *                             mutual exclusion is provided.  But this
- *                             implementation can be overridden at
- *                             start-time.
- *
- *   SQLITE_MUTEX_PTHREADS     For multi-threaded applications on Unix.
- */
-#if !SQLITE_THREADSAFE
-#define SQLITE_MUTEX_OMIT
-#endif
-#if SQLITE_THREADSAFE && !defined(SQLITE_MUTEX_NOOP)
-#define SQLITE_MUTEX_PTHREADS
-#endif
-
-#ifdef SQLITE_MUTEX_OMIT
-/*
- * If this is a no-op implementation, implement everything as macros.
- */
-#define sqlite3_mutex_alloc(X)    ((sqlite3_mutex*)8)
-#define sqlite3_mutex_free(X)
-#define sqlite3_mutex_enter(X)
-#define sqlite3_mutex_try(X)      SQLITE_OK
-#define sqlite3_mutex_leave(X)
-#define sqlite3_mutex_held(X)     ((void)(X),1)
-#define sqlite3_mutex_notheld(X)  ((void)(X),1)
-#define sqlite3MutexAlloc(X)      ((sqlite3_mutex*)8)
-#define sqlite3MutexInit()        SQLITE_OK
-#define sqlite3MutexEnd()
-#define MUTEX_LOGIC(X)
-#else
-#define MUTEX_LOGIC(X)            X
-#endif				/* defined(SQLITE_MUTEX_OMIT) */
diff --git a/src/box/sql/mutex_noop.c b/src/box/sql/mutex_noop.c
deleted file mode 100644
index 67af80a..0000000
--- a/src/box/sql/mutex_noop.c
+++ /dev/null
@@ -1,300 +0,0 @@
-/*
- * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * 1. Redistributions of source code must retain the above
- *    copyright notice, this list of conditions and the
- *    following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
- * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- * This file contains the C functions that implement mutexes.
- *
- * This implementation in this file does not provide any mutual
- * exclusion and is thus suitable for use only in applications
- * that use SQLite in a single thread.  The routines defined
- * here are place-holders.  Applications can substitute working
- * mutex routines at start-time using the
- *
- *     sqlite3_config(SQLITE_CONFIG_MUTEX,...)
- *
- * interface.
- *
- * If compiled with SQLITE_DEBUG, then additional logic is inserted
- * that does error checking on mutexes to make sure they are being
- * called correctly.
- */
-#include "sqliteInt.h"
-
-#ifndef SQLITE_MUTEX_OMIT
-
-#ifndef SQLITE_DEBUG
-/*
- * Stub routines for all mutex methods.
- *
- * This routines provide no mutual exclusion or error checking.
- */
-static int
-noopMutexInit(void)
-{
-	return SQLITE_OK;
-}
-
-static int
-noopMutexEnd(void)
-{
-	return SQLITE_OK;
-}
-
-static sqlite3_mutex *
-noopMutexAlloc(int id)
-{
-	UNUSED_PARAMETER(id);
-	return (sqlite3_mutex *) 8;
-}
-
-static void
-noopMutexFree(sqlite3_mutex * p)
-{
-	UNUSED_PARAMETER(p);
-	return;
-}
-
-static void
-noopMutexEnter(sqlite3_mutex * p)
-{
-	UNUSED_PARAMETER(p);
-	return;
-}
-
-static int
-noopMutexTry(sqlite3_mutex * p)
-{
-	UNUSED_PARAMETER(p);
-	return SQLITE_OK;
-}
-
-static void
-noopMutexLeave(sqlite3_mutex * p)
-{
-	UNUSED_PARAMETER(p);
-	return;
-}
-
-sqlite3_mutex_methods const *
-sqlite3NoopMutex(void)
-{
-	static const sqlite3_mutex_methods sMutex = {
-		noopMutexInit,
-		noopMutexEnd,
-		noopMutexAlloc,
-		noopMutexFree,
-		noopMutexEnter,
-		noopMutexTry,
-		noopMutexLeave,
-
-		0,
-		0,
-	};
-
-	return &sMutex;
-}
-#endif				/* !SQLITE_DEBUG */
-
-#ifdef SQLITE_DEBUG
-/*
- * In this implementation, error checking is provided for testing
- * and debugging purposes.  The mutexes still do not provide any
- * mutual exclusion.
- */
-
-/*
- * The mutex object
- */
-typedef struct sqlite3_debug_mutex {
-	int id;			/* The mutex type */
-	int cnt;		/* Number of entries without a matching leave */
-} sqlite3_debug_mutex;
-
-/*
- * The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
- * intended for use inside assert() statements.
- */
-static int
-debugMutexHeld(sqlite3_mutex * pX)
-{
-	sqlite3_debug_mutex *p = (sqlite3_debug_mutex *) pX;
-	return p == 0 || p->cnt > 0;
-}
-
-static int
-debugMutexNotheld(sqlite3_mutex * pX)
-{
-	sqlite3_debug_mutex *p = (sqlite3_debug_mutex *) pX;
-	return p == 0 || p->cnt == 0;
-}
-
-/*
- * Initialize and deinitialize the mutex subsystem.
- */
-static int
-debugMutexInit(void)
-{
-	return SQLITE_OK;
-}
-
-static int
-debugMutexEnd(void)
-{
-	return SQLITE_OK;
-}
-
-/*
- * The sqlite3_mutex_alloc() routine allocates a new
- * mutex and returns a pointer to it.  If it returns NULL
- * that means that a mutex could not be allocated.
- */
-static sqlite3_mutex *
-debugMutexAlloc(int id)
-{
-	static sqlite3_debug_mutex aStatic[SQLITE_MUTEX_STATIC_VFS3 - 1];
-	sqlite3_debug_mutex *pNew = 0;
-	switch (id) {
-	case SQLITE_MUTEX_FAST:
-	case SQLITE_MUTEX_RECURSIVE:{
-			pNew = sqlite3Malloc(sizeof(*pNew));
-			if (pNew) {
-				pNew->id = id;
-				pNew->cnt = 0;
-			}
-			break;
-		}
-	default:{
-#ifdef SQLITE_ENABLE_API_ARMOR
-			if (id - 2 < 0 || id - 2 >= ArraySize(aStatic)) {
-				(void)SQLITE_MISUSE_BKPT;
-				return 0;
-			}
-#endif
-			pNew = &aStatic[id - 2];
-			pNew->id = id;
-			break;
-		}
-	}
-	return (sqlite3_mutex *) pNew;
-}
-
-/*
- * This routine deallocates a previously allocated mutex.
- */
-static void
-debugMutexFree(sqlite3_mutex * pX)
-{
-	sqlite3_debug_mutex *p = (sqlite3_debug_mutex *) pX;
-	assert(p->cnt == 0);
-	if (p->id == SQLITE_MUTEX_RECURSIVE || p->id == SQLITE_MUTEX_FAST) {
-		sqlite3_free(p);
-	} else {
-#ifdef SQLITE_ENABLE_API_ARMOR
-		(void)SQLITE_MISUSE_BKPT;
-#endif
-	}
-}
-
-/*
- * The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
- * to enter a mutex.  If another thread is already within the mutex,
- * sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
- * SQLITE_BUSY.  The sqlite3_mutex_try() interface returns SQLITE_OK
- * upon successful entry.  Mutexes created using SQLITE_MUTEX_RECURSIVE can
- * be entered multiple times by the same thread.  In such cases the,
- * mutex must be exited an equal number of times before another thread
- * can enter.  If the same thread tries to enter any other kind of mutex
- * more than once, the behavior is undefined.
- */
-static void
-debugMutexEnter(sqlite3_mutex * pX)
-{
-	sqlite3_debug_mutex *p = (sqlite3_debug_mutex *) pX;
-	assert(p->id == SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX));
-	p->cnt++;
-}
-
-static int
-debugMutexTry(sqlite3_mutex * pX)
-{
-	sqlite3_debug_mutex *p = (sqlite3_debug_mutex *) pX;
-	assert(p->id == SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX));
-	p->cnt++;
-	return SQLITE_OK;
-}
-
-/*
- * The sqlite3_mutex_leave() routine exits a mutex that was
- * previously entered by the same thread.  The behavior
- * is undefined if the mutex is not currently entered or
- * is not currently allocated.  SQLite will never do either.
- */
-static void
-debugMutexLeave(sqlite3_mutex * pX)
-{
-	sqlite3_debug_mutex *p = (sqlite3_debug_mutex *) pX;
-	assert(debugMutexHeld(pX));
-	p->cnt--;
-	assert(p->id == SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX));
-}
-
-sqlite3_mutex_methods const *
-sqlite3NoopMutex(void)
-{
-	static const sqlite3_mutex_methods sMutex = {
-		debugMutexInit,
-		debugMutexEnd,
-		debugMutexAlloc,
-		debugMutexFree,
-		debugMutexEnter,
-		debugMutexTry,
-		debugMutexLeave,
-
-		debugMutexHeld,
-		debugMutexNotheld
-	};
-
-	return &sMutex;
-}
-#endif				/* SQLITE_DEBUG */
-
-/*
- * If compiled with SQLITE_MUTEX_NOOP, then the no-op mutex implementation
- * is used regardless of the run-time threadsafety setting.
- */
-#ifdef SQLITE_MUTEX_NOOP
-sqlite3_mutex_methods const *
-sqlite3DefaultMutex(void)
-{
-	return sqlite3NoopMutex();
-}
-#endif				/* defined(SQLITE_MUTEX_NOOP) */
-#endif				/* !defined(SQLITE_MUTEX_OMIT) */
diff --git a/src/box/sql/mutex_unix.c b/src/box/sql/mutex_unix.c
deleted file mode 100644
index aec0de2..0000000
--- a/src/box/sql/mutex_unix.c
+++ /dev/null
@@ -1,442 +0,0 @@
-/*
- * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * 1. Redistributions of source code must retain the above
- *    copyright notice, this list of conditions and the
- *    following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
- * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- * This file contains the C functions that implement mutexes for pthreads
- */
-#include "sqliteInt.h"
-
-/*
- * The code in this file is only used if we are compiling threadsafe
- * under unix with pthreads.
- *
- * Note that this implementation requires a version of pthreads that
- * supports recursive mutexes.
- */
-#ifdef SQLITE_MUTEX_PTHREADS
-
-#include <pthread.h>
-
-/*
- * The sqlite3_mutex.id, sqlite3_mutex.nRef, and sqlite3_mutex.owner fields
- * are necessary under two condidtions:  (1) Debug builds and (2) using
- * home-grown mutexes.  Encapsulate these conditions into a single #define.
- */
-#if defined(SQLITE_DEBUG) || defined(SQLITE_HOMEGROWN_RECURSIVE_MUTEX)
-#define SQLITE_MUTEX_NREF 1
-#else
-#define SQLITE_MUTEX_NREF 0
-#endif
-
-/*
- * Each recursive mutex is an instance of the following structure.
- */
-struct sqlite3_mutex {
-	pthread_mutex_t mutex;	/* Mutex controlling the lock */
-#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR)
-	int id;			/* Mutex type */
-#endif
-#if SQLITE_MUTEX_NREF
-	volatile int nRef;	/* Number of entrances */
-	volatile pthread_t owner;	/* Thread that is within this mutex */
-	int trace;		/* True to trace changes */
-#endif
-};
-#if SQLITE_MUTEX_NREF
-#define SQLITE3_MUTEX_INITIALIZER {PTHREAD_MUTEX_INITIALIZER,0,0,(pthread_t)0,0}
-#elif defined(SQLITE_ENABLE_API_ARMOR)
-#define SQLITE3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER, 0 }
-#else
-#define SQLITE3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER }
-#endif
-
-/*
- * The sqlite3_mutex_held() and sqlite3_mutex_notheld() routine are
- * intended for use only inside assert() statements.  On some platforms,
- * there might be race conditions that can cause these routines to
- * deliver incorrect results.  In particular, if pthread_equal() is
- * not an atomic operation, then these routines might delivery
- * incorrect results.  On most platforms, pthread_equal() is a
- * comparison of two integers and is therefore atomic.
- *
- * On those platforms where pthread_equal() is not atomic, SQLite
- * should be compiled without -DSQLITE_DEBUG and with -DNDEBUG to
- * make sure no assert() statements are evaluated and hence these
- * routines are never called.
- */
-#if !defined(NDEBUG) || defined(SQLITE_DEBUG)
-static int
-pthreadMutexHeld(sqlite3_mutex * p)
-{
-	return (p->nRef != 0 && pthread_equal(p->owner, pthread_self()));
-}
-
-static int
-pthreadMutexNotheld(sqlite3_mutex * p)
-{
-	return p->nRef == 0 || pthread_equal(p->owner, pthread_self()) == 0;
-}
-#endif
-
-/*
- * Try to provide a memory barrier operation, needed for initialization
- * and also for the implementation of xShmBarrier in the VFS in cases
- * where SQLite is compiled without mutexes.
- */
-void
-sqlite3MemoryBarrier(void)
-{
-#if defined(SQLITE_MEMORY_BARRIER)
-	SQLITE_MEMORY_BARRIER;
-#elif defined(__GNUC__) && GCC_VERSION>=4001000
-	__sync_synchronize();
-#endif
-}
-
-/*
- * Initialize and deinitialize the mutex subsystem.
- */
-static int
-pthreadMutexInit(void)
-{
-	return SQLITE_OK;
-}
-
-static int
-pthreadMutexEnd(void)
-{
-	return SQLITE_OK;
-}
-
-/*
- * The sqlite3_mutex_alloc() routine allocates a new
- * mutex and returns a pointer to it.  If it returns NULL
- * that means that a mutex could not be allocated.  SQLite
- * will unwind its stack and return an error.  The argument
- * to sqlite3_mutex_alloc() is one of these integer constants:
- *
- * <ul>
- * <li>  SQLITE_MUTEX_FAST
- * <li>  SQLITE_MUTEX_RECURSIVE
- * <li>  SQLITE_MUTEX_STATIC_MASTER
- * <li>  SQLITE_MUTEX_STATIC_MEM
- * <li>  SQLITE_MUTEX_STATIC_OPEN
- * <li>  SQLITE_MUTEX_STATIC_PRNG
- * <li>  SQLITE_MUTEX_STATIC_LRU
- * <li>  SQLITE_MUTEX_STATIC_PMEM
- * <li>  SQLITE_MUTEX_STATIC_APP1
- * <li>  SQLITE_MUTEX_STATIC_APP2
- * <li>  SQLITE_MUTEX_STATIC_APP3
- * <li>  SQLITE_MUTEX_STATIC_VFS1
- * <li>  SQLITE_MUTEX_STATIC_VFS2
- * <li>  SQLITE_MUTEX_STATIC_VFS3
- * </ul>
- *
- * The first two constants cause sqlite3_mutex_alloc() to create
- * a new mutex.  The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
- * is used but not necessarily so when SQLITE_MUTEX_FAST is used.
- * The mutex implementation does not need to make a distinction
- * between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
- * not want to.  But SQLite will only request a recursive mutex in
- * cases where it really needs one.  If a faster non-recursive mutex
- * implementation is available on the host platform, the mutex subsystem
- * might return such a mutex in response to SQLITE_MUTEX_FAST.
- *
- * The other allowed parameters to sqlite3_mutex_alloc() each return
- * a pointer to a static preexisting mutex.  Six static mutexes are
- * used by the current version of SQLite.  Future versions of SQLite
- * may add additional static mutexes.  Static mutexes are for internal
- * use by SQLite only.  Applications that use SQLite mutexes should
- * use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
- * SQLITE_MUTEX_RECURSIVE.
- *
- * Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
- * or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
- * returns a different mutex on every call.  But for the static
- * mutex types, the same mutex is returned on every call that has
- * the same type number.
- */
-static sqlite3_mutex *
-pthreadMutexAlloc(int iType)
-{
-	static sqlite3_mutex staticMutexes[] = {
-		SQLITE3_MUTEX_INITIALIZER,
-		SQLITE3_MUTEX_INITIALIZER,
-		SQLITE3_MUTEX_INITIALIZER,
-		SQLITE3_MUTEX_INITIALIZER,
-		SQLITE3_MUTEX_INITIALIZER,
-		SQLITE3_MUTEX_INITIALIZER,
-		SQLITE3_MUTEX_INITIALIZER,
-		SQLITE3_MUTEX_INITIALIZER,
-		SQLITE3_MUTEX_INITIALIZER,
-		SQLITE3_MUTEX_INITIALIZER,
-		SQLITE3_MUTEX_INITIALIZER,
-		SQLITE3_MUTEX_INITIALIZER
-	};
-	sqlite3_mutex *p;
-	switch (iType) {
-	case SQLITE_MUTEX_RECURSIVE:{
-			p = sqlite3MallocZero(sizeof(*p));
-			if (p) {
-#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
-				/* If recursive mutexes are not available, we will have to
-				 * build our own.  See below.
-				 */
-				pthread_mutex_init(&p->mutex, 0);
-#else
-				/* Use a recursive mutex if it is available */
-				pthread_mutexattr_t recursiveAttr;
-				pthread_mutexattr_init(&recursiveAttr);
-				pthread_mutexattr_settype(&recursiveAttr,
-							  PTHREAD_MUTEX_RECURSIVE);
-				pthread_mutex_init(&p->mutex, &recursiveAttr);
-				pthread_mutexattr_destroy(&recursiveAttr);
-#endif
-			}
-			break;
-		}
-	case SQLITE_MUTEX_FAST:{
-			p = sqlite3MallocZero(sizeof(*p));
-			if (p) {
-				pthread_mutex_init(&p->mutex, 0);
-			}
-			break;
-		}
-	default:{
-#ifdef SQLITE_ENABLE_API_ARMOR
-			if (iType - 2 < 0
-			    || iType - 2 >= ArraySize(staticMutexes)) {
-				(void)SQLITE_MISUSE_BKPT;
-				return 0;
-			}
-#endif
-			p = &staticMutexes[iType - 2];
-			break;
-		}
-	}
-#if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR)
-	if (p)
-		p->id = iType;
-#endif
-	return p;
-}
-
-/*
- * This routine deallocates a previously
- * allocated mutex.  SQLite is careful to deallocate every
- * mutex that it allocates.
- */
-static void
-pthreadMutexFree(sqlite3_mutex * p)
-{
-	assert(p->nRef == 0);
-#if SQLITE_ENABLE_API_ARMOR
-	if (p->id == SQLITE_MUTEX_FAST || p->id == SQLITE_MUTEX_RECURSIVE)
-#endif
-	{
-		pthread_mutex_destroy(&p->mutex);
-		sqlite3_free(p);
-	}
-#ifdef SQLITE_ENABLE_API_ARMOR
-	else {
-		(void)SQLITE_MISUSE_BKPT;
-	}
-#endif
-}
-
-/*
- * The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
- * to enter a mutex.  If another thread is already within the mutex,
- * sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
- * SQLITE_BUSY.  The sqlite3_mutex_try() interface returns SQLITE_OK
- * upon successful entry.  Mutexes created using SQLITE_MUTEX_RECURSIVE can
- * be entered multiple times by the same thread.  In such cases the,
- * mutex must be exited an equal number of times before another thread
- * can enter.  If the same thread tries to enter any other kind of mutex
- * more than once, the behavior is undefined.
- */
-static void
-pthreadMutexEnter(sqlite3_mutex * p)
-{
-	assert(p->id == SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p));
-
-#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
-	/* If recursive mutexes are not available, then we have to grow
-	 * our own.  This implementation assumes that pthread_equal()
-	 * is atomic - that it cannot be deceived into thinking self
-	 * and p->owner are equal if p->owner changes between two values
-	 * that are not equal to self while the comparison is taking place.
-	 * This implementation also assumes a coherent cache - that
-	 * separate processes cannot read different values from the same
-	 * address at the same time.  If either of these two conditions
-	 * are not met, then the mutexes will fail and problems will result.
-	 */
-	{
-		pthread_t self = pthread_self();
-		if (p->nRef > 0 && pthread_equal(p->owner, self)) {
-			p->nRef++;
-		} else {
-			pthread_mutex_lock(&p->mutex);
-			assert(p->nRef == 0);
-			p->owner = self;
-			p->nRef = 1;
-		}
-	}
-#else
-	/* Use the built-in recursive mutexes if they are available.
-	 */
-	pthread_mutex_lock(&p->mutex);
-#if SQLITE_MUTEX_NREF
-	assert(p->nRef > 0 || p->owner == 0);
-	p->owner = pthread_self();
-	p->nRef++;
-#endif
-#endif
-
-#ifdef SQLITE_DEBUG
-	if (p->trace) {
-		printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace,
-		       p->nRef);
-	}
-#endif
-}
-
-static int
-pthreadMutexTry(sqlite3_mutex * p)
-{
-	int rc;
-	assert(p->id == SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p));
-
-#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
-	/* If recursive mutexes are not available, then we have to grow
-	 * our own.  This implementation assumes that pthread_equal()
-	 * is atomic - that it cannot be deceived into thinking self
-	 * and p->owner are equal if p->owner changes between two values
-	 * that are not equal to self while the comparison is taking place.
-	 * This implementation also assumes a coherent cache - that
-	 * separate processes cannot read different values from the same
-	 * address at the same time.  If either of these two conditions
-	 * are not met, then the mutexes will fail and problems will result.
-	 */
-	{
-		pthread_t self = pthread_self();
-		if (p->nRef > 0 && pthread_equal(p->owner, self)) {
-			p->nRef++;
-			rc = SQLITE_OK;
-		} else if (pthread_mutex_trylock(&p->mutex) == 0) {
-			assert(p->nRef == 0);
-			p->owner = self;
-			p->nRef = 1;
-			rc = SQLITE_OK;
-		} else {
-			rc = SQLITE_BUSY;
-		}
-	}
-#else
-	/* Use the built-in recursive mutexes if they are available.
-	 */
-	if (pthread_mutex_trylock(&p->mutex) == 0) {
-#if SQLITE_MUTEX_NREF
-		p->owner = pthread_self();
-		p->nRef++;
-#endif
-		rc = SQLITE_OK;
-	} else {
-		rc = SQLITE_BUSY;
-	}
-#endif
-
-#ifdef SQLITE_DEBUG
-	if (rc == SQLITE_OK && p->trace) {
-		printf("enter mutex %p (%d) with nRef=%d\n", p, p->trace,
-		       p->nRef);
-	}
-#endif
-	return rc;
-}
-
-/*
- * The sqlite3_mutex_leave() routine exits a mutex that was
- * previously entered by the same thread.  The behavior
- * is undefined if the mutex is not currently entered or
- * is not currently allocated.  SQLite will never do either.
- */
-static void
-pthreadMutexLeave(sqlite3_mutex * p)
-{
-	assert(pthreadMutexHeld(p));
-#if SQLITE_MUTEX_NREF
-	p->nRef--;
-	if (p->nRef == 0)
-		p->owner = 0;
-#endif
-	assert(p->nRef == 0 || p->id == SQLITE_MUTEX_RECURSIVE);
-
-#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
-	if (p->nRef == 0) {
-		pthread_mutex_unlock(&p->mutex);
-	}
-#else
-	pthread_mutex_unlock(&p->mutex);
-#endif
-
-#ifdef SQLITE_DEBUG
-	if (p->trace) {
-		printf("leave mutex %p (%d) with nRef=%d\n", p, p->trace,
-		       p->nRef);
-	}
-#endif
-}
-
-sqlite3_mutex_methods const *
-sqlite3DefaultMutex(void)
-{
-	static const sqlite3_mutex_methods sMutex = {
-		pthreadMutexInit,
-		pthreadMutexEnd,
-		pthreadMutexAlloc,
-		pthreadMutexFree,
-		pthreadMutexEnter,
-		pthreadMutexTry,
-		pthreadMutexLeave,
-#ifdef SQLITE_DEBUG
-		pthreadMutexHeld,
-		pthreadMutexNotheld
-#else
-		0,
-		0
-#endif
-	};
-
-	return &sMutex;
-}
-
-#endif				/* SQLITE_MUTEX_PTHREADS */
diff --git a/src/box/sql/sqlite3.h b/src/box/sql/sqlite3.h
deleted file mode 100644
index d60d74d..0000000
--- a/src/box/sql/sqlite3.h
+++ /dev/null
@@ -1,6728 +0,0 @@
-/*
- * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
- *
- * Redistribution and use in source and binary forms, with or
- * without modification, are permitted provided that the following
- * conditions are met:
- *
- * 1. Redistributions of source code must retain the above
- *    copyright notice, this list of conditions and the
- *    following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials
- *    provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
- * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
- * <COPYRIGHT HOLDER> OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
- * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- * This header file defines the interface that the SQLite library
- * presents to client programs.  If a C-function, structure, datatype,
- * or constant definition does not appear in this file, then it is
- * not a published API of SQLite, is subject to change without
- * notice, and should not be referenced by programs that use SQLite.
- *
- * Some of the definitions that are in this file are marked as
- * "experimental".  Experimental interfaces are normally new
- * features recently added to SQLite.  We do not anticipate changes
- * to experimental interfaces but reserve the right to make minor changes
- * if experience from use "in the wild" suggest such changes are prudent.
- *
- * The official C-language API documentation for SQLite is derived
- * from comments in this file.  This file is the authoritative source
- * on how SQLite interfaces are supposed to operate.
- *
- * The name of this file under configuration management is "sqlite.h.in".
- * The makefile makes some minor changes to this file (such as inserting
- * the version number) and changes its name to "sqlite3.h" as
- * part of the build process.
-*/
-#ifndef SQLITE3_H
-#define SQLITE3_H
-#include <stdarg.h>		/* Needed for the definition of va_list */
-
-/*
- * Make sure we can call this stuff from C++.
-*/
-#ifdef __cplusplus
-//extern "C" {
-#endif
-
-/*
- * Provide the ability to override linkage features of the interface.
-*/
-#ifndef SQLITE_EXTERN
-#define SQLITE_EXTERN extern
-#endif
-#ifndef SQLITE_API
-#define SQLITE_API
-#endif
-#ifndef SQLITE_CDECL
-#define SQLITE_CDECL
-#endif
-#ifndef SQLITE_APICALL
-#define SQLITE_APICALL
-#endif
-#ifndef SQLITE_STDCALL
-#define SQLITE_STDCALL SQLITE_APICALL
-#endif
-#ifndef SQLITE_CALLBACK
-#define SQLITE_CALLBACK
-#endif
-#ifndef SQLITE_SYSAPI
-#define SQLITE_SYSAPI
-#endif
-
-/*
- * These no-op macros are used in front of interfaces to mark those
- * interfaces as either deprecated or experimental.  New applications
- * should not use deprecated interfaces - they are supported for backwards
- * compatibility only.  Application writers should be aware that
- * experimental interfaces are subject to change in point releases.
- *
- * These macros used to resolve to various kinds of compiler magic that
- * would generate warning messages when they were used.  But that
- * compiler magic ended up generating such a flurry of bug reports
- * that we have taken it all out and gone back to using simple
- * noop macros.
-*/
-#define SQLITE_EXPERIMENTAL
-
-/*
- * Ensure these symbols were not defined by some previous header file.
-*/
-#ifdef SQLITE_VERSION
-#undef SQLITE_VERSION
-#endif
-#ifdef SQLITE_VERSION_NUMBER
-#undef SQLITE_VERSION_NUMBER
-#endif
-
-/*
- * CAPI3REF: Compile-Time Library Version Numbers
- *
- * ^(The [SQLITE_VERSION] C preprocessor macro in the sqlite3.h header
- * evaluates to a string literal that is the SQLite version in the
- * format "X.Y.Z" where X is the major version number (always 3 for
- * SQLite3) and Y is the minor version number and Z is the release number.)^
- * ^(The [SQLITE_VERSION_NUMBER] C preprocessor macro resolves to an integer
- * with the value (X*1000000 + Y*1000 + Z) where X, Y, and Z are the same
- * numbers used in [SQLITE_VERSION].)^
- * The SQLITE_VERSION_NUMBER for any given release of SQLite will also
- * be larger than the release from which it is derived.  Either Y will
- * be held constant and Z will be incremented or else Y will be incremented
- * and Z will be reset to zero.
- *
- * Since [version 3.6.18] ([dateof:3.6.18]),
- * SQLite source code has been stored in the
- * <a href="http://www.fossil-scm.org/">Fossil configuration management
- * system</a>.  ^The SQLITE_SOURCE_ID macro evaluates to
- * a string which identifies a particular check-in of SQLite
- * within its configuration management system.  ^The SQLITE_SOURCE_ID
- * string contains the date and time of the check-in (UTC) and an SHA1
- * hash of the entire source tree.
- *
- * See also: [sqlite3_libversion()],
- * [sqlite3_libversion_number()], [sqlite3_sourceid()],
- * [sqlite_version()] and [sqlite_source_id()].
-*/
-#define SQLITE_VERSION        "3.16.2"
-#define SQLITE_VERSION_NUMBER 3016002
-#define SQLITE_SOURCE_ID      "D 1970-01-01 00:00:00 00000000-0000-0000-0000-000000000000"
-
-/*
- * CAPI3REF: Run-Time Library Version Numbers
- * KEYWORDS: sqlite3_version sqlite3_sourceid
- *
- * These interfaces provide the same information as the [SQLITE_VERSION],
- * [SQLITE_VERSION_NUMBER], and [SQLITE_SOURCE_ID] C preprocessor macros
- * but are associated with the library instead of the header file.  ^(Cautious
- * programmers might include assert() statements in their application to
- * verify that values returned by these interfaces match the macros in
- * the header, and thus ensure that the application is
- * compiled with matching library and header files.
- *
- * <blockquote><pre>
- * assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
- * assert( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)==0 );
- * assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );
- * </pre></blockquote>)^
- *
- * ^The sqlite3_version[] string constant contains the text of [SQLITE_VERSION]
- * macro.  ^The sqlite3_libversion() function returns a pointer to the
- * to the sqlite3_version[] string constant.  The sqlite3_libversion()
- * function is provided for use in DLLs since DLL users usually do not have
- * direct access to string constants within the DLL.  ^The
- * sqlite3_libversion_number() function returns an integer equal to
- * [SQLITE_VERSION_NUMBER].  ^The sqlite3_sourceid() function returns
- * a pointer to a string constant whose value is the same as the
- * [SQLITE_SOURCE_ID] C preprocessor macro.
- *
- * See also: [sqlite_version()] and [sqlite_source_id()].
-*/
-SQLITE_API SQLITE_EXTERN const char sqlite3_version[];
-
-SQLITE_API const char *
-sqlite3_libversion(void);
-
-SQLITE_API const char *
-sqlite3_sourceid(void);
-
-SQLITE_API int
-sqlite3_libversion_number(void);
-
-/*
- * CAPI3REF: Test To See If The Library Is Threadsafe
- *
- * ^The sqlite3_threadsafe() function returns zero if and only if
- * SQLite was compiled with mutexing code omitted due to the
- * [SQLITE_THREADSAFE] compile-time option being set to 0.
- *
- * SQLite can be compiled with or without mutexes.  When
- * the [SQLITE_THREADSAFE] C preprocessor macro is 1 or 2, mutexes
- * are enabled and SQLite is threadsafe.  When the
- * [SQLITE_THREADSAFE] macro is 0,
- * the mutexes are omitted.  Without the mutexes, it is not safe
- * to use SQLite concurrently from more than one thread.
- *
- * Enabling mutexes incurs a measurable performance penalty.
- * So if speed is of utmost importance, it makes sense to disable
- * the mutexes.  But for maximum safety, mutexes should be enabled.
- * ^The default behavior is for mutexes to be enabled.
- *
- * This interface can be used by an application to make sure that the
- * version of SQLite that it is linking against was compiled with
- * the desired setting of the [SQLITE_THREADSAFE] macro.
- *
- * This interface only reports on the compile-time mutex setting
- * of the [SQLITE_THREADSAFE] flag.  If SQLite is compiled with
- * SQLITE_THREADSAFE=1 or =2 then mutexes are enabled by default but
- * can be fully or partially disabled using a call to [sqlite3_config()]
- * with the verbs [SQLITE_CONFIG_SINGLETHREAD], [SQLITE_CONFIG_MULTITHREAD],
- * or [SQLITE_CONFIG_SERIALIZED].  ^(The return value of the
- * sqlite3_threadsafe() function shows only the compile-time setting of
- * thread safety, not any run-time changes to that setting made by
- * sqlite3_config(). In other words, the return value from sqlite3_threadsafe()
- * is unchanged by calls to sqlite3_config().)^
- *
- * See the [threading mode] documentation for additional information.
-*/
-SQLITE_API int
-sqlite3_threadsafe(void);
-
-/*
- * CAPI3REF: Database Connection Handle
- * KEYWORDS: {database connection} {database connections}
- *
- * Each open SQLite database is represented by a pointer to an instance of
- * the opaque structure named "sqlite3".  It is useful to think of an sqlite3
- * pointer as an object.  The [sqlite3_open()], and
- * [sqlite3_open_v2()] interfaces are its constructors, and [sqlite3_close()]
- * and [sqlite3_close_v2()] are its destructors.  There are many other
- * interfaces (such as
- * [sqlite3_prepare_v2()], [sqlite3_create_function()], and
- * [sqlite3_busy_timeout()] to name but three) that are methods on an
- * sqlite3 object.
-*/
-typedef struct sqlite3 sqlite3;
-
-/*
- * CAPI3REF: 64-Bit Integer Types
- * KEYWORDS: sqlite_int64 sqlite_uint64
- *
- * Because there is no cross-platform way to specify 64-bit integer types
- * SQLite includes typedefs for 64-bit signed and unsigned integers.
- *
- * The sqlite3_int64 and sqlite3_uint64 are the preferred type definitions.
- * The sqlite_int64 and sqlite_uint64 types are supported for backwards
- * compatibility only.
- *
- * ^The sqlite3_int64 and sqlite_int64 types can store integer values
- * between -9223372036854775808 and +9223372036854775807 inclusive.  ^The
- * sqlite3_uint64 and sqlite_uint64 types can store integer values
- * between 0 and +18446744073709551615 inclusive.
-*/
-#ifdef SQLITE_INT64_TYPE
-typedef SQLITE_INT64_TYPE sqlite_int64;
-typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
-#elif defined(_MSC_VER) || defined(__BORLANDC__)
-typedef __int64 sqlite_int64;
-typedef unsigned __int64 sqlite_uint64;
-#else
-typedef long long int sqlite_int64;
-typedef unsigned long long int sqlite_uint64;
-#endif
-typedef sqlite_int64 sqlite3_int64;
-typedef sqlite_uint64 sqlite3_uint64;
-
-/*
- * If compiling for a processor that lacks floating point support,
- * substitute integer for floating-point.
-*/
-#ifdef SQLITE_OMIT_FLOATING_POINT
-#define double sqlite3_int64
-#endif
-
-/*
- * CAPI3REF: Closing A Database Connection
- * DESTRUCTOR: sqlite3
- *
- * ^The sqlite3_close() and sqlite3_close_v2() routines are destructors
- * for the [sqlite3] object.
- * ^Calls to sqlite3_close() and sqlite3_close_v2() return [SQLITE_OK] if
- * the [sqlite3] object is successfully destroyed and all associated
- * resources are deallocated.
- *
- * ^If the database connection is associated with unfinalized prepared
- * statements objects then sqlite3_close()
- * will leave the database connection open and return [SQLITE_BUSY].
- * ^If sqlite3_close_v2() is called with unfinalized prepared statements
- * , then the database connection becomes
- * an unusable "zombie" which will automatically be deallocated when the
- * last prepared statement is finalized.
- * The sqlite3_close_v2() interface is intended for use with
- * host languages that are garbage collected, and where the order in which
- * destructors are called is arbitrary.
- *
- * Applications should [sqlite3_finalize | finalize] all [prepared statements],
- * [sqlite3_blob_close | close] all [BLOB handles], and
- * [finish] all objects associated
- * with the [sqlite3] object prior to attempting to close the object.  ^If
- * sqlite3_close_v2() is called on a [database connection] that still has
- * outstanding [prepared statements], [BLOB handles]
- * then it returns [SQLITE_OK] and the deallocation
- * of resources is deferred until all [prepared statements], [BLOB handles]
- * objects are also destroyed.
- *
- * ^If an [sqlite3] object is destroyed while a transaction is open,
- * the transaction is automatically rolled back.
- *
- * The C parameter to [sqlite3_close(C)] and [sqlite3_close_v2(C)]
- * must be either a NULL
- * pointer or an [sqlite3] object pointer obtained
- * from [sqlite3_open()], [sqlite3_open16()], or
- * [sqlite3_open_v2()], and not previously closed.
- * ^Calling sqlite3_close() or sqlite3_close_v2() with a NULL pointer
- * argument is a harmless no-op.
-*/
-SQLITE_API int
-sqlite3_close(sqlite3 *);
-
-SQLITE_API int
-sqlite3_close_v2(sqlite3 *);
-
-/*
- * The type for a callback function.
- * This is legacy and deprecated.  It is included for historical
- * compatibility and is not documented.
-*/
-typedef int (*sqlite3_callback) (void *, int, char **, char **);
-
-/*
- * CAPI3REF: One-Step Query Execution Interface
- * METHOD: sqlite3
- *
- * The sqlite3_exec() interface is a convenience wrapper around
- * [sqlite3_prepare_v2()], [sqlite3_step()], and [sqlite3_finalize()],
- * that allows an application to run multiple statements of SQL
- * without having to use a lot of C code.
- *
- * ^The sqlite3_exec() interface runs zero or more UTF-8 encoded,
- * semicolon-separate SQL statements passed into its 2nd argument,
- * in the context of the [database connection] passed in as its 1st
- * argument.  ^If the callback function of the 3rd argument to
- * sqlite3_exec() is not NULL, then it is invoked for each result row
- * coming out of the evaluated SQL statements.  ^The 4th argument to
- * sqlite3_exec() is relayed through to the 1st argument of each
- * callback invocation.  ^If the callback pointer to sqlite3_exec()
- * is NULL, then no callback is ever invoked and result rows are
- * ignored.
- *
- * ^If an error occurs while evaluating the SQL statements passed into
- * sqlite3_exec(), then execution of the current statement stops and
- * subsequent statements are skipped.  ^If the 5th parameter to sqlite3_exec()
- * is not NULL then any error message is written into memory obtained
- * from [sqlite3_malloc()] and passed back through the 5th parameter.
- * To avoid memory leaks, the application should invoke [sqlite3_free()]
- * on error message strings returned through the 5th parameter of
- * sqlite3_exec() after the error message string is no longer needed.
- * ^If the 5th parameter to sqlite3_exec() is not NULL and no errors
- * occur, then sqlite3_exec() sets the pointer in its 5th parameter to
- * NULL before returning.
- *
- * ^If an sqlite3_exec() callback returns non-zero, the sqlite3_exec()
- * routine returns SQLITE_ABORT without invoking the callback again and
- * without running any subsequent SQL statements.
- *
- * ^The 2nd argument to the sqlite3_exec() callback function is the
- * number of columns in the result.  ^The 3rd argument to the sqlite3_exec()
- * callback is an array of pointers to strings obtained as if from
- * [sqlite3_column_text()], one for each column.  ^If an element of a
- * result row is NULL then the corresponding string pointer for the
- * sqlite3_exec() callback is a NULL pointer.  ^The 4th argument to the
- * sqlite3_exec() callback is an array of pointers to strings where each
- * entry represents the name of corresponding result column as obtained
- * from [sqlite3_column_name()].
- *
- * ^If the 2nd parameter to sqlite3_exec() is a NULL pointer, a pointer
- * to an empty string, or a pointer that contains only whitespace and/or
- * SQL comments, then no SQL statements are evaluated and the database
- * is not changed.
- *
- * Restrictions:
- *
- * <ul>
- * <li> The application must ensure that the 1st parameter to sqlite3_exec()
- *      is a valid and open [database connection].
- * <li> The application must not close the [database connection] specified by
- *      the 1st parameter to sqlite3_exec() while sqlite3_exec() is running.
- * <li> The application must not modify the SQL statement text passed into
- *      the 2nd parameter of sqlite3_exec() while sqlite3_exec() is running.
- * </ul>
-*/
-SQLITE_API int
-sqlite3_exec(sqlite3 *,	/* An open database */
-	     const char *sql,	/* SQL to be evaluated */
-	     int (*callback) (void *, int, char **, char **),	/* Callback function */
-	     void *,	/* 1st argument to callback */
-	     char **errmsg	/* Error msg written here */
-	);
-
-/*
- * CAPI3REF: Result Codes
- * KEYWORDS: {result code definitions}
- *
- * Many SQLite functions return an integer result code from the set shown
- * here in order to indicate success or failure.
- *
- * New error codes may be added in future versions of SQLite.
- *
- * See also: [extended result code definitions]
-*/
-#define SQLITE_OK           0	/* Successful result */
-/* beginning-of-error-codes */
-#define SQLITE_ERROR        1	/* SQL error or missing database */
-#define SQLITE_INTERNAL     2	/* Internal logic error in SQLite */
-#define SQLITE_PERM         3	/* Access permission denied */
-#define SQLITE_ABORT        4	/* Callback routine requested an abort */
-#define SQLITE_BUSY         5	/* The database file is locked */
-#define SQLITE_LOCKED       6	/* A table in the database is locked */
-#define SQLITE_NOMEM        7	/* A malloc() failed */
-#define SQLITE_READONLY     8	/* Attempt to write a readonly database */
-#define SQLITE_INTERRUPT    9	/* Operation terminated by sqlite3_interrupt() */
-#define SQLITE_IOERR       10	/* Some kind of disk I/O error occurred */
-#define SQLITE_CORRUPT     11	/* The database disk image is malformed */
-#define SQLITE_NOTFOUND    12	/* Unknown opcode in sqlite3_file_control() */
-#define SQLITE_FULL        13	/* Insertion failed because database is full */
-#define SQLITE_CANTOPEN    14	/* Unable to open the database file */
-#define SQLITE_PROTOCOL    15	/* Database lock protocol error */
-#define SQLITE_EMPTY       16	/* Database is empty */
-#define SQLITE_SCHEMA      17	/* The database schema changed */
-#define SQLITE_TOOBIG      18	/* String or BLOB exceeds size limit */
-#define SQLITE_CONSTRAINT  19	/* Abort due to constraint violation */
-#define SQLITE_MISMATCH    20	/* Data type mismatch */
-#define SQLITE_MISUSE      21	/* Library used incorrectly */
-#define SQLITE_NOLFS       22	/* Uses OS features not supported on host */
-#define SQLITE_FORMAT      23	/* Auxiliary database format error */
-#define SQLITE_RANGE       24	/* 2nd parameter to sqlite3_bind out of range */
-#define SQLITE_NOTADB      25	/* File opened that is not a database file */
-#define SQL_TARANTOOL_ITERATOR_FAIL 26
-#define SQL_TARANTOOL_INSERT_FAIL   27
-#define SQL_TARANTOOL_DELETE_FAIL   28
-#define SQL_TARANTOOL_ERROR         29
-#define SQLITE_NOTICE      31	/* Notifications from sqlite3_log() */
-#define SQLITE_WARNING     32	/* Warnings from sqlite3_log() */
-#define SQLITE_ROW         100	/* sqlite3_step() has another row ready */
-#define SQLITE_DONE        101	/* sqlite3_step() has finished executing */
-/* end-of-error-codes */
-
-/*
- * CAPI3REF: Extended Result Codes
- * KEYWORDS: {extended result code definitions}
- *
- * In its default configuration, SQLite API routines return one of 30 integer
- * [result codes].  However, experience has shown that many of
- * these result codes are too coarse-grained.  They do not provide as
- * much information about problems as programmers might like.  In an effort to
- * address this, newer versions of SQLite (version 3.3.8 [dateof:3.3.8]
- * and later) include
- * support for additional result codes that provide more detailed information
- * about errors. These [extended result codes] are enabled or disabled
- * on a per database connection basis using the
- * [sqlite3_extended_result_codes()] API.  Or, the extended code for
- * the most recent error can be obtained using
- * [sqlite3_extended_errcode()].
-*/
-#define SQLITE_IOERR_READ              (SQLITE_IOERR | (1<<8))
-#define SQLITE_IOERR_SHORT_READ        (SQLITE_IOERR | (2<<8))
-#define SQLITE_IOERR_WRITE             (SQLITE_IOERR | (3<<8))
-#define SQLITE_IOERR_FSYNC             (SQLITE_IOERR | (4<<8))
-#define SQLITE_IOERR_DIR_FSYNC         (SQLITE_IOERR | (5<<8))
-#define SQLITE_IOERR_TRUNCATE          (SQLITE_IOERR | (6<<8))
-#define SQLITE_IOERR_FSTAT             (SQLITE_IOERR | (7<<8))
-#define SQLITE_IOERR_UNLOCK            (SQLITE_IOERR | (8<<8))
-#define SQLITE_IOERR_RDLOCK            (SQLITE_IOERR | (9<<8))
-#define SQLITE_IOERR_DELETE            (SQLITE_IOERR | (10<<8))
-#define SQLITE_IOERR_BLOCKED           (SQLITE_IOERR | (11<<8))
-#define SQLITE_IOERR_NOMEM             (SQLITE_IOERR | (12<<8))
-#define SQLITE_IOERR_ACCESS            (SQLITE_IOERR | (13<<8))
-#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))
-#define SQLITE_IOERR_LOCK              (SQLITE_IOERR | (15<<8))
-#define SQLITE_IOERR_CLOSE             (SQLITE_IOERR | (16<<8))
-#define SQLITE_IOERR_DIR_CLOSE         (SQLITE_IOERR | (17<<8))
-#define SQLITE_IOERR_SHMOPEN           (SQLITE_IOERR | (18<<8))
-#define SQLITE_IOERR_SHMSIZE           (SQLITE_IOERR | (19<<8))
-#define SQLITE_IOERR_SHMLOCK           (SQLITE_IOERR | (20<<8))
-#define SQLITE_IOERR_SHMMAP            (SQLITE_IOERR | (21<<8))
-#define SQLITE_IOERR_SEEK              (SQLITE_IOERR | (22<<8))
-#define SQLITE_IOERR_DELETE_NOENT      (SQLITE_IOERR | (23<<8))
-#define SQLITE_IOERR_MMAP              (SQLITE_IOERR | (24<<8))
-#define SQLITE_IOERR_GETTEMPPATH       (SQLITE_IOERR | (25<<8))
-#define SQLITE_IOERR_CONVPATH          (SQLITE_IOERR | (26<<8))
-#define SQLITE_IOERR_VNODE             (SQLITE_IOERR | (27<<8))
-#define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))
-#define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))
-#define SQLITE_BUSY_SNAPSHOT           (SQLITE_BUSY   |  (2<<8))
-#define SQLITE_CANTOPEN_NOTEMPDIR      (SQLITE_CANTOPEN | (1<<8))
-#define SQLITE_CANTOPEN_ISDIR          (SQLITE_CANTOPEN | (2<<8))
-#define SQLITE_CANTOPEN_FULLPATH       (SQLITE_CANTOPEN | (3<<8))
-#define SQLITE_CANTOPEN_CONVPATH       (SQLITE_CANTOPEN | (4<<8))
-#define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))
-#define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))
-#define SQLITE_READONLY_ROLLBACK       (SQLITE_READONLY | (3<<8))
-#define SQLITE_READONLY_DBMOVED        (SQLITE_READONLY | (4<<8))
-#define SQLITE_ABORT_ROLLBACK          (SQLITE_ABORT | (2<<8))
-#define SQLITE_CONSTRAINT_CHECK        (SQLITE_CONSTRAINT | (1<<8))
-#define SQLITE_CONSTRAINT_COMMITHOOK   (SQLITE_CONSTRAINT | (2<<8))
-#define SQLITE_CONSTRAINT_FOREIGNKEY   (SQLITE_CONSTRAINT | (3<<8))
-#define SQLITE_CONSTRAINT_FUNCTION     (SQLITE_CONSTRAINT | (4<<8))
-#define SQLITE_CONSTRAINT_NOTNULL      (SQLITE_CONSTRAINT | (5<<8))
-#define SQLITE_CONSTRAINT_PRIMARYKEY   (SQLITE_CONSTRAINT | (6<<8))
-#define SQLITE_CONSTRAINT_TRIGGER      (SQLITE_CONSTRAINT | (7<<8))
-#define SQLITE_CONSTRAINT_UNIQUE       (SQLITE_CONSTRAINT | (8<<8))
-#define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))
-#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
-#define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))
-#define SQLITE_OK_LOAD_PERMANENTLY     (SQLITE_OK | (1<<8))
-
-/*
- * CAPI3REF: Flags For File Open Operations
- *
- * These bit values are intended for use in the
- * 3rd parameter to the [sqlite3_open_v2()] interface and
- * in the 4th parameter to the [sqlite3_vfs.xOpen] method.
-*/
-#define SQLITE_OPEN_READONLY         0x00000001	/* Ok for sqlite3_open_v2() */
-#define SQLITE_OPEN_READWRITE        0x00000002	/* Ok for sqlite3_open_v2() */
-#define SQLITE_OPEN_CREATE           0x00000004	/* Ok for sqlite3_open_v2() */
-#define SQLITE_OPEN_DELETEONCLOSE    0x00000008	/* VFS only */
-#define SQLITE_OPEN_EXCLUSIVE        0x00000010	/* VFS only */
-#define SQLITE_OPEN_AUTOPROXY        0x00000020	/* VFS only */
-#define SQLITE_OPEN_URI              0x00000040	/* Ok for sqlite3_open_v2() */
-#define SQLITE_OPEN_MEMORY           0x00000080	/* Ok for sqlite3_open_v2() */
-#define SQLITE_OPEN_MAIN_DB          0x00000100	/* VFS only */
-#define SQLITE_OPEN_TEMP_DB          0x00000200	/* VFS only */
-#define SQLITE_OPEN_TRANSIENT_DB     0x00000400	/* VFS only */
-#define SQLITE_OPEN_NOMUTEX          0x00008000	/* Ok for sqlite3_open_v2() */
-#define SQLITE_OPEN_FULLMUTEX        0x00010000	/* Ok for sqlite3_open_v2() */
-#define SQLITE_OPEN_SHAREDCACHE      0x00020000	/* Ok for sqlite3_open_v2() */
-#define SQLITE_OPEN_PRIVATECACHE     0x00040000	/* Ok for sqlite3_open_v2() */
-
-/* Reserved:                         0x00F00000 */
-
-/*
- * CAPI3REF: Device Characteristics
- *
- * The xDeviceCharacteristics method of the [sqlite3_io_methods]
- * object returns an integer which is a vector of these
- * bit values expressing I/O characteristics of the mass storage
- * device that holds the file that the [sqlite3_io_methods]
- * refers to.
- *
- * The SQLITE_IOCAP_ATOMIC property means that all writes of
- * any size are atomic.  The SQLITE_IOCAP_ATOMICnnn values
- * mean that writes of blocks that are nnn bytes in size and
- * are aligned to an address which is an integer multiple of
- * nnn are atomic.  The SQLITE_IOCAP_SAFE_APPEND value means
- * that when data is appended to a file, the data is appended
- * first then the size of the file is extended, never the other
- * way around.  The SQLITE_IOCAP_SEQUENTIAL property means that
- * information is written to disk in the same order as calls
- * to xWrite().  The SQLITE_IOCAP_POWERSAFE_OVERWRITE property means that
- * after reboot following a crash or power loss, the only bytes in a
- * file that were written at the application level might have changed
- * and that adjacent bytes, even bytes within the same sector are
- * guaranteed to be unchanged.  The SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
- * flag indicate that a file cannot be deleted when open.  The
- * SQLITE_IOCAP_IMMUTABLE flag indicates that the file is on
- * read-only media and cannot be changed even by processes with
- * elevated privileges.
-*/
-#define SQLITE_IOCAP_ATOMIC                 0x00000001
-#define SQLITE_IOCAP_ATOMIC512              0x00000002
-#define SQLITE_IOCAP_ATOMIC1K               0x00000004
-#define SQLITE_IOCAP_ATOMIC2K               0x00000008
-#define SQLITE_IOCAP_ATOMIC4K               0x00000010
-#define SQLITE_IOCAP_ATOMIC8K               0x00000020
-#define SQLITE_IOCAP_ATOMIC16K              0x00000040
-#define SQLITE_IOCAP_ATOMIC32K              0x00000080
-#define SQLITE_IOCAP_ATOMIC64K              0x00000100
-#define SQLITE_IOCAP_SAFE_APPEND            0x00000200
-#define SQLITE_IOCAP_SEQUENTIAL             0x00000400
-#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN  0x00000800
-#define SQLITE_IOCAP_POWERSAFE_OVERWRITE    0x00001000
-#define SQLITE_IOCAP_IMMUTABLE              0x00002000
-
-/*
- * CAPI3REF: File Locking Levels
- *
- * SQLite uses one of these integer values as the second
- * argument to calls it makes to the xLock() and xUnlock() methods
- * of an [sqlite3_io_methods] object.
-*/
-#define SQLITE_LOCK_NONE          0
-#define SQLITE_LOCK_SHARED        1
-#define SQLITE_LOCK_RESERVED      2
-#define SQLITE_LOCK_PENDING       3
-#define SQLITE_LOCK_EXCLUSIVE     4
-
-/*
- * CAPI3REF: Synchronization Type Flags
- *
- * When SQLite invokes the xSync() method of an
- * [sqlite3_io_methods] object it uses a combination of
- * these integer values as the second argument.
- *
- * When the SQLITE_SYNC_DATAONLY flag is used, it means that the
- * sync operation only needs to flush data to mass storage.  Inode
- * information need not be flushed. If the lower four bits of the flag
- * equal SQLITE_SYNC_NORMAL, that means to use normal fsync() semantics.
- * If the lower four bits equal SQLITE_SYNC_FULL, that means
- * to use Mac OS X style fullsync instead of fsync().
- *
- * Do not confuse the SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags
- * with the [PRAGMA synchronous]=NORMAL and [PRAGMA synchronous]=FULL
- * settings.  The [synchronous pragma] determines when calls to the
- * xSync VFS method occur and applies uniformly across all platforms.
- * The SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL flags determine how
- * energetic or rigorous or forceful the sync operations are and
- * only make a difference on Mac OSX for the default SQLite code.
- * (Third-party VFS implementations might also make the distinction
- * between SQLITE_SYNC_NORMAL and SQLITE_SYNC_FULL, but among the
- * operating systems natively supported by SQLite, only Mac OSX
- * cares about the difference.)
-*/
-#define SQLITE_SYNC_NORMAL        0x00002
-#define SQLITE_SYNC_FULL          0x00003
-#define SQLITE_SYNC_DATAONLY      0x00010
-
-/*
- * CAPI3REF: OS Interface Open File Handle
- *
- * An [sqlite3_file] object represents an open file in the
- * [sqlite3_vfs | OS interface layer].  Individual OS interface
- * implementations will
- * want to subclass this object by appending additional fields
- * for their own use.  The pMethods entry is a pointer to an
- * [sqlite3_io_methods] object that defines methods for performing
- * I/O operations on the open file.
-*/
-typedef struct sqlite3_file sqlite3_file;
-struct sqlite3_file {
-	const struct sqlite3_io_methods *pMethods;	/* Methods for an open file */
-};
-
-/*
- * CAPI3REF: OS Interface File Virtual Methods Object
- *
- * Every file opened by the [sqlite3_vfs.xOpen] method populates an
- * [sqlite3_file] object (or, more commonly, a subclass of the
- * [sqlite3_file] object) with a pointer to an instance of this object.
- * This object defines the methods used to perform various operations
- * against the open file represented by the [sqlite3_file] object.
- *
- * If the [sqlite3_vfs.xOpen] method sets the sqlite3_file.pMethods element
- * to a non-NULL pointer, then the sqlite3_io_methods.xClose method
- * may be invoked even if the [sqlite3_vfs.xOpen] reported that it failed.  The
- * only way to prevent a call to xClose following a failed [sqlite3_vfs.xOpen]
- * is for the [sqlite3_vfs.xOpen] to set the sqlite3_file.pMethods element
- * to NULL.
- *
- * The flags argument to xSync may be one of [SQLITE_SYNC_NORMAL] or
- * [SQLITE_SYNC_FULL].  The first choice is the normal fsync().
- * The second choice is a Mac OS X style fullsync.  The [SQLITE_SYNC_DATAONLY]
- * flag may be ORed in to indicate that only the data of the file
- * and not its inode needs to be synced.
- *
- * The integer values to xLock() and xUnlock() are one of
- * <ul>
- * <li> [SQLITE_LOCK_NONE],
- * <li> [SQLITE_LOCK_SHARED],
- * <li> [SQLITE_LOCK_RESERVED],
- * <li> [SQLITE_LOCK_PENDING], or
- * <li> [SQLITE_LOCK_EXCLUSIVE].
- * </ul>
- * xLock() increases the lock. xUnlock() decreases the lock.
- * The xCheckReservedLock() method checks whether any database connection,
- * either in this process or in some other process, is holding a RESERVED,
- * PENDING, or EXCLUSIVE lock on the file.  It returns true
- * if such a lock exists and false otherwise.
- *
- * The xFileControl() method is a generic interface that allows custom
- * VFS implementations to directly control an open file using the
- * [sqlite3_file_control()] interface.  The second "op" argument is an
- * integer opcode.  The third argument is a generic pointer intended to
- * point to a structure that may contain arguments or space in which to
- * write return values.  Potential uses for xFileControl() might be
- * functions to enable blocking locks with timeouts, to change the
- * locking strategy (for example to use dot-file locks), to inquire
- * about the status of a lock, or to break stale locks.  The SQLite
- * core reserves all opcodes less than 100 for its own use.
- * A [file control opcodes | list of opcodes] less than 100 is available.
- * Applications that define a custom xFileControl method should use opcodes
- * greater than 100 to avoid conflicts.  VFS implementations should
- * return [SQLITE_NOTFOUND] for file control opcodes that they do not
- * recognize.
- *
- * The xSectorSize() method returns the sector size of the
- * device that underlies the file.  The sector size is the
- * minimum write that can be performed without disturbing
- * other bytes in the file.  The xDeviceCharacteristics()
- * method returns a bit vector describing behaviors of the
- * underlying device:
- *
- * <ul>
- * <li> [SQLITE_IOCAP_ATOMIC]
- * <li> [SQLITE_IOCAP_ATOMIC512]
- * <li> [SQLITE_IOCAP_ATOMIC1K]
- * <li> [SQLITE_IOCAP_ATOMIC2K]
- * <li> [SQLITE_IOCAP_ATOMIC4K]
- * <li> [SQLITE_IOCAP_ATOMIC8K]
- * <li> [SQLITE_IOCAP_ATOMIC16K]
- * <li> [SQLITE_IOCAP_ATOMIC32K]
- * <li> [SQLITE_IOCAP_ATOMIC64K]
- * <li> [SQLITE_IOCAP_SAFE_APPEND]
- * <li> [SQLITE_IOCAP_SEQUENTIAL]
- * </ul>
- *
- * The SQLITE_IOCAP_ATOMIC property means that all writes of
- * any size are atomic.  The SQLITE_IOCAP_ATOMICnnn values
- * mean that writes of blocks that are nnn bytes in size and
- * are aligned to an address which is an integer multiple of
- * nnn are atomic.  The SQLITE_IOCAP_SAFE_APPEND value means
- * that when data is appended to a file, the data is appended
- * first then the size of the file is extended, never the other
- * way around.  The SQLITE_IOCAP_SEQUENTIAL property means that
- * information is written to disk in the same order as calls
- * to xWrite().
- *
- * If xRead() returns SQLITE_IOERR_SHORT_READ it must also fill
- * in the unread portions of the buffer with zeros.  A VFS that
- * fails to zero-fill short reads might seem to work.  However,
- * failure to zero-fill short reads will eventually lead to
- * database corruption.
-*/
-typedef struct sqlite3_io_methods sqlite3_io_methods;
-struct sqlite3_io_methods {
-	int iVersion;
-	int (*xClose) (sqlite3_file *);
-	int (*xRead) (sqlite3_file *, void *, int iAmt,
-		      sqlite3_int64 iOfst);
-	int (*xWrite) (sqlite3_file *, const void *, int iAmt,
-		       sqlite3_int64 iOfst);
-	int (*xTruncate) (sqlite3_file *, sqlite3_int64 size);
-	int (*xSync) (sqlite3_file *, int flags);
-	int (*xFileSize) (sqlite3_file *, sqlite3_int64 * pSize);
-	int (*xLock) (sqlite3_file *, int);
-	int (*xUnlock) (sqlite3_file *, int);
-	int (*xCheckReservedLock) (sqlite3_file *, int *pResOut);
-	int (*xFileControl) (sqlite3_file *, int op, void *pArg);
-	int (*xSectorSize) (sqlite3_file *);
-	int (*xDeviceCharacteristics) (sqlite3_file *);
-	/* Methods above are valid for version 1 */
-	int (*xShmMap) (sqlite3_file *, int iPg, int pgsz, int,
-			void volatile **);
-	int (*xShmLock) (sqlite3_file *, int offset, int n, int flags);
-	void (*xShmBarrier) (sqlite3_file *);
-	int (*xShmUnmap) (sqlite3_file *, int deleteFlag);
-	/* Methods above are valid for version 2 */
-	int (*xFetch) (sqlite3_file *, sqlite3_int64 iOfst, int iAmt,
-		       void **pp);
-	int (*xUnfetch) (sqlite3_file *, sqlite3_int64 iOfst, void *p);
-	/* Methods above are valid for version 3 */
-	/* Additional methods may be added in future releases */
-};
-
-/*
- * CAPI3REF: Standard File Control Opcodes
- * KEYWORDS: {file control opcodes} {file control opcode}
- *
- * These integer constants are opcodes for the xFileControl method
- * of the [sqlite3_io_methods] object and for the [sqlite3_file_control()]
- * interface.
- *
- * <ul>
- * <li>[[SQLITE_FCNTL_LOCKSTATE]]
- * The [SQLITE_FCNTL_LOCKSTATE] opcode is used for debugging.  This
- * opcode causes the xFileControl method to write the current state of
- * the lock (one of [SQLITE_LOCK_NONE], [SQLITE_LOCK_SHARED],
- * [SQLITE_LOCK_RESERVED], [SQLITE_LOCK_PENDING], or [SQLITE_LOCK_EXCLUSIVE])
- * into an integer that the pArg argument points to. This capability
- * is used during testing and is only available when the SQLITE_TEST
- * compile-time option is used.
- *
- * <li>[[SQLITE_FCNTL_SIZE_HINT]]
- * The [SQLITE_FCNTL_SIZE_HINT] opcode is used by SQLite to give the VFS
- * layer a hint of how large the database file will grow to be during the
- * current transaction.  This hint is not guaranteed to be accurate but it
- * is often close.  The underlying VFS might choose to preallocate database
- * file space based on this hint in order to help writes to the database
- * file run faster.
- *
- * <li>[[SQLITE_FCNTL_CHUNK_SIZE]]
- * The [SQLITE_FCNTL_CHUNK_SIZE] opcode is used to request that the VFS
- * extends and truncates the database file in chunks of a size specified
- * by the user. The fourth argument to [sqlite3_file_control()] should
- * point to an integer (type int) containing the new chunk-size to use
- * for the nominated database. Allocating database file space in large
- * chunks (say 1MB at a time), may reduce file-system fragmentation and
- * improve performance on some systems.
- *
- * <li>[[SQLITE_FCNTL_FILE_POINTER]]
- * The [SQLITE_FCNTL_FILE_POINTER] opcode is used to obtain a pointer
- * to the [sqlite3_file] object associated with a particular database
- * connection.
- *
- * <li>[[SQLITE_FCNTL_SYNC_OMITTED]]
- * No longer in use.
- *
- * <li>[[SQLITE_FCNTL_SYNC]]
- * The [SQLITE_FCNTL_SYNC] opcode is generated internally by SQLite and
- * sent to the VFS immediately before the xSync method is invoked on a
- * database file descriptor. Or, if the xSync method is not invoked
- * because the user has configured SQLite with
- * [PRAGMA synchronous | PRAGMA synchronous=OFF] it is invoked in place
- * of the xSync method. In most cases, the pointer argument passed with
- * this file-control is NULL. However, if the database file is being synced
- * as part of a multi-database commit, the argument points to a nul-terminated
- * string containing the transactions master-journal file name. VFSes that
- * do not need this signal should silently ignore this opcode. Applications
- * should not call [sqlite3_file_control()] with this opcode as doing so may
- * disrupt the operation of the specialized VFSes that do require it.
- *
- * <li>[[SQLITE_FCNTL_COMMIT_PHASETWO]]
- * The [SQLITE_FCNTL_COMMIT_PHASETWO] opcode is generated internally by SQLite
- * and sent to the VFS after a transaction has been committed immediately
- * but before the database is unlocked. VFSes that do not need this signal
- * should silently ignore this opcode. Applications should not call
- * [sqlite3_file_control()] with this opcode as doing so may disrupt the
- * operation of the specialized VFSes that do require it.
- *
- * <li>[[SQLITE_FCNTL_POWERSAFE_OVERWRITE]]
- * ^The [SQLITE_FCNTL_POWERSAFE_OVERWRITE] opcode is used to set or query the
- * persistent "powersafe-overwrite" or "PSOW" setting.  The PSOW setting
- * determines the [SQLITE_IOCAP_POWERSAFE_OVERWRITE] bit of the
- * xDeviceCharacteristics methods. The fourth parameter to
- * [sqlite3_file_control()] for this opcode should be a pointer to an integer.
- * That integer is 0 to disable zero-damage mode or 1 to enable zero-damage
- * mode.  If the integer is -1, then it is overwritten with the current
- * zero-damage mode setting.
- *
- * <li>[[SQLITE_FCNTL_OVERWRITE]]
- * ^The [SQLITE_FCNTL_OVERWRITE] opcode is invoked by SQLite after opening
- * a write transaction to indicate that, unless it is rolled back for some
- * reason, the entire database file will be overwritten by the current
- * transaction.
- *
- * <li>[[SQLITE_FCNTL_VFSNAME]]
- * ^The [SQLITE_FCNTL_VFSNAME] opcode can be used to obtain the names of
- * all [VFSes] in the VFS stack.  The names are of all VFS shims and the
- * final bottom-level VFS are written into memory obtained from
- * [sqlite3_malloc()] and the result is stored in the char* variable
- * that the fourth parameter of [sqlite3_file_control()] points to.
- * The caller is responsible for freeing the memory when done.  As with
- * all file-control actions, there is no guarantee that this will actually
- * do anything.  Callers should initialize the char* variable to a NULL
- * pointer in case this file-control is not implemented.  This file-control
- * is intended for diagnostic use only.
- *
- * <li>[[SQLITE_FCNTL_VFS_POINTER]]
- * ^The [SQLITE_FCNTL_VFS_POINTER] opcode finds a pointer to the top-level
- * [VFSes] currently in use.  ^(The argument X in
- * sqlite3_file_control(db,SQLITE_FCNTL_VFS_POINTER,X) must be
- * of type "[sqlite3_vfs] **".  This opcodes will set *X
- * to a pointer to the top-level VFS.)^
- * ^When there are multiple VFS shims in the stack, this opcode finds the
- * upper-most shim only.
- *
- * <li>[[SQLITE_FCNTL_PRAGMA]]
- * ^Whenever a [PRAGMA] statement is parsed, an [SQLITE_FCNTL_PRAGMA]
- * file control is sent to the open [sqlite3_file] object corresponding
- * to the database file to which the pragma statement refers. ^The argument
- * to the [SQLITE_FCNTL_PRAGMA] file control is an array of
- * pointers to strings (char**) in which the second element of the array
- * is the name of the pragma and the third element is the argument to the
- * pragma or NULL if the pragma has no argument.  ^The handler for an
- * [SQLITE_FCNTL_PRAGMA] file control can optionally make the first element
- * of the char** argument point to a string obtained from [sqlite3_mprintf()]
- * or the equivalent and that string will become the result of the pragma or
- * the error message if the pragma fails. ^If the
- * [SQLITE_FCNTL_PRAGMA] file control returns [SQLITE_NOTFOUND], then normal
- * [PRAGMA] processing continues.  ^If the [SQLITE_FCNTL_PRAGMA]
- * file control returns [SQLITE_OK], then the parser assumes that the
- * VFS has handled the PRAGMA itself and the parser generates a no-op
- * prepared statement if result string is NULL, or that returns a copy
- * of the result string if the string is non-NULL.
- * ^If the [SQLITE_FCNTL_PRAGMA] file control returns
- * any result code other than [SQLITE_OK] or [SQLITE_NOTFOUND], that means
- * that the VFS encountered an error while handling the [PRAGMA] and the
- * compilation of the PRAGMA fails with an error.  ^The [SQLITE_FCNTL_PRAGMA]
- * file control occurs at the beginning of pragma statement analysis and so
- * it is able to override built-in [PRAGMA] statements.
- *
- * <li>[[SQLITE_FCNTL_BUSYHANDLER]]
- * ^The [SQLITE_FCNTL_BUSYHANDLER]
- * file-control may be invoked by SQLite on the database file handle
- * shortly after it is opened in order to provide a custom VFS with access
- * to the connections busy-handler callback. The argument is of type (void **)
- * - an array of two (void *) values. The first (void *) actually points
- * to a function of type (int (*)(void *)). In order to invoke the connections
- * busy-handler, this function should be invoked with the second (void *) in
- * the array as the only argument. If it returns non-zero, then the operation
- * should be retried. If it returns zero, the custom VFS should abandon the
- * current operation.
- *
- * <li>[[SQLITE_FCNTL_TEMPFILENAME]]
- * ^Application can invoke the [SQLITE_FCNTL_TEMPFILENAME] file-control
- * to have SQLite generate a
- * temporary filename using the same algorithm that is followed to generate
- * temporary filenames for TEMP tables and other internal uses.  The
- * argument should be a char** which will be filled with the filename
- * written into memory obtained from [sqlite3_malloc()].  The caller should
- * invoke [sqlite3_free()] on the result to avoid a memory leak.
- *
- * <li>[[SQLITE_FCNTL_MMAP_SIZE]]
- * The [SQLITE_FCNTL_MMAP_SIZE] file control is used to query or set the
- * maximum number of bytes that will be used for memory-mapped I/O.
- * The argument is a pointer to a value of type sqlite3_int64 that
- * is an advisory maximum number of bytes in the file to memory map.  The
- * pointer is overwritten with the old value.  The limit is not changed if
- * the value originally pointed to is negative, and so the current limit
- * can be queried by passing in a pointer to a negative number.  This
- * file-control is used internally to implement [PRAGMA mmap_size].
- *
- * <li>[[SQLITE_FCNTL_TRACE]]
- * The [SQLITE_FCNTL_TRACE] file control provides advisory information
- * to the VFS about what the higher layers of the SQLite stack are doing.
- * This file control is used by some VFS activity tracing [shims].
- * The argument is a zero-terminated string.  Higher layers in the
- * SQLite stack may generate instances of this file control if
- * the [SQLITE_USE_FCNTL_TRACE] compile-time option is enabled.
- *
- * <li>[[SQLITE_FCNTL_HAS_MOVED]]
- * The [SQLITE_FCNTL_HAS_MOVED] file control interprets its argument as a
- * pointer to an integer and it writes a boolean into that integer depending
- * on whether or not the file has been renamed, moved, or deleted since it
- * was first opened.
- *
- * <li>[[SQLITE_FCNTL_ZIPVFS]]
- * The [SQLITE_FCNTL_ZIPVFS] opcode is implemented by zipvfs only. All other
- * VFS should return SQLITE_NOTFOUND for this opcode.
- *
- * <li>[[SQLITE_FCNTL_RBU]]
- * The [SQLITE_FCNTL_RBU] opcode is implemented by the special VFS used by
- * the RBU extension only.  All other VFS should return SQLITE_NOTFOUND for
- * this opcode.
- * </ul>
-*/
-#define SQLITE_FCNTL_LOCKSTATE               1
-#define SQLITE_FCNTL_GET_LOCKPROXYFILE       2
-#define SQLITE_FCNTL_SET_LOCKPROXYFILE       3
-#define SQLITE_FCNTL_LAST_ERRNO              4
-#define SQLITE_FCNTL_SIZE_HINT               5
-#define SQLITE_FCNTL_CHUNK_SIZE              6
-#define SQLITE_FCNTL_FILE_POINTER            7
-#define SQLITE_FCNTL_SYNC_OMITTED            8
-#define SQLITE_FCNTL_OVERWRITE              10
-#define SQLITE_FCNTL_VFSNAME                11
-#define SQLITE_FCNTL_POWERSAFE_OVERWRITE    12
-#define SQLITE_FCNTL_PRAGMA                 13
-#define SQLITE_FCNTL_BUSYHANDLER            14
-#define SQLITE_FCNTL_TEMPFILENAME           15
-#define SQLITE_FCNTL_MMAP_SIZE              16
-#define SQLITE_FCNTL_TRACE                  17
-#define SQLITE_FCNTL_HAS_MOVED              18
-#define SQLITE_FCNTL_SYNC                   19
-#define SQLITE_FCNTL_COMMIT_PHASETWO        20
-#define SQLITE_FCNTL_ZIPVFS                 22
-#define SQLITE_FCNTL_RBU                    23
-#define SQLITE_FCNTL_VFS_POINTER            24
-#define SQLITE_FCNTL_PDB                    26
-
-/*
- * CAPI3REF: Mutex Handle
- *
- * The mutex module within SQLite defines [sqlite3_mutex] to be an
- * abstract type for a mutex object.  The SQLite core never looks
- * at the internal representation of an [sqlite3_mutex].  It only
- * deals with pointers to the [sqlite3_mutex] object.
- *
- * Mutexes are created using [sqlite3_mutex_alloc()].
-*/
-typedef struct sqlite3_mutex sqlite3_mutex;
-
-/*
- * CAPI3REF: Loadable Extension Thunk
- *
- * A pointer to the opaque sqlite3_api_routines structure is passed as
- * the third parameter to entry points of [loadable extensions].  This
- * structure must be typedefed in order to work around compiler warnings
- * on some platforms.
-*/
-typedef struct sqlite3_api_routines sqlite3_api_routines;
-
-/*
- * CAPI3REF: OS Interface Object
- *
- * An instance of the sqlite3_vfs object defines the interface between
- * the SQLite core and the underlying operating system.  The "vfs"
- * in the name of the object stands for "virtual file system".  See
- * the [VFS | VFS documentation] for further information.
- *
- * The value of the iVersion field is initially 1 but may be larger in
- * future versions of SQLite.  Additional fields may be appended to this
- * object when the iVersion value is increased.  Note that the structure
- * of the sqlite3_vfs object changes in the transaction between
- * SQLite version 3.5.9 and 3.6.0 and yet the iVersion field was not
- * modified.
- *
- * The szOsFile field is the size of the subclassed [sqlite3_file]
- * structure used by this VFS.  mxPathname is the maximum length of
- * a pathname in this VFS.
- *
- * Registered sqlite3_vfs objects are kept on a linked list formed by
- * the pNext pointer.  The [sqlite3_vfs_register()]
- * and [sqlite3_vfs_unregister()] interfaces manage this list
- * in a thread-safe way.  The [sqlite3_vfs_find()] interface
- * searches the list.  Neither the application code nor the VFS
- * implementation should use the pNext pointer.
- *
- * The pNext field is the only field in the sqlite3_vfs
- * structure that SQLite will ever modify.  SQLite will only access
- * or modify this field while holding a particular static mutex.
- * The application should never modify anything within the sqlite3_vfs
- * object once the object has been registered.
- *
- * The zName field holds the name of the VFS module.  The name must
- * be unique across all VFS modules.
- *
- * [[sqlite3_vfs.xOpen]]
- * ^SQLite guarantees that the zFilename parameter to xOpen
- * is either a NULL pointer or string obtained
- * from xFullPathname() with an optional suffix added.
- * ^If a suffix is added to the zFilename parameter, it will
- * consist of a single "-" character followed by no more than
- * 11 alphanumeric and/or "-" characters.
- * ^SQLite further guarantees that
- * the string will be valid and unchanged until xClose() is
- * called. Because of the previous sentence,
- * the [sqlite3_file] can safely store a pointer to the
- * filename if it needs to remember the filename for some reason.
- * If the zFilename parameter to xOpen is a NULL pointer then xOpen
- * must invent its own temporary name for the file.  ^Whenever the
- * xFilename parameter is NULL it will also be the case that the
- * flags parameter will include [SQLITE_OPEN_DELETEONCLOSE].
- *
- * The flags argument to xOpen() includes all bits set in
- * the flags argument to [sqlite3_open_v2()].  Or if [sqlite3_open()]
- * or is used, then flags includes at least
- * [SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE].
- * If xOpen() opens a file read-only then it sets *pOutFlags to
- * include [SQLITE_OPEN_READONLY].  Other bits in *pOutFlags may be set.
- *
- * ^(SQLite will also add one of the following flags to the xOpen()
- * call, depending on the object being opened:
- *
- * <ul>
- * <li>  [SQLITE_OPEN_MAIN_DB]
- * <li>  [SQLITE_OPEN_TEMP_DB]
- * <li>  [SQLITE_OPEN_TRANSIENT_DB]
- * </ul>)^
- *
- * The file I/O implementation can use the object type flags to
- * change the way it deals with files.  For example, an application
- * that does not care about crash recovery or rollback might make
- * the open of a journal file a no-op.  Writes to this journal would
- * also be no-ops, and any attempt to read the journal would return
- * SQLITE_IOERR.  Or the implementation might recognize that a database
- * file will be doing page-aligned sector reads and writes in a random
- * order and set up its I/O subsystem accordingly.
- *
- * SQLite might also add one of the following flags to the xOpen method:
- *
- * <ul>
- * <li> [SQLITE_OPEN_DELETEONCLOSE]
- * <li> [SQLITE_OPEN_EXCLUSIVE]
- * </ul>
- *
- * The [SQLITE_OPEN_DELETEONCLOSE] flag means the file should be
- * deleted when it is closed.  ^The [SQLITE_OPEN_DELETEONCLOSE]
- * will be set for TEMP databases and their journals, transient
- * databases, and subjournals.
- *
- * ^The [SQLITE_OPEN_EXCLUSIVE] flag is always used in conjunction
- * with the [SQLITE_OPEN_CREATE] flag, which are both directly
- * analogous to the O_EXCL and O_CREAT flags of the POSIX open()
- * API.  The SQLITE_OPEN_EXCLUSIVE flag, when paired with the
- * SQLITE_OPEN_CREATE, is used to indicate that file should always
- * be created, and that it is an error if it already exists.
- * It is <i>not</i> used to indicate the file should be opened
- * for exclusive access.
- *
- * ^At least szOsFile bytes of memory are allocated by SQLite
- * to hold the  [sqlite3_file] structure passed as the third
- * argument to xOpen.  The xOpen method does not have to
- * allocate the structure; it should just fill it in.  Note that
- * the xOpen method must set the sqlite3_file.pMethods to either
- * a valid [sqlite3_io_methods] object or to NULL.  xOpen must do
- * this even if the open fails.  SQLite expects that the sqlite3_file.pMethods
- * element will be valid after xOpen returns regardless of the success
- * or failure of the xOpen call.
- *
- * [[sqlite3_vfs.xAccess]]
- * ^The flags argument to xAccess() may be [SQLITE_ACCESS_EXISTS]
- * to test for the existence of a file, or [SQLITE_ACCESS_READWRITE] to
- * test whether a file is readable and writable, or [SQLITE_ACCESS_READ]
- * to test whether a file is at least readable.   The file can be a
- * directory.
- *
- * ^SQLite will always allocate at least mxPathname+1 bytes for the
- * output buffer xFullPathname.  The exact size of the output buffer
- * is also passed as a parameter to both  methods. If the output buffer
- * is not large enough, [SQLITE_CANTOPEN] should be returned. Since this is
- * handled as a fatal error by SQLite, vfs implementations should endeavor
- * to prevent this by setting mxPathname to a sufficiently large value.
- *
- * The xRandomness(), xSleep(), xCurrentTime(), and xCurrentTimeInt64()
- * interfaces are not strictly a part of the filesystem, but they are
- * included in the VFS structure for completeness.
- * The xRandomness() function attempts to return nBytes bytes
- * of good-quality randomness into zOut.  The return value is
- * the actual number of bytes of randomness obtained.
- * The xSleep() method causes the calling thread to sleep for at
- * least the number of microseconds given.  ^The xCurrentTime()
- * method returns a Julian Day Number for the current date and time as
- * a floating point value.
- * ^The xCurrentTimeInt64() method returns, as an integer, the Julian
- * Day Number multiplied by 86400000 (the number of milliseconds in
- * a 24-hour day).
- * ^SQLite will use the xCurrentTimeInt64() method to get the current
- * date and time if that method is available (if iVersion is 2 or
- * greater and the function pointer is not NULL) and will fall back
- * to xCurrentTime() if xCurrentTimeInt64() is unavailable.
- *
- * ^The xSetSystemCall(), xGetSystemCall(), and xNestSystemCall() interfaces
- * are not used by the SQLite core.  These optional interfaces are provided
- * by some VFSes to facilitate testing of the VFS code. By overriding
- * system calls with functions under its control, a test program can
- * simulate faults and error conditions that would otherwise be difficult
- * or impossible to induce.  The set of system calls that can be overridden
- * varies from one VFS to another, and from one version of the same VFS to the
- * next.  Applications that use these interfaces must be prepared for any
- * or all of these interfaces to be NULL or for their behavior to change
- * from one release to the next.  Applications must not attempt to access
- * any of these methods if the iVersion of the VFS is less than 3.
-*/
-typedef struct sqlite3_vfs sqlite3_vfs;
-typedef void (*sqlite3_syscall_ptr) (void);
-struct sqlite3_vfs {
-	int iVersion;	/* Structure version number (currently 3) */
-	int szOsFile;	/* Size of subclassed sqlite3_file */
-	int mxPathname;	/* Maximum file pathname length */
-	sqlite3_vfs *pNext;	/* Next registered VFS */
-	const char *zName;	/* Name of this virtual file system */
-	void *pAppData;	/* Pointer to application-specific data */
-	int (*xOpen) (sqlite3_vfs *, const char *zName, sqlite3_file *,
-		      int flags, int *pOutFlags);
-	int (*xDelete) (sqlite3_vfs *, const char *zName, int syncDir);
-	int (*xAccess) (sqlite3_vfs *, const char *zName, int flags,
-			int *pResOut);
-	int (*xFullPathname) (sqlite3_vfs *, const char *zName,
-			      int nOut, char *zOut);
-	void *(*xDlOpen) (sqlite3_vfs *, const char *zFilename);
-	void (*xDlError) (sqlite3_vfs *, int nByte, char *zErrMsg);
-	void (*(*xDlSym) (sqlite3_vfs *, void *, const char *zSymbol))
-	(void);
-	void (*xDlClose) (sqlite3_vfs *, void *);
-	int (*xRandomness) (sqlite3_vfs *, int nByte, char *zOut);
-	int (*xSleep) (sqlite3_vfs *, int microseconds);
-	int (*xCurrentTime) (sqlite3_vfs *, double *);
-	int (*xGetLastError) (sqlite3_vfs *, int, char *);
-	/*
-	** The methods above are in version 1 of the sqlite_vfs object
-	** definition.  Those that follow are added in version 2 or later
-	*/
-	int (*xCurrentTimeInt64) (sqlite3_vfs *, sqlite3_int64 *);
-	/*
-	** The methods above are in versions 1 and 2 of the sqlite_vfs object.
-	** Those below are for version 3 and greater.
-	*/
-	int (*xSetSystemCall) (sqlite3_vfs *, const char *zName,
-			       sqlite3_syscall_ptr);
-	sqlite3_syscall_ptr(*xGetSystemCall) (sqlite3_vfs *,
-					      const char *zName);
-	const char *(*xNextSystemCall) (sqlite3_vfs *,
-					const char *zName);
-	/*
-	** The methods above are in versions 1 through 3 of the sqlite_vfs object.
-	** New fields may be appended in future versions.  The iVersion
-	** value will increment whenever this happens.
-	*/
-};
-
-/*
- * CAPI3REF: Flags for the xAccess VFS method
- *
- * These integer constants can be used as the third parameter to
- * the xAccess method of an [sqlite3_vfs] object.  They determine
- * what kind of permissions the xAccess method is looking for.
- * With SQLITE_ACCESS_EXISTS, the xAccess method
- * simply checks whether the file exists.
- * With SQLITE_ACCESS_READWRITE, the xAccess method
- * checks whether the named directory is both readable and writable
- * (in other words, if files can be added, removed, and renamed within
- * the directory).
- * The SQLITE_ACCESS_READWRITE constant is currently used only by the
- * [temp_store_directory pragma], though this could change in a future
- * release of SQLite.
- * With SQLITE_ACCESS_READ, the xAccess method
- * checks whether the file is readable.  The SQLITE_ACCESS_READ constant is
- * currently unused, though it might be used in a future release of
- * SQLite.
-*/
-#define SQLITE_ACCESS_EXISTS    0
-#define SQLITE_ACCESS_READWRITE 1	/* Used by PRAGMA temp_store_directory */
-#define SQLITE_ACCESS_READ      2	/* Unused */
-
-/*
- * CAPI3REF: Flags for the xShmLock VFS method
- *
- * These integer constants define the various locking operations
- * allowed by the xShmLock method of [sqlite3_io_methods].  The
- * following are the only legal combinations of flags to the
- * xShmLock method:
- *
- * <ul>
- * <li>  SQLITE_SHM_LOCK | SQLITE_SHM_SHARED
- * <li>  SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE
- * <li>  SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED
- * <li>  SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE
- * </ul>
- *
- * When unlocking, the same SHARED or EXCLUSIVE flag must be supplied as
- * was given on the corresponding lock.
- *
- * The xShmLock method can transition between unlocked and SHARED or
- * between unlocked and EXCLUSIVE.  It cannot transition between SHARED
- * and EXCLUSIVE.
-*/
-#define SQLITE_SHM_UNLOCK       1
-#define SQLITE_SHM_LOCK         2
-#define SQLITE_SHM_SHARED       4
-#define SQLITE_SHM_EXCLUSIVE    8
-
-/*
- * CAPI3REF: Maximum xShmLock index
- *
- * The xShmLock method on [sqlite3_io_methods] may use values
- * between 0 and this upper bound as its "offset" argument.
- * The SQLite core will never attempt to acquire or release a
- * lock outside of this range
-*/
-#define SQLITE_SHM_NLOCK        8
-
-/*
- * CAPI3REF: Initialize The SQLite Library
- *
- * ^The sqlite3_initialize() routine initializes the
- * SQLite library.  ^The sqlite3_shutdown() routine
- * deallocates any resources that were allocated by sqlite3_initialize().
- * These routines are designed to aid in process initialization and
- * shutdown on embedded systems.  Workstation applications using
- * SQLite normally do not need to invoke either of these routines.
- *
- * A call to sqlite3_initialize() is an "effective" call if it is
- * the first time sqlite3_initialize() is invoked during the lifetime of
- * the process, or if it is the first time sqlite3_initialize() is invoked
- * following a call to sqlite3_shutdown().  ^(Only an effective call
- * of sqlite3_initialize() does any initialization.  All other calls
- * are harmless no-ops.)^
- *
- * A call to sqlite3_shutdown() is an "effective" call if it is the first
- * call to sqlite3_shutdown() since the last sqlite3_initialize().  ^(Only
- * an effective call to sqlite3_shutdown() does any deinitialization.
- * All other valid calls to sqlite3_shutdown() are harmless no-ops.)^
- *
- * The sqlite3_initialize() interface is threadsafe, but sqlite3_shutdown()
- * is not.  The sqlite3_shutdown() interface must only be called from a
- * single thread.  All open [database connections] must be closed and all
- * other SQLite resources must be deallocated prior to invoking
- * sqlite3_shutdown().
- *
- * Among other things, ^sqlite3_initialize() will invoke
- * sqlite3_os_init().  Similarly, ^sqlite3_shutdown()
- * will invoke sqlite3_os_end().
- *
- * ^The sqlite3_initialize() routine returns [SQLITE_OK] on success.
- * ^If for some reason, sqlite3_initialize() is unable to initialize
- * the library (perhaps it is unable to allocate a needed resource such
- * as a mutex) it returns an [error code] other than [SQLITE_OK].
- *
- * ^The sqlite3_initialize() routine is called internally by many other
- * SQLite interfaces so that an application usually does not need to
- * invoke sqlite3_initialize() directly.  For example, [sqlite3_open()]
- * calls sqlite3_initialize() so the SQLite library will be automatically
- * initialized when [sqlite3_open()] is called if it has not be initialized
- * already.  ^However, if SQLite is compiled with the [SQLITE_OMIT_AUTOINIT]
- * compile-time option, then the automatic calls to sqlite3_initialize()
- * are omitted and the application must call sqlite3_initialize() directly
- * prior to using any other SQLite interface.  For maximum portability,
- * it is recommended that applications always invoke sqlite3_initialize()
- * directly prior to using any other SQLite interface.  Future releases
- * of SQLite may require this.  In other words, the behavior exhibited
- * when SQLite is compiled with [SQLITE_OMIT_AUTOINIT] might become the
- * default behavior in some future release of SQLite.
- *
- * The sqlite3_os_init() routine does operating-system specific
- * initialization of the SQLite library.  The sqlite3_os_end()
- * routine undoes the effect of sqlite3_os_init().  Typical tasks
- * performed by these routines include allocation or deallocation
- * of static resources, initialization of global variables,
- * setting up a default [sqlite3_vfs] module, or setting up
- * a default configuration using [sqlite3_config()].
- *
- * The application should never invoke either sqlite3_os_init()
- * or sqlite3_os_end() directly.  The application should only invoke
- * sqlite3_initialize() and sqlite3_shutdown().  The sqlite3_os_init()
- * interface is called automatically by sqlite3_initialize() and
- * sqlite3_os_end() is called by sqlite3_shutdown().  Appropriate
- * implementations for sqlite3_os_init() and sqlite3_os_end()
- * are built into SQLite when it is compiled for Unix or OS/2.
-*/
-SQLITE_API int
-sqlite3_initialize(void);
-
-SQLITE_API int
-sqlite3_shutdown(void);
-
-SQLITE_API int
-sqlite3_os_init(void);
-
-SQLITE_API int
-sqlite3_os_end(void);
-
-/*
- * CAPI3REF: Configuring The SQLite Library
- *
- * The sqlite3_config() interface is used to make global configuration
- * changes to SQLite in order to tune SQLite to the specific needs of
- * the application.  The default configuration is recommended for most
- * applications and so this routine is usually not necessary.  It is
- * provided to support rare applications with unusual needs.
- *
- * <b>The sqlite3_config() interface is not threadsafe. The application
- * must ensure that no other SQLite interfaces are invoked by other
- * threads while sqlite3_config() is running.</b>
- *
- * The sqlite3_config() interface
- * may only be invoked prior to library initialization using
- * [sqlite3_initialize()] or after shutdown by [sqlite3_shutdown()].
- * ^If sqlite3_config() is called after [sqlite3_initialize()] and before
- * [sqlite3_shutdown()] then it will return SQLITE_MISUSE.
- * Note, however, that ^sqlite3_config() can be called as part of the
- * implementation of an application-defined [sqlite3_os_init()].
- *
- * The first argument to sqlite3_config() is an integer
- * [configuration option] that determines
- * what property of SQLite is to be configured.  Subsequent arguments
- * vary depending on the [configuration option]
- * in the first argument.
- *
- * ^When a configuration option is set, sqlite3_config() returns [SQLITE_OK].
- * ^If the option is unknown or SQLite is unable to set the option
- * then this routine returns a non-zero [error code].
-*/
-SQLITE_API int
-sqlite3_config(int, ...);
-
-/*
- * CAPI3REF: Configure database connections
- * METHOD: sqlite3
- *
- * The sqlite3_db_config() interface is used to make configuration
- * changes to a [database connection].  The interface is similar to
- * [sqlite3_config()] except that the changes apply to a single
- * [database connection] (specified in the first argument).
- *
- * The second argument to sqlite3_db_config(D,V,...)  is the
- * [SQLITE_DBCONFIG_LOOKASIDE | configuration verb] - an integer code
- * that indicates what aspect of the [database connection] is being configured.
- * Subsequent arguments vary depending on the configuration verb.
- *
- * ^Calls to sqlite3_db_config() return SQLITE_OK if and only if
- * the call is considered successful.
-*/
-SQLITE_API int
-sqlite3_db_config(sqlite3 *, int op, ...);
-
-/*
- * CAPI3REF: Memory Allocation Routines
- *
- * An instance of this object defines the interface between SQLite
- * and low-level memory allocation routines.
- *
- * This object is used in only one place in the SQLite interface.
- * A pointer to an instance of this object is the argument to
- * [sqlite3_config()] when the configuration option is
- * [SQLITE_CONFIG_MALLOC] or [SQLITE_CONFIG_GETMALLOC].
- * By creating an instance of this object
- * and passing it to [sqlite3_config]([SQLITE_CONFIG_MALLOC])
- * during configuration, an application can specify an alternative
- * memory allocation subsystem for SQLite to use for all of its
- * dynamic memory needs.
- *
- * Note that SQLite comes with several [built-in memory allocators]
- * that are perfectly adequate for the overwhelming majority of applications
- * and that this object is only useful to a tiny minority of applications
- * with specialized memory allocation requirements.  This object is
- * also used during testing of SQLite in order to specify an alternative
- * memory allocator that simulates memory out-of-memory conditions in
- * order to verify that SQLite recovers gracefully from such
- * conditions.
- *
- * The xMalloc, xRealloc, and xFree methods must work like the
- * malloc(), realloc() and free() functions from the standard C library.
- * ^SQLite guarantees that the second argument to
- * xRealloc is always a value returned by a prior call to xRoundup.
- *
- * xSize should return the allocated size of a memory allocation
- * previously obtained from xMalloc or xRealloc.  The allocated size
- * is always at least as big as the requested size but may be larger.
- *
- * The xRoundup method returns what would be the allocated size of
- * a memory allocation given a particular requested size.  Most memory
- * allocators round up memory allocations at least to the next multiple
- * of 8.  Some allocators round up to a larger multiple or to a power of 2.
- * Every memory allocation request coming in through [sqlite3_malloc()]
- * or [sqlite3_realloc()] first calls xRoundup.  If xRoundup returns 0,
- * that causes the corresponding memory allocation to fail.
- *
- * The xInit method initializes the memory allocator.  For example,
- * it might allocate any require mutexes or initialize internal data
- * structures.  The xShutdown method is invoked (indirectly) by
- * [sqlite3_shutdown()] and should deallocate any resources acquired
- * by xInit.  The pAppData pointer is used as the only parameter to
- * xInit and xShutdown.
- *
- * SQLite holds the [SQLITE_MUTEX_STATIC_MASTER] mutex when it invokes
- * the xInit method, so the xInit method need not be threadsafe.  The
- * xShutdown method is only called from [sqlite3_shutdown()] so it does
- * not need to be threadsafe either.  For all other methods, SQLite
- * holds the [SQLITE_MUTEX_STATIC_MEM] mutex as long as the
- * [SQLITE_CONFIG_MEMSTATUS] configuration option is turned on (which
- * it is by default) and so the methods are automatically serialized.
- * However, if [SQLITE_CONFIG_MEMSTATUS] is disabled, then the other
- * methods must be threadsafe or else make their own arrangements for
- * serialization.
- *
- * SQLite will never invoke xInit() more than once without an intervening
- * call to xShutdown().
-*/
-typedef struct sqlite3_mem_methods sqlite3_mem_methods;
-struct sqlite3_mem_methods {
-	void *(*xMalloc) (int);	/* Memory allocation function */
-	void (*xFree) (void *);	/* Free a prior allocation */
-	void *(*xRealloc) (void *, int);	/* Resize an allocation */
-	int (*xSize) (void *);	/* Return the size of an allocation */
-	int (*xRoundup) (int);	/* Round up request size to allocation size */
-	int (*xInit) (void *);	/* Initialize the memory allocator */
-	void (*xShutdown) (void *);	/* Deinitialize the memory allocator */
-	void *pAppData;	/* Argument to xInit() and xShutdown() */
-};
-
-/*
- * CAPI3REF: Configuration Options
- * KEYWORDS: {configuration option}
- *
- * These constants are the available integer configuration options that
- * can be passed as the first argument to the [sqlite3_config()] interface.
- *
- * New configuration options may be added in future releases of SQLite.
- * Existing configuration options might be discontinued.  Applications
- * should check the return code from [sqlite3_config()] to make sure that
- * the call worked.  The [sqlite3_config()] interface will return a
- * non-zero [error code] if a discontinued or unsupported configuration option
- * is invoked.
- *
- * <dl>
- * [[SQLITE_CONFIG_SINGLETHREAD]] <dt>SQLITE_CONFIG_SINGLETHREAD</dt>
- * <dd>There are no arguments to this option.  ^This option sets the
- * [threading mode] to Single-thread.  In other words, it disables
- * all mutexing and puts SQLite into a mode where it can only be used
- * by a single thread.   ^If SQLite is compiled with
- * the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
- * it is not possible to change the [threading mode] from its default
- * value of Single-thread and so [sqlite3_config()] will return
- * [SQLITE_ERROR] if called with the SQLITE_CONFIG_SINGLETHREAD
- * configuration option.</dd>
- *
- * [[SQLITE_CONFIG_MULTITHREAD]] <dt>SQLITE_CONFIG_MULTITHREAD</dt>
- * <dd>There are no arguments to this option.  ^This option sets the
- * [threading mode] to Multi-thread.  In other words, it disables
- * mutexing on [database connection] and [prepared statement] objects.
- * The application is responsible for serializing access to
- * [database connections] and [prepared statements].  But other mutexes
- * are enabled so that SQLite will be safe to use in a multi-threaded
- * environment as long as no two threads attempt to use the same
- * [database connection] at the same time.  ^If SQLite is compiled with
- * the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
- * it is not possible to set the Multi-thread [threading mode] and
- * [sqlite3_config()] will return [SQLITE_ERROR] if called with the
- * SQLITE_CONFIG_MULTITHREAD configuration option.</dd>
- *
- * [[SQLITE_CONFIG_SERIALIZED]] <dt>SQLITE_CONFIG_SERIALIZED</dt>
- * <dd>There are no arguments to this option.  ^This option sets the
- * [threading mode] to Serialized. In other words, this option enables
- * all mutexes including the recursive
- * mutexes on [database connection] and [prepared statement] objects.
- * In this mode (which is the default when SQLite is compiled with
- * [SQLITE_THREADSAFE=1]) the SQLite library will itself serialize access
- * to [database connections] and [prepared statements] so that the
- * application is free to use the same [database connection] or the
- * same [prepared statement] in different threads at the same time.
- * ^If SQLite is compiled with
- * the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
- * it is not possible to set the Serialized [threading mode] and
- * [sqlite3_config()] will return [SQLITE_ERROR] if called with the
- * SQLITE_CONFIG_SERIALIZED configuration option.</dd>
- *
- * [[SQLITE_CONFIG_MALLOC]] <dt>SQLITE_CONFIG_MALLOC</dt>
- * <dd> ^(The SQLITE_CONFIG_MALLOC option takes a single argument which is
- * a pointer to an instance of the [sqlite3_mem_methods] structure.
- * The argument specifies
- * alternative low-level memory allocation routines to be used in place of
- * the memory allocation routines built into SQLite.)^ ^SQLite makes
- * its own private copy of the content of the [sqlite3_mem_methods] structure
- * before the [sqlite3_config()] call returns.</dd>
- *
- * [[SQLITE_CONFIG_GETMALLOC]] <dt>SQLITE_CONFIG_GETMALLOC</dt>
- * <dd> ^(The SQLITE_CONFIG_GETMALLOC option takes a single argument which
- * is a pointer to an instance of the [sqlite3_mem_methods] structure.
- * The [sqlite3_mem_methods]
- * structure is filled with the currently defined memory allocation routines.)^
- * This option can be used to overload the default memory allocation
- * routines with a wrapper that simulations memory allocation failure or
- * tracks memory usage, for example. </dd>
- *
- * [[SQLITE_CONFIG_MEMSTATUS]] <dt>SQLITE_CONFIG_MEMSTATUS</dt>
- * <dd> ^The SQLITE_CONFIG_MEMSTATUS option takes single argument of type int,
- * interpreted as a boolean, which enables or disables the collection of
- * memory allocation statistics. ^(When memory allocation statistics are
- * disabled, the following SQLite interfaces become non-operational:
- *   <ul>
- *   <li> [sqlite3_memory_used()]
- *   <li> [sqlite3_memory_highwater()]
- *   <li> [sqlite3_soft_heap_limit64()]
- *   <li> [sqlite3_status64()]
- *   </ul>)^
- * ^Memory allocation statistics are enabled by default unless SQLite is
- * compiled with [SQLITE_DEFAULT_MEMSTATUS]=0 in which case memory
- * allocation statistics are disabled by default.
- * </dd>
- *
- * [[SQLITE_CONFIG_SCRATCH]] <dt>SQLITE_CONFIG_SCRATCH</dt>
- * <dd> ^The SQLITE_CONFIG_SCRATCH option specifies a static memory buffer
- * that SQLite can use for scratch memory.  ^(There are three arguments
- * to SQLITE_CONFIG_SCRATCH:  A pointer an 8-byte
- * aligned memory buffer from which the scratch allocations will be
- * drawn, the size of each scratch allocation (sz),
- * and the maximum number of scratch allocations (N).)^
- * The first argument must be a pointer to an 8-byte aligned buffer
- * of at least sz*N bytes of memory.
- * ^SQLite will not use more than one scratch buffers per thread.
- * ^SQLite will never request a scratch buffer that is more than 6
- * times the database page size.
- * ^If SQLite needs needs additional
- * scratch memory beyond what is provided by this configuration option, then
- * [sqlite3_malloc()] will be used to obtain the memory needed.<p>
- * ^When the application provides any amount of scratch memory using
- * SQLITE_CONFIG_SCRATCH, SQLite avoids unnecessary large
- * [sqlite3_malloc|heap allocations].
- * This can help [Robson proof|prevent memory allocation failures] due to heap
- * fragmentation in low-memory embedded systems.
- * </dd>
- *
- * [[SQLITE_CONFIG_PAGECACHE]] <dt>SQLITE_CONFIG_PAGECACHE</dt>
- * <dd> ^The SQLITE_CONFIG_PAGECACHE option specifies a memory pool
- * that SQLite can use for the database page cache with the default page
- * cache implementation.
- * This configuration option is a no-op if an application-define page
- * cache implementation is loaded using the [SQLITE_CONFIG_PCACHE2].
- * ^There are three arguments to SQLITE_CONFIG_PAGECACHE: A pointer to
- * 8-byte aligned memory (pMem), the size of each page cache line (sz),
- * and the number of cache lines (N).
- * The sz argument should be the size of the largest database page
- * (a power of two between 512 and 65536) plus some extra bytes for each
- * page header.  ^The number of extra bytes needed by the page header
- * can be determined using [SQLITE_CONFIG_PCACHE_HDRSZ].
- * ^It is harmless, apart from the wasted memory,
- * for the sz parameter to be larger than necessary.  The pMem
- * argument must be either a NULL pointer or a pointer to an 8-byte
- * aligned block of memory of at least sz*N bytes, otherwise
- * subsequent behavior is undefined.
- * ^When pMem is not NULL, SQLite will strive to use the memory provided
- * to satisfy page cache needs, falling back to [sqlite3_malloc()] if
- * a page cache line is larger than sz bytes or if all of the pMem buffer
- * is exhausted.
- * ^If pMem is NULL and N is non-zero, then each database connection
- * does an initial bulk allocation for page cache memory
- * from [sqlite3_malloc()] sufficient for N cache lines if N is positive or
- * of -1024*N bytes if N is negative, . ^If additional
- * page cache memory is needed beyond what is provided by the initial
- * allocation, then SQLite goes to [sqlite3_malloc()] separately for each
- * additional cache line. </dd>
- *
- * [[SQLITE_CONFIG_HEAP]] <dt>SQLITE_CONFIG_HEAP</dt>
- * <dd> ^The SQLITE_CONFIG_HEAP option specifies a static memory buffer
- * that SQLite will use for all of its dynamic memory allocation needs
- * beyond those provided for by [SQLITE_CONFIG_SCRATCH] and
- * [SQLITE_CONFIG_PAGECACHE].
- * ^The SQLITE_CONFIG_HEAP option is only available if SQLite is compiled
- * with either [SQLITE_ENABLE_MEMSYS3] or [SQLITE_ENABLE_MEMSYS5] and returns
- * [SQLITE_ERROR] if invoked otherwise.
- * ^There are three arguments to SQLITE_CONFIG_HEAP:
- * An 8-byte aligned pointer to the memory,
- * the number of bytes in the memory buffer, and the minimum allocation size.
- * ^If the first pointer (the memory pointer) is NULL, then SQLite reverts
- * to using its default memory allocator (the system malloc() implementation),
- * undoing any prior invocation of [SQLITE_CONFIG_MALLOC].  ^If the
- * memory pointer is not NULL then the alternative memory
- * allocator is engaged to handle all of SQLites memory allocation needs.
- * The first pointer (the memory pointer) must be aligned to an 8-byte
- * boundary or subsequent behavior of SQLite will be undefined.
- * The minimum allocation size is capped at 2**12. Reasonable values
- * for the minimum allocation size are 2**5 through 2**8.</dd>
- *
- * [[SQLITE_CONFIG_MUTEX]] <dt>SQLITE_CONFIG_MUTEX</dt>
- * <dd> ^(The SQLITE_CONFIG_MUTEX option takes a single argument which is a
- * pointer to an instance of the [sqlite3_mutex_methods] structure.
- * The argument specifies alternative low-level mutex routines to be used
- * in place the mutex routines built into SQLite.)^  ^SQLite makes a copy of
- * the content of the [sqlite3_mutex_methods] structure before the call to
- * [sqlite3_config()] returns. ^If SQLite is compiled with
- * the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
- * the entire mutexing subsystem is omitted from the build and hence calls to
- * [sqlite3_config()] with the SQLITE_CONFIG_MUTEX configuration option will
- * return [SQLITE_ERROR].</dd>
- *
- * [[SQLITE_CONFIG_GETMUTEX]] <dt>SQLITE_CONFIG_GETMUTEX</dt>
- * <dd> ^(The SQLITE_CONFIG_GETMUTEX option takes a single argument which
- * is a pointer to an instance of the [sqlite3_mutex_methods] structure.  The
- * [sqlite3_mutex_methods]
- * structure is filled with the currently defined mutex routines.)^
- * This option can be used to overload the default mutex allocation
- * routines with a wrapper used to track mutex usage for performance
- * profiling or testing, for example.   ^If SQLite is compiled with
- * the [SQLITE_THREADSAFE | SQLITE_THREADSAFE=0] compile-time option then
- * the entire mutexing subsystem is omitted from the build and hence calls to
- * [sqlite3_config()] with the SQLITE_CONFIG_GETMUTEX configuration option will
- * return [SQLITE_ERROR].</dd>
- *
- * [[SQLITE_CONFIG_LOOKASIDE]] <dt>SQLITE_CONFIG_LOOKASIDE</dt>
- * <dd> ^(The SQLITE_CONFIG_LOOKASIDE option takes two arguments that determine
- * the default size of lookaside memory on each [database connection].
- * The first argument is the
- * size of each lookaside buffer slot and the second is the number of
- * slots allocated to each database connection.)^  ^(SQLITE_CONFIG_LOOKASIDE
- * sets the <i>default</i> lookaside size. The [SQLITE_DBCONFIG_LOOKASIDE]
- * option to [sqlite3_db_config()] can be used to change the lookaside
- * configuration on individual connections.)^ </dd>
- *
- * [[SQLITE_CONFIG_PCACHE2]] <dt>SQLITE_CONFIG_PCACHE2</dt>
- * <dd> ^(The SQLITE_CONFIG_PCACHE2 option takes a single argument which is
- * a pointer to an [sqlite3_pcache_methods2] object.  This object specifies
- * the interface to a custom page cache implementation.)^
- * ^SQLite makes a copy of the [sqlite3_pcache_methods2] object.</dd>
- *
- * [[SQLITE_CONFIG_GETPCACHE2]] <dt>SQLITE_CONFIG_GETPCACHE2</dt>
- * <dd> ^(The SQLITE_CONFIG_GETPCACHE2 option takes a single argument which
- * is a pointer to an [sqlite3_pcache_methods2] object.  SQLite copies of
- * the current page cache implementation into that object.)^ </dd>
- *
- * [[SQLITE_CONFIG_LOG]] <dt>SQLITE_CONFIG_LOG</dt>
- * <dd> The SQLITE_CONFIG_LOG option is used to configure the SQLite
- * global [error log].
- * (^The SQLITE_CONFIG_LOG option takes two arguments: a pointer to a
- * function with a call signature of void(*)(void*,int,const char*),
- * and a pointer to void. ^If the function pointer is not NULL, it is
- * invoked by [sqlite3_log()] to process each logging event.  ^If the
- * function pointer is NULL, the [sqlite3_log()] interface becomes a no-op.
- * ^The void pointer that is the second argument to SQLITE_CONFIG_LOG is
- * passed through as the first parameter to the application-defined logger
- * function whenever that function is invoked.  ^The second parameter to
- * the logger function is a copy of the first parameter to the corresponding
- * [sqlite3_log()] call and is intended to be a [result code] or an
- * [extended result code].  ^The third parameter passed to the logger is
- * log message after formatting via [sqlite3_snprintf()].
- * The SQLite logging interface is not reentrant; the logger function
- * supplied by the application must not invoke any SQLite interface.
- * In a multi-threaded application, the application-defined logger
- * function must be threadsafe. </dd>
- *
- * [[SQLITE_CONFIG_URI]] <dt>SQLITE_CONFIG_URI
- * <dd>^(The SQLITE_CONFIG_URI option takes a single argument of type int.
- * If non-zero, then URI handling is globally enabled. If the parameter is zero,
- * then URI handling is globally disabled.)^ ^If URI handling is globally
- * enabled, all filenames passed to [sqlite3_open()], [sqlite3_open_v2()],
- * [sqlite3_open16()] or
- * specified as part of [ATTACH] commands are interpreted as URIs, regardless
- * of whether or not the [SQLITE_OPEN_URI] flag is set when the database
- * connection is opened. ^If it is globally disabled, filenames are
- * only interpreted as URIs if the SQLITE_OPEN_URI flag is set when the
- * database connection is opened. ^(By default, URI handling is globally
- * disabled. The default value may be changed by compiling with the
- * [SQLITE_USE_URI] symbol defined.)^
- *
- * [[SQLITE_CONFIG_COVERING_INDEX_SCAN]] <dt>SQLITE_CONFIG_COVERING_INDEX_SCAN
- * <dd>^The SQLITE_CONFIG_COVERING_INDEX_SCAN option takes a single integer
- * argument which is interpreted as a boolean in order to enable or disable
- * the use of covering indices for full table scans in the query optimizer.
- * ^The default setting is determined
- * by the [SQLITE_ALLOW_COVERING_INDEX_SCAN] compile-time option, or is "on"
- * if that compile-time option is omitted.
- * The ability to disable the use of covering indices for full table scans
- * is because some incorrectly coded legacy applications might malfunction
- * when the optimization is enabled.  Providing the ability to
- * disable the optimization allows the older, buggy application code to work
- * without change even with newer versions of SQLite.
- *
- * [[SQLITE_CONFIG_PCACHE]] [[SQLITE_CONFIG_GETPCACHE]]
- * <dt>SQLITE_CONFIG_PCACHE and SQLITE_CONFIG_GETPCACHE
- * <dd> These options are obsolete and should not be used by new code.
- * They are retained for backwards compatibility but are now no-ops.
- * </dd>
- *
- * [[SQLITE_CONFIG_SQLLOG]]
- * <dt>SQLITE_CONFIG_SQLLOG
- * <dd>This option is only available if sqlite is compiled with the
- * [SQLITE_ENABLE_SQLLOG] pre-processor macro defined. The first argument should
- * be a pointer to a function of type void(*)(void*,sqlite3*,const char*, int).
- * The second should be of type (void*). The callback is invoked by the library
- * in three separate circumstances, identified by the value passed as the
- * fourth parameter. If the fourth parameter is 0, then the database connection
- * passed as the second argument has just been opened. The third argument
- * points to a buffer containing the name of the main database file. If the
- * fourth parameter is 1, then the SQL statement that the third parameter
- * points to has just been executed. Or, if the fourth parameter is 2, then
- * the connection being passed as the second parameter is being closed. The
- * third parameter is passed NULL In this case.  An example of using this
- * configuration option can be seen in the "test_sqllog.c" source file in
- * the canonical SQLite source tree.</dd>
- *
- * [[SQLITE_CONFIG_MMAP_SIZE]]
- * <dt>SQLITE_CONFIG_MMAP_SIZE
- * <dd>^SQLITE_CONFIG_MMAP_SIZE takes two 64-bit integer (sqlite3_int64) values
- * that are the default mmap size limit (the default setting for
- * [PRAGMA mmap_size]) and the maximum allowed mmap size limit.
- * ^The default setting can be overridden by each database connection using
- * either the [PRAGMA mmap_size] command, or by using the
- * [SQLITE_FCNTL_MMAP_SIZE] file control.  ^(The maximum allowed mmap size
- * will be silently truncated if necessary so that it does not exceed the
- * compile-time maximum mmap size set by the
- * [SQLITE_MAX_MMAP_SIZE] compile-time option.)^
- * ^If either argument to this option is negative, then that argument is
- * changed to its compile-time default.
- *
- * [[SQLITE_CONFIG_PCACHE_HDRSZ]]
- * <dt>SQLITE_CONFIG_PCACHE_HDRSZ
- * <dd>^The SQLITE_CONFIG_PCACHE_HDRSZ option takes a single parameter which
- * is a pointer to an integer and writes into that integer the number of extra
- * bytes per page required for each page in [SQLITE_CONFIG_PAGECACHE].
- * The amount of extra space required can change depending on the compiler,
- * target platform, and SQLite version.
- *
- * [[SQLITE_CONFIG_PMASZ]]
- * <dt>SQLITE_CONFIG_PMASZ
- * <dd>^The SQLITE_CONFIG_PMASZ option takes a single parameter which
- * is an unsigned integer and sets the "Minimum PMA Size" for the multithreaded
- * sorter to that integer.  The default minimum PMA Size is set by the
- * [SQLITE_SORTER_PMASZ] compile-time option.  New threads are launched
- * to help with sort operations when multithreaded sorting
- * is enabled (using the [PRAGMA threads] command) and the amount of content
- * to be sorted exceeds the page size times the minimum of the
- * [PRAGMA cache_size] setting and this value.
- *
- * [[SQLITE_CONFIG_STMTJRNL_SPILL]]
- * <dt>SQLITE_CONFIG_STMTJRNL_SPILL
- * <dd>^The SQLITE_CONFIG_STMTJRNL_SPILL option takes a single parameter which
- * becomes the [statement journal] spill-to-disk threshold.
- * [Statement journals] are held in memory until their size (in bytes)
- * exceeds this threshold, at which point they are written to disk.
- * Or if the threshold is -1, statement journals are always held
- * exclusively in memory.
- * Since many statement journals never become large, setting the spill
- * threshold to a value such as 64KiB can greatly reduce the amount of
- * I/O required to support statement rollback.
- * The default value for this setting is controlled by the
- * [SQLITE_STMTJRNL_SPILL] compile-time option.
- * </dl>
-*/
-#define SQLITE_CONFIG_SINGLETHREAD  1	/* nil */
-#define SQLITE_CONFIG_MULTITHREAD   2	/* nil */
-#define SQLITE_CONFIG_SERIALIZED    3	/* nil */
-#define SQLITE_CONFIG_MALLOC        4	/* sqlite3_mem_methods* */
-#define SQLITE_CONFIG_GETMALLOC     5	/* sqlite3_mem_methods* */
-#define SQLITE_CONFIG_SCRATCH       6	/* void*, int sz, int N */
-#define SQLITE_CONFIG_PAGECACHE     7	/* void*, int sz, int N */
-#define SQLITE_CONFIG_HEAP          8	/* void*, int nByte, int min */
-#define SQLITE_CONFIG_MEMSTATUS     9	/* boolean */
-#define SQLITE_CONFIG_MUTEX        10	/* sqlite3_mutex_methods* */
-#define SQLITE_CONFIG_GETMUTEX     11	/* sqlite3_mutex_methods* */
-/* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */
-#define SQLITE_CONFIG_LOOKASIDE    13	/* int int */
-#define SQLITE_CONFIG_LOG          16	/* xFunc, void* */
-#define SQLITE_CONFIG_URI          17	/* int */
-#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20	/* int */
-#define SQLITE_CONFIG_SQLLOG       21	/* xSqllog, void* */
-#define SQLITE_CONFIG_MMAP_SIZE    22	/* sqlite3_int64, sqlite3_int64 */
-#define SQLITE_CONFIG_PMASZ               24	/* unsigned int szPma */
-#define SQLITE_CONFIG_STMTJRNL_SPILL      25	/* int nByte */
-
-/*
- * CAPI3REF: Database Connection Configuration Options
- *
- * These constants are the available integer configuration options that
- * can be passed as the second argument to the [sqlite3_db_config()] interface.
- *
- * New configuration options may be added in future releases of SQLite.
- * Existing configuration options might be discontinued.  Applications
- * should check the return code from [sqlite3_db_config()] to make sure that
- * the call worked.  ^The [sqlite3_db_config()] interface will return a
- * non-zero [error code] if a discontinued or unsupported configuration option
- * is invoked.
- *
- * <dl>
- * <dt>SQLITE_DBCONFIG_LOOKASIDE</dt>
- * <dd> ^This option takes three additional arguments that determine the
- * [lookaside memory allocator] configuration for the [database connection].
- * ^The first argument (the third parameter to [sqlite3_db_config()] is a
- * pointer to a memory buffer to use for lookaside memory.
- * ^The first argument after the SQLITE_DBCONFIG_LOOKASIDE verb
- * may be NULL in which case SQLite will allocate the
- * lookaside buffer itself using [sqlite3_malloc()]. ^The second argument is the
- * size of each lookaside buffer slot.  ^The third argument is the number of
- * slots.  The size of the buffer in the first argument must be greater than
- * or equal to the product of the second and third arguments.  The buffer
- * must be aligned to an 8-byte boundary.  ^If the second argument to
- * SQLITE_DBCONFIG_LOOKASIDE is not a multiple of 8, it is internally
- * rounded down to the next smaller multiple of 8.  ^(The lookaside memory
- * configuration for a database connection can only be changed when that
- * connection is not currently using lookaside memory, or in other words
- * when the "current value" returned by
- * [sqlite3_db_status](D,[SQLITE_CONFIG_LOOKASIDE],...) is zero.
- * Any attempt to change the lookaside memory configuration when lookaside
- * memory is in use leaves the configuration unchanged and returns
- * [SQLITE_BUSY].)^</dd>
- *
- * <dt>SQLITE_DBCONFIG_ENABLE_FKEY</dt>
- * <dd> ^This option is used to enable or disable the enforcement of
- * [foreign key constraints].  There should be two additional arguments.
- * The first argument is an integer which is 0 to disable FK enforcement,
- * positive to enable FK enforcement or negative to leave FK enforcement
- * unchanged.  The second parameter is a pointer to an integer into which
- * is written 0 or 1 to indicate whether FK enforcement is off or on
- * following this call.  The second parameter may be a NULL pointer, in
- * which case the FK enforcement setting is not reported back. </dd>
- *
- * <dt>SQLITE_DBCONFIG_ENABLE_TRIGGER</dt>
- * <dd> ^This option is used to enable or disable [CREATE TRIGGER | triggers].
- * There should be two additional arguments.
- * The first argument is an integer which is 0 to disable triggers,
- * positive to enable triggers or negative to leave the setting unchanged.
- * The second parameter is a pointer to an integer into which
- * is written 0 or 1 to indicate whether triggers are disabled or enabled
- * following this call.  The second parameter may be a NULL pointer, in
- * which case the trigger setting is not reported back. </dd>
- *
- * <dt>SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER</dt>
- * <dd> ^This option is used to enable or disable the two-argument
- * version of the [fts3_tokenizer()] function which is part of the
- * [FTS3] full-text search engine extension.
- * There should be two additional arguments.
- * The first argument is an integer which is 0 to disable fts3_tokenizer() or
- * positive to enable fts3_tokenizer() or negative to leave the setting
- * unchanged.
- * The second parameter is a pointer to an integer into which
- * is written 0 or 1 to indicate whether fts3_tokenizer is disabled or enabled
- * following this call.  The second parameter may be a NULL pointer, in
- * which case the new setting is not reported back. </dd>
- *
- * <dt>SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION</dt>
- * <dd> ^This option is used to enable or disable the [sqlite3_load_extension()]
- * interface independently of the [load_extension()] SQL function.
- * The [sqlite3_enable_load_extension()] API enables or disables both the
- * C-API [sqlite3_load_extension()] and the SQL function [load_extension()].
- * There should be two additional arguments.
- * When the first argument to this interface is 1, then only the C-API is
- * enabled and the SQL function remains disabled.  If the first argument to
- * this interface is 0, then both the C-API and the SQL function are disabled.
- * If the first argument is -1, then no changes are made to state of either the
- * C-API or the SQL function.
- * The second parameter is a pointer to an integer into which
- * is written 0 or 1 to indicate whether [sqlite3_load_extension()] interface
- * is disabled or enabled following this call.  The second parameter may
- * be a NULL pointer, in which case the new setting is not reported back.
- * </dd>
- *
- * <dt>SQLITE_DBCONFIG_MAINDBNAME</dt>
- * <dd> ^This option is used to change the name of the "main" database
- * schema.  ^The sole argument is a pointer to a constant UTF8 string
- * which will become the new schema name in place of "main".  ^SQLite
- * does not make a copy of the new main schema name string, so the application
- * must ensure that the argument passed into this DBCONFIG option is unchanged
- * until after the database connection closes.
- * </dd>
- *
- * <dt>SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE</dt>
- * <dd> Usually, when a database in wal mode is closed or detached from a
- * database handle, SQLite checks if this will mean that there are now no
- * connections at all to the database. If so, it performs a checkpoint
- * operation before closing the connection. This option may be used to
- * override this behaviour. The first parameter passed to this operation
- * is an integer - non-zero to disable checkpoints-on-close, or zero (the
- * default) to enable them. The second parameter is a pointer to an integer
- * into which is written 0 or 1 to indicate whether checkpoints-on-close
- * have been disabled - 0 if they are not disabled, 1 if they are.
- * </dd>
- *
- * </dl>
-*/
-#define SQLITE_DBCONFIG_MAINDBNAME            1000	/* const char* */
-#define SQLITE_DBCONFIG_LOOKASIDE             1001	/* void* int int */
-#define SQLITE_DBCONFIG_ENABLE_FKEY           1002	/* int int* */
-#define SQLITE_DBCONFIG_ENABLE_TRIGGER        1003	/* int int* */
-#define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004	/* int int* */
-#define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005	/* int int* */
-#define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE      1006	/* int int* */
-
-/*
- * CAPI3REF: Enable Or Disable Extended Result Codes
- * METHOD: sqlite3
- *
- * ^The sqlite3_extended_result_codes() routine enables or disables the
- * [extended result codes] feature of SQLite. ^The extended result
- * codes are disabled by default for historical compatibility.
-*/
-SQLITE_API int
-sqlite3_extended_result_codes(sqlite3 *, int onoff);
-
-/*
- * CAPI3REF: Count The Number Of Rows Modified
- * METHOD: sqlite3
- *
- * ^This function returns the number of rows modified, inserted or
- * deleted by the most recently completed INSERT, UPDATE or DELETE
- * statement on the database connection specified by the only parameter.
- * ^Executing any other type of SQL statement does not modify the value
- * returned by this function.
- *
- * ^Only changes made directly by the INSERT, UPDATE or DELETE statement are
- * considered - auxiliary changes caused by [CREATE TRIGGER | triggers],
- * [foreign key actions] or [REPLACE] constraint resolution are not counted.
- *
- * Changes to a view that are intercepted by
- * [INSTEAD OF trigger | INSTEAD OF triggers] are not counted. ^The value
- * returned by sqlite3_changes() immediately after an INSERT, UPDATE or
- * DELETE statement run on a view is always zero. Only changes made to real
- * tables are counted.
- *
- * Things are more complicated if the sqlite3_changes() function is
- * executed while a trigger program is running. This may happen if the
- * program uses the [changes() SQL function], or if some other callback
- * function invokes sqlite3_changes() directly. Essentially:
- *
- * <ul>
- *   <li> ^(Before entering a trigger program the value returned by
- *        sqlite3_changes() function is saved. After the trigger program
- *        has finished, the original value is restored.)^
- *
- *   <li> ^(Within a trigger program each INSERT, UPDATE and DELETE
- *        statement sets the value returned by sqlite3_changes()
- *        upon completion as normal. Of course, this value will not include
- *        any changes performed by sub-triggers, as the sqlite3_changes()
- *        value will be saved and restored after each sub-trigger has run.)^
- * </ul>
- *
- * ^This means that if the changes() SQL function (or similar) is used
- * by the first INSERT, UPDATE or DELETE statement within a trigger, it
- * returns the value as set when the calling statement began executing.
- * ^If it is used by the second or subsequent such statement within a trigger
- * program, the value returned reflects the number of rows modified by the
- * previous INSERT, UPDATE or DELETE statement within the same trigger.
- *
- * See also the [sqlite3_total_changes()] interface, the
- * [count_changes pragma], and the [changes() SQL function].
- *
- * If a separate thread makes changes on the same database connection
- * while [sqlite3_changes()] is running then the value returned
- * is unpredictable and not meaningful.
-*/
-SQLITE_API int
-sqlite3_changes(sqlite3 *);
-
-/*
- * CAPI3REF: Total Number Of Rows Modified
- * METHOD: sqlite3
- *
- * ^This function returns the total number of rows inserted, modified or
- * deleted by all [INSERT], [UPDATE] or [DELETE] statements completed
- * since the database connection was opened, including those executed as
- * part of trigger programs. ^Executing any other type of SQL statement
- * does not affect the value returned by sqlite3_total_changes().
- *
- * ^Changes made as part of [foreign key actions] are included in the
- * count, but those made as part of REPLACE constraint resolution are
- * not. ^Changes to a view that are intercepted by INSTEAD OF triggers
- * are not counted.
- *
- * See also the [sqlite3_changes()] interface, the
- * [count_changes pragma], and the [total_changes() SQL function].
- *
- * If a separate thread makes changes on the same database connection
- * while [sqlite3_total_changes()] is running then the value
- * returned is unpredictable and not meaningful.
-*/
-SQLITE_API int
-sqlite3_total_changes(sqlite3 *);
-
-/*
- * CAPI3REF: Interrupt A Long-Running Query
- * METHOD: sqlite3
- *
- * ^This function causes any pending database operation to abort and
- * return at its earliest opportunity. This routine is typically
- * called in response to a user action such as pressing "Cancel"
- * or Ctrl-C where the user wants a long query operation to halt
- * immediately.
- *
- * ^It is safe to call this routine from a thread different from the
- * thread that is currently running the database operation.  But it
- * is not safe to call this routine with a [database connection] that
- * is closed or might close before sqlite3_interrupt() returns.
- *
- * ^If an SQL operation is very nearly finished at the time when
- * sqlite3_interrupt() is called, then it might not have an opportunity
- * to be interrupted and might continue to completion.
- *
- * ^An SQL operation that is interrupted will return [SQLITE_INTERRUPT].
- * ^If the interrupted SQL operation is an INSERT, UPDATE, or DELETE
- * that is inside an explicit transaction, then the entire transaction
- * will be rolled back automatically.
- *
- * ^The sqlite3_interrupt(D) call is in effect until all currently running
- * SQL statements on [database connection] D complete.  ^Any new SQL statements
- * that are started after the sqlite3_interrupt() call and before the
- * running statements reaches zero are interrupted as if they had been
- * running prior to the sqlite3_interrupt() call.  ^New SQL statements
- * that are started after the running statement count reaches zero are
- * not effected by the sqlite3_interrupt().
- * ^A call to sqlite3_interrupt(D) that occurs when there are no running
- * SQL statements is a no-op and has no effect on SQL statements
- * that are started after the sqlite3_interrupt() call returns.
- *
- * If the database connection closes while [sqlite3_interrupt()]
- * is running then bad things will likely happen.
-*/
-SQLITE_API void
-sqlite3_interrupt(sqlite3 *);
-
-/*
- * CAPI3REF: Determine If An SQL Statement Is Complete
- *
- * These routines are useful during command-line input to determine if the
- * currently entered text seems to form a complete SQL statement or
- * if additional input is needed before sending the text into
- * SQLite for parsing.  ^These routines return 1 if the input string
- * appears to be a complete SQL statement.  ^A statement is judged to be
- * complete if it ends with a semicolon token and is not a prefix of a
- * well-formed CREATE TRIGGER statement.  ^Semicolons that are embedded within
- * string literals or quoted identifier names or comments are not
- * independent tokens (they are part of the token in which they are
- * embedded) and thus do not count as a statement terminator.  ^Whitespace
- * and comments that follow the final semicolon are ignored.
- *
- * ^These routines return 0 if the statement is incomplete.  ^If a
- * memory allocation fails, then SQLITE_NOMEM is returned.
- *
- * ^These routines do not parse the SQL statements thus
- * will not detect syntactically incorrect SQL.
- *
- * ^(If SQLite has not been initialized using [sqlite3_initialize()] prior
- * to invoking sqlite3_complete16() then sqlite3_initialize() is invoked
- * automatically by sqlite3_complete16().  If that initialization fails,
- * then the return value from sqlite3_complete16() will be non-zero
- * regardless of whether or not the input SQL is complete.)^
- *
- * The input to [sqlite3_complete()] must be a zero-terminated
- * UTF-8 string.
- *
- * The input to [sqlite3_complete16()] must be a zero-terminated
- * UTF-16 string in native byte order.
-*/
-SQLITE_API int
-sqlite3_complete(const char *sql);
-
-/*
- * CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors
- * KEYWORDS: {busy-handler callback} {busy handler}
- * METHOD: sqlite3
- *
- * ^The sqlite3_busy_handler(D,X,P) routine sets a callback function X
- * that might be invoked with argument P whenever
- * an attempt is made to access a database table associated with
- * [database connection] D when another thread
- * or process has the table locked.
- * The sqlite3_busy_handler() interface is used to implement
- * [sqlite3_busy_timeout()] and [PRAGMA busy_timeout].
- *
- * ^If the busy callback is NULL, then [SQLITE_BUSY]
- * is returned immediately upon encountering the lock.  ^If the busy callback
- * is not NULL, then the callback might be invoked with two arguments.
- *
- * ^The first argument to the busy handler is a copy of the void* pointer which
- * is the third argument to sqlite3_busy_handler().  ^The second argument to
- * the busy handler callback is the number of times that the busy handler has
- * been invoked previously for the same locking event.  ^If the
- * busy callback returns 0, then no additional attempts are made to
- * access the database and [SQLITE_BUSY] is returned
- * to the application.
- * ^If the callback returns non-zero, then another attempt
- * is made to access the database and the cycle repeats.
- *
- * The presence of a busy handler does not guarantee that it will be invoked
- * when there is lock contention. ^If SQLite determines that invoking the busy
- * handler could result in a deadlock, it will go ahead and return [SQLITE_BUSY]
- * to the application instead of invoking the
- * busy handler.
- * Consider a scenario where one process is holding a read lock that
- * it is trying to promote to a reserved lock and
- * a second process is holding a reserved lock that it is trying
- * to promote to an exclusive lock.  The first process cannot proceed
- * because it is blocked by the second and the second process cannot
- * proceed because it is blocked by the first.  If both processes
- * invoke the busy handlers, neither will make any progress.  Therefore,
- * SQLite returns [SQLITE_BUSY] for the first process, hoping that this
- * will induce the first process to release its read lock and allow
- * the second process to proceed.
- *
- * ^The default busy callback is NULL.
- *
- * ^(There can only be a single busy handler defined for each
- * [database connection].  Setting a new busy handler clears any
- * previously set handler.)^  ^Note that calling [sqlite3_busy_timeout()]
- * or evaluating [PRAGMA busy_timeout=N] will change the
- * busy handler and thus clear any previously set busy handler.
- *
- * The busy callback should not take any actions which modify the
- * database connection that invoked the busy handler.  In other words,
- * the busy handler is not reentrant.  Any such actions
- * result in undefined behavior.
- *
- * A busy handler must not close the database connection
- * or [prepared statement] that invoked the busy handler.
-*/
-SQLITE_API int
-sqlite3_busy_handler(sqlite3 *, int (*)(void *, int),
-		     void *);
-
-/*
- * CAPI3REF: Set A Busy Timeout
- * METHOD: sqlite3
- *
- * ^This routine sets a [sqlite3_busy_handler | busy handler] that sleeps
- * for a specified amount of time when a table is locked.  ^The handler
- * will sleep multiple times until at least "ms" milliseconds of sleeping
- * have accumulated.  ^After at least "ms" milliseconds of sleeping,
- * the handler returns 0 which causes [sqlite3_step()] to return
- * [SQLITE_BUSY].
- *
- * ^Calling this routine with an argument less than or equal to zero
- * turns off all busy handlers.
- *
- * ^(There can only be a single busy handler for a particular
- * [database connection] at any given moment.  If another busy handler
- * was defined  (using [sqlite3_busy_handler()]) prior to calling
- * this routine, that other busy handler is cleared.)^
- *
- * See also:  [PRAGMA busy_timeout]
-*/
-SQLITE_API int
-sqlite3_busy_timeout(sqlite3 *, int ms);
-
-/*
- * CAPI3REF: Convenience Routines For Running Queries
- * METHOD: sqlite3
- *
- * This is a legacy interface that is preserved for backwards compatibility.
- * Use of this interface is not recommended.
- *
- * Definition: A <b>result table</b> is memory data structure created by the
- * [sqlite3_get_table()] interface.  A result table records the
- * complete query results from one or more queries.
- *
- * The table conceptually has a number of rows and columns.  But
- * these numbers are not part of the result table itself.  These
- * numbers are obtained separately.  Let N be the number of rows
- * and M be the number of columns.
- *
- * A result table is an array of pointers to zero-terminated UTF-8 strings.
- * There are (N+1)*M elements in the array.  The first M pointers point
- * to zero-terminated strings that  contain the names of the columns.
- * The remaining entries all point to query results.  NULL values result
- * in NULL pointers.  All other values are in their UTF-8 zero-terminated
- * string representation as returned by [sqlite3_column_text()].
- *
- * A result table might consist of one or more memory allocations.
- * It is not safe to pass a result table directly to [sqlite3_free()].
- * A result table should be deallocated using [sqlite3_free_table()].
- *
- * ^(As an example of the result table format, suppose a query result
- * is as follows:
- *
- * <blockquote><pre>
- *        Name        | Age
- *        -----------------------
- *        Alice       | 43
- *        Bob         | 28
- *        Cindy       | 21
- * </pre></blockquote>
- *
- * There are two column (M==2) and three rows (N==3).  Thus the
- * result table has 8 entries.  Suppose the result table is stored
- * in an array names azResult.  Then azResult holds this content:
- *
- * <blockquote><pre>
- *        azResult&#91;0] = "Name";
- *        azResult&#91;1] = "Age";
- *        azResult&#91;2] = "Alice";
- *        azResult&#91;3] = "43";
- *        azResult&#91;4] = "Bob";
- *        azResult&#91;5] = "28";
- *        azResult&#91;6] = "Cindy";
- *        azResult&#91;7] = "21";
- * </pre></blockquote>)^
- *
- * ^The sqlite3_get_table() function evaluates one or more
- * semicolon-separated SQL statements in the zero-terminated UTF-8
- * string of its 2nd parameter and returns a result table to the
- * pointer given in its 3rd parameter.
- *
- * After the application has finished with the result from sqlite3_get_table(),
- * it must pass the result table pointer to sqlite3_free_table() in order to
- * release the memory that was malloced.  Because of the way the
- * [sqlite3_malloc()] happens within sqlite3_get_table(), the calling
- * function must not try to call [sqlite3_free()] directly.  Only
- * [sqlite3_free_table()] is able to release the memory properly and safely.
- *
- * The sqlite3_get_table() interface is implemented as a wrapper around
- * [sqlite3_exec()].  The sqlite3_get_table() routine does not have access
- * to any internal data structures of SQLite.  It uses only the public
- * interface defined here.  As a consequence, errors that occur in the
- * wrapper layer outside of the internal [sqlite3_exec()] call are not
- * reflected in subsequent calls to [sqlite3_errcode()] or
- * [sqlite3_errmsg()].
-*/
-SQLITE_API int
-sqlite3_get_table(sqlite3 * db,	/* An open database */
-		  const char *zSql,	/* SQL to be evaluated */
-		  char ***pazResult,	/* Results of the query */
-		  int *pnRow,	/* Number of result rows written here */
-		  int *pnColumn,	/* Number of result columns written here */
-		  char **pzErrmsg	/* Error msg written here */
-	);
-
-SQLITE_API void
-sqlite3_free_table(char **result);
-
-/*
- * CAPI3REF: Formatted String Printing Functions
- *
- * These routines are work-alikes of the "printf()" family of functions
- * from the standard C library.
- * These routines understand most of the common K&R formatting options,
- * plus some additional non-standard formats, detailed below.
- * Note that some of the more obscure formatting options from recent
- * C-library standards are omitted from this implementation.
- *
- * ^The sqlite3_mprintf() and sqlite3_vmprintf() routines write their
- * results into memory obtained from [sqlite3_malloc()].
- * The strings returned by these two routines should be
- * released by [sqlite3_free()].  ^Both routines return a
- * NULL pointer if [sqlite3_malloc()] is unable to allocate enough
- * memory to hold the resulting string.
- *
- * ^(The sqlite3_snprintf() routine is similar to "snprintf()" from
- * the standard C library.  The result is written into the
- * buffer supplied as the second parameter whose size is given by
- * the first parameter. Note that the order of the
- * first two parameters is reversed from snprintf().)^  This is an
- * historical accident that cannot be fixed without breaking
- * backwards compatibility.  ^(Note also that sqlite3_snprintf()
- * returns a pointer to its buffer instead of the number of
- * characters actually written into the buffer.)^  We admit that
- * the number of characters written would be a more useful return
- * value but we cannot change the implementation of sqlite3_snprintf()
- * now without breaking compatibility.
- *
- * ^As long as the buffer size is greater than zero, sqlite3_snprintf()
- * guarantees that the buffer is always zero-terminated.  ^The first
- * parameter "n" is the total size of the buffer, including space for
- * the zero terminator.  So the longest string that can be completely
- * written will be n-1 characters.
- *
- * ^The sqlite3_vsnprintf() routine is a varargs version of sqlite3_snprintf().
- *
- * These routines all implement some additional formatting
- * options that are useful for constructing SQL statements.
- * All of the usual printf() formatting options apply.  In addition, there
- * is are "%q", "%Q", "%w" and "%z" options.
- *
- * ^(The %q option works like %s in that it substitutes a nul-terminated
- * string from the argument list.  But %q also doubles every '\'' character.
- * %q is designed for use inside a string literal.)^  By doubling each '\''
- * character it escapes that character and allows it to be inserted into
- * the string.
- *
- * For example, assume the string variable zText contains text as follows:
- *
- * <blockquote><pre>
- *  char *zText = "It's a happy day!";
- * </pre></blockquote>
- *
- * One can use this text in an SQL statement as follows:
- *
- * <blockquote><pre>
- *  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES('%q')", zText);
- *  sqlite3_exec(db, zSQL, 0, 0, 0);
- *  sqlite3_free(zSQL);
- * </pre></blockquote>
- *
- * Because the %q format string is used, the '\'' character in zText
- * is escaped and the SQL generated is as follows:
- *
- * <blockquote><pre>
- *  INSERT INTO table1 VALUES('It''s a happy day!')
- * </pre></blockquote>
- *
- * This is correct.  Had we used %s instead of %q, the generated SQL
- * would have looked like this:
- *
- * <blockquote><pre>
- *  INSERT INTO table1 VALUES('It's a happy day!');
- * </pre></blockquote>
- *
- * This second example is an SQL syntax error.  As a general rule you should
- * always use %q instead of %s when inserting text into a string literal.
- *
- * ^(The %Q option works like %q except it also adds single quotes around
- * the outside of the total string.  Additionally, if the parameter in the
- * argument list is a NULL pointer, %Q substitutes the text "NULL" (without
- * single quotes).)^  So, for example, one could say:
- *
- * <blockquote><pre>
- *  char *zSQL = sqlite3_mprintf("INSERT INTO table VALUES(%Q)", zText);
- *  sqlite3_exec(db, zSQL, 0, 0, 0);
- *  sqlite3_free(zSQL);
- * </pre></blockquote>
- *
- * The code above will render a correct SQL statement in the zSQL
- * variable even if the zText variable is a NULL pointer.
- *
- * ^(The "%w" formatting option is like "%q" except that it expects to
- * be contained within double-quotes instead of single quotes, and it
- * escapes the double-quote character instead of the single-quote
- * character.)^  The "%w" formatting option is intended for safely inserting
- * table and column names into a constructed SQL statement.
- *
- * ^(The "%z" formatting option works like "%s" but with the
- * addition that after the string has been read and copied into
- * the result, [sqlite3_free()] is called on the input string.)^
-*/
-SQLITE_API char *
-sqlite3_mprintf(const char *, ...);
-SQLITE_API char *
-sqlite3_vmprintf(const char *, va_list);
-SQLITE_API char *
-sqlite3_snprintf(int, char *, const char *, ...);
-SQLITE_API char *
-sqlite3_vsnprintf(int, char *, const char *, va_list);
-
-/*
- * CAPI3REF: Memory Allocation Subsystem
- *
- * The SQLite core uses these three routines for all of its own
- * internal memory allocation needs. "Core" in the previous sentence
- * does not include operating-system specific VFS implementation.
- *
- * ^The sqlite3_malloc() routine returns a pointer to a block
- * of memory at least N bytes in length, where N is the parameter.
- * ^If sqlite3_malloc() is unable to obtain sufficient free
- * memory, it returns a NULL pointer.  ^If the parameter N to
- * sqlite3_malloc() is zero or negative then sqlite3_malloc() returns
- * a NULL pointer.
- *
- * ^The sqlite3_malloc64(N) routine works just like
- * sqlite3_malloc(N) except that N is an unsigned 64-bit integer instead
- * of a signed 32-bit integer.
- *
- * ^Calling sqlite3_free() with a pointer previously returned
- * by sqlite3_malloc() or sqlite3_realloc() releases that memory so
- * that it might be reused.  ^The sqlite3_free() routine is
- * a no-op if is called with a NULL pointer.  Passing a NULL pointer
- * to sqlite3_free() is harmless.  After being freed, memory
- * should neither be read nor written.  Even reading previously freed
- * memory might result in a segmentation fault or other severe error.
- * Memory corruption, a segmentation fault, or other severe error
- * might result if sqlite3_free() is called with a non-NULL pointer that
- * was not obtained from sqlite3_malloc() or sqlite3_realloc().
- *
- * ^The sqlite3_realloc(X,N) interface attempts to resize a
- * prior memory allocation X to be at least N bytes.
- * ^If the X parameter to sqlite3_realloc(X,N)
- * is a NULL pointer then its behavior is identical to calling
- * sqlite3_malloc(N).
- * ^If the N parameter to sqlite3_realloc(X,N) is zero or
- * negative then the behavior is exactly the same as calling
- * sqlite3_free(X).
- * ^sqlite3_realloc(X,N) returns a pointer to a memory allocation
- * of at least N bytes in size or NULL if insufficient memory is available.
- * ^If M is the size of the prior allocation, then min(N,M) bytes
- * of the prior allocation are copied into the beginning of buffer returned
- * by sqlite3_realloc(X,N) and the prior allocation is freed.
- * ^If sqlite3_realloc(X,N) returns NULL and N is positive, then the
- * prior allocation is not freed.
- *
- * ^The sqlite3_realloc64(X,N) interfaces works the same as
- * sqlite3_realloc(X,N) except that N is a 64-bit unsigned integer instead
- * of a 32-bit signed integer.
- *
- * ^If X is a memory allocation previously obtained from sqlite3_malloc(),
- * sqlite3_malloc64(), sqlite3_realloc(), or sqlite3_realloc64(), then
- * sqlite3_msize(X) returns the size of that memory allocation in bytes.
- * ^The value returned by sqlite3_msize(X) might be larger than the number
- * of bytes requested when X was allocated.  ^If X is a NULL pointer then
- * sqlite3_msize(X) returns zero.  If X points to something that is not
- * the beginning of memory allocation, or if it points to a formerly
- * valid memory allocation that has now been freed, then the behavior
- * of sqlite3_msize(X) is undefined and possibly harmful.
- *
- * ^The memory returned by sqlite3_malloc(), sqlite3_realloc(),
- * sqlite3_malloc64(), and sqlite3_realloc64()
- * is always aligned to at least an 8 byte boundary, or to a
- * 4 byte boundary if the [SQLITE_4_BYTE_ALIGNED_MALLOC] compile-time
- * option is used.
- *
- * In SQLite version 3.5.0 and 3.5.1, it was possible to define
- * the SQLITE_OMIT_MEMORY_ALLOCATION which would cause the built-in
- * implementation of these routines to be omitted.  That capability
- * is no longer provided.  Only built-in memory allocators can be used.
- *
- * The pointer arguments to [sqlite3_free()] and [sqlite3_realloc()]
- * must be either NULL or else pointers obtained from a prior
- * invocation of [sqlite3_malloc()] or [sqlite3_realloc()] that have
- * not yet been released.
- *
- * The application must not read or write any part of
- * a block of memory after it has been released using
- * [sqlite3_free()] or [sqlite3_realloc()].
-*/
-SQLITE_API void *
-sqlite3_malloc(int);
-
-SQLITE_API void *
-
-sqlite3_malloc64(sqlite3_uint64);
-
-SQLITE_API void *
-sqlite3_realloc(void *, int);
-
-SQLITE_API void *
-sqlite3_realloc64(void *, sqlite3_uint64);
-
-SQLITE_API void
-sqlite3_free(void *);
-
-SQLITE_API sqlite3_uint64
-sqlite3_msize(void *);
-
-/*
- * CAPI3REF: Memory Allocator Statistics
- *
- * SQLite provides these two interfaces for reporting on the status
- * of the [sqlite3_malloc()], [sqlite3_free()], and [sqlite3_realloc()]
- * routines, which form the built-in memory allocation subsystem.
- *
- * ^The [sqlite3_memory_used()] routine returns the number of bytes
- * of memory currently outstanding (malloced but not freed).
- * ^The [sqlite3_memory_highwater()] routine returns the maximum
- * value of [sqlite3_memory_used()] since the high-water mark
- * was last reset.  ^The values returned by [sqlite3_memory_used()] and
- * [sqlite3_memory_highwater()] include any overhead
- * added by SQLite in its implementation of [sqlite3_malloc()],
- * but not overhead added by the any underlying system library
- * routines that [sqlite3_malloc()] may call.
- *
- * ^The memory high-water mark is reset to the current value of
- * [sqlite3_memory_used()] if and only if the parameter to
- * [sqlite3_memory_highwater()] is true.  ^The value returned
- * by [sqlite3_memory_highwater(1)] is the high-water mark
- * prior to the reset.
-*/
-SQLITE_API sqlite3_int64
-sqlite3_memory_used(void);
-
-SQLITE_API sqlite3_int64
-sqlite3_memory_highwater(int resetFlag);
-
-/*
- * CAPI3REF: Pseudo-Random Number Generator
- *
- * SQLite contains a high-quality pseudo-random number generator (PRNG).
- * The PRNG is used for the build-in random() and randomblob() SQL functions.
- * This interface allows applications to access the same PRNG for other purposes.
- *
- * ^A call to this routine stores N bytes of randomness into buffer P.
- * ^The P parameter can be a NULL pointer.
- *
- * ^If this routine has not been previously called or if the previous
- * call had N less than one or a NULL pointer for P, then the PRNG is
- * seeded using randomness obtained from the xRandomness method of
- * the default [sqlite3_vfs] object.
- * ^If the previous call to this routine had an N of 1 or more and a
- * non-NULL P then the pseudo-randomness is generated
- * internally and without recourse to the [sqlite3_vfs] xRandomness
- * method.
-*/
-SQLITE_API void
-sqlite3_randomness(int N, void *P);
-
-
-/*
- * CAPI3REF: SQL Trace Event Codes
- * KEYWORDS: SQLITE_TRACE
- *
- * These constants identify classes of events that can be monitored
- * using the [sqlite3_trace_v2()] tracing logic.  The third argument
- * to [sqlite3_trace_v2()] is an OR-ed combination of one or more of
- * the following constants.  ^The first argument to the trace callback
- * is one of the following constants.
- *
- * New tracing constants may be added in future releases.
- *
- * ^A trace callback has four arguments: xCallback(T,C,P,X).
- * ^The T argument is one of the integer type codes above.
- * ^The C argument is a copy of the context pointer passed in as the
- * fourth argument to [sqlite3_trace_v2()].
- * The P and X arguments are pointers whose meanings depend on T.
- *
- * <dl>
- * [[SQLITE_TRACE_STMT]] <dt>SQLITE_TRACE_STMT</dt>
- * <dd>^An SQLITE_TRACE_STMT callback is invoked when a prepared statement
- * first begins running and possibly at other times during the
- * execution of the prepared statement, such as at the start of each
- * trigger subprogram. ^The P argument is a pointer to the
- * [prepared statement]. ^The X argument is a pointer to a string which
- * is the unexpanded SQL text of the prepared statement or an SQL comment
- * that indicates the invocation of a trigger.  ^The callback can compute
- * the same text that would have been returned by the legacy [sqlite3_trace()]
- * interface by using the X argument when X begins with "--" and invoking
- * [sqlite3_expanded_sql(P)] otherwise.
- *
- * [[SQLITE_TRACE_PROFILE]] <dt>SQLITE_TRACE_PROFILE</dt>
- * <dd>^An SQLITE_TRACE_PROFILE callback provides approximately the same
- * information as is provided by the [sqlite3_profile()] callback.
- * ^The P argument is a pointer to the [prepared statement] and the
- * X argument points to a 64-bit integer which is the estimated of
- * the number of nanosecond that the prepared statement took to run.
- * ^The SQLITE_TRACE_PROFILE callback is invoked when the statement finishes.
- *
- * [[SQLITE_TRACE_ROW]] <dt>SQLITE_TRACE_ROW</dt>
- * <dd>^An SQLITE_TRACE_ROW callback is invoked whenever a prepared
- * statement generates a single row of result.
- * ^The P argument is a pointer to the [prepared statement] and the
- * X argument is unused.
- *
- * [[SQLITE_TRACE_CLOSE]] <dt>SQLITE_TRACE_CLOSE</dt>
- * <dd>^An SQLITE_TRACE_CLOSE callback is invoked when a database
- * connection closes.
- * ^The P argument is a pointer to the [database connection] object
- * and the X argument is unused.
- * </dl>
-*/
-#define SQLITE_TRACE_STMT       0x01
-#define SQLITE_TRACE_PROFILE    0x02
-#define SQLITE_TRACE_ROW        0x04
-#define SQLITE_TRACE_CLOSE      0x08
-
-/*
- * CAPI3REF: SQL Trace Hook
- * METHOD: sqlite3
- *
- * ^The sqlite3_trace_v2(D,M,X,P) interface registers a trace callback
- * function X against [database connection] D, using property mask M
- * and context pointer P.  ^If the X callback is
- * NULL or if the M mask is zero, then tracing is disabled.  The
- * M argument should be the bitwise OR-ed combination of
- * zero or more [SQLITE_TRACE] constants.
- *
- * ^Each call to either sqlite3_trace() or sqlite3_trace_v2() overrides
- * (cancels) any prior calls to sqlite3_trace() or sqlite3_trace_v2().
- *
- * ^The X callback is invoked whenever any of the events identified by
- * mask M occur.  ^The integer return value from the callback is currently
- * ignored, though this may change in future releases.  Callback
- * implementations should return zero to ensure future compatibility.
- *
- * ^A trace callback is invoked with four arguments: callback(T,C,P,X).
- * ^The T argument is one of the [SQLITE_TRACE]
- * constants to indicate why the callback was invoked.
- * ^The C argument is a copy of the context pointer.
- * The P and X arguments are pointers whose meanings depend on T.
- *
- * The sqlite3_trace_v2() interface is intended to replace the legacy
- * interfaces [sqlite3_trace()] and [sqlite3_profile()], both of which
- * are deprecated.
-*/
-SQLITE_API int
-sqlite3_trace_v2(sqlite3 *,
-		 unsigned uMask,
-		 int (*xCallback) (unsigned, void *,
-				   void *, void *),
-		 void *pCtx);
-
-/*
- * CAPI3REF: Query Progress Callbacks
- * METHOD: sqlite3
- *
- * ^The sqlite3_progress_handler(D,N,X,P) interface causes the callback
- * function X to be invoked periodically during long running calls to
- * [sqlite3_exec()], [sqlite3_step()] and [sqlite3_get_table()] for
- * database connection D.  An example use for this
- * interface is to keep a GUI updated during a large query.
- *
- * ^The parameter P is passed through as the only parameter to the
- * callback function X.  ^The parameter N is the approximate number of
- * [virtual machine instructions] that are evaluated between successive
- * invocations of the callback X.  ^If N is less than one then the progress
- * handler is disabled.
- *
- * ^Only a single progress handler may be defined at one time per
- * [database connection]; setting a new progress handler cancels the
- * old one.  ^Setting parameter X to NULL disables the progress handler.
- * ^The progress handler is also disabled by setting N to a value less
- * than 1.
- *
- * ^If the progress callback returns non-zero, the operation is
- * interrupted.  This feature can be used to implement a
- * "Cancel" button on a GUI progress dialog box.
- *
- * The progress handler callback must not do anything that will modify
- * the database connection that invoked the progress handler.
- * Note that [sqlite3_prepare_v2()] and [sqlite3_step()] both modify their
- * database connections for the meaning of "modify" in this paragraph.
- *
-*/
-SQLITE_API void
-sqlite3_progress_handler(sqlite3 *, int,
-			 int (*)(void *), void *);
-
-/*
- * CAPI3REF: Opening A New Database Connection
- * CONSTRUCTOR: sqlite3
- *
- * ^These routines open an SQLite database file as specified by the
- * filename argument. ^The filename argument is interpreted as UTF-8 for
- * sqlite3_open() and sqlite3_open_v2() and as UTF-16 in the native byte
- * order for sqlite3_open16(). ^(A [database connection] handle is usually
- * returned in *ppDb, even if an error occurs.  The only exception is that
- * if SQLite is unable to allocate memory to hold the [sqlite3] object,
- * a NULL will be written into *ppDb instead of a pointer to the [sqlite3]
- * object.)^ ^(If the database is opened (and/or created) successfully, then
- * [SQLITE_OK] is returned.  Otherwise an [error code] is returned.)^ ^The
- * [sqlite3_errmsg()] or [sqlite3_errmsg16()] routines can be used to obtain
- * an English language description of the error following a failure of any
- * of the sqlite3_open() routines.
- *
- * ^The default encoding will be UTF-8 for databases created using
- * sqlite3_open() or sqlite3_open_v2().  ^The default encoding for databases
- * created using sqlite3_open16() will be UTF-16 in the native byte order.
- *
- * Whether or not an error occurs when it is opened, resources
- * associated with the [database connection] handle should be released by
- * passing it to [sqlite3_close()] when it is no longer required.
- *
- * The sqlite3_open_v2() interface works like sqlite3_open()
- * except that it accepts two additional parameters for additional control
- * over the new database connection.  ^(The flags parameter to
- * sqlite3_open_v2() can take one of
- * the following three values, optionally combined with the
- * [SQLITE_OPEN_NOMUTEX], [SQLITE_OPEN_FULLMUTEX], [SQLITE_OPEN_SHAREDCACHE],
- * [SQLITE_OPEN_PRIVATECACHE], and/or [SQLITE_OPEN_URI] flags:)^
- *
- * <dl>
- * ^(<dt>[SQLITE_OPEN_READONLY]</dt>
- * <dd>The database is opened in read-only mode.  If the database does not
- * already exist, an error is returned.</dd>)^
- *
- * ^(<dt>[SQLITE_OPEN_READWRITE]</dt>
- * <dd>The database is opened for reading and writing if possible, or reading
- * only if the file is write protected by the operating system.  In either
- * case the database must already exist, otherwise an error is returned.</dd>)^
- *
- * ^(<dt>[SQLITE_OPEN_READWRITE] | [SQLITE_OPEN_CREATE]</dt>
- * <dd>The database is opened for reading and writing, and is created if
- * it does not already exist. This is the behavior that is always used for
- * sqlite3_open() and sqlite3_open16().</dd>)^
- * </dl>
- *
- * If the 3rd parameter to sqlite3_open_v2() is not one of the
- * combinations shown above optionally combined with other
- * [SQLITE_OPEN_READONLY | SQLITE_OPEN_* bits]
- * then the behavior is undefined.
- *
- * ^If the [SQLITE_OPEN_NOMUTEX] flag is set, then the database connection
- * opens in the multi-thread [threading mode] as long as the single-thread
- * mode has not been set at compile-time or start-time.  ^If the
- * [SQLITE_OPEN_FULLMUTEX] flag is set then the database connection opens
- * in the serialized [threading mode] unless single-thread was
- * previously selected at compile-time or start-time.
- * ^The [SQLITE_OPEN_SHAREDCACHE] flag causes the database connection to be
- * eligible to use [shared cache mode], regardless of whether or not shared
- * cache is enabled using [sqlite3_enable_shared_cache()].  ^The
- * [SQLITE_OPEN_PRIVATECACHE] flag causes the database connection to not
- * participate in [shared cache mode] even if it is enabled.
- *
- * ^The fourth parameter to sqlite3_open_v2() is the name of the
- * [sqlite3_vfs] object that defines the operating system interface that
- * the new database connection should use.  ^If the fourth parameter is
- * a NULL pointer then the default [sqlite3_vfs] object is used.
- *
- * ^If the filename is ":memory:", then a private, temporary in-memory database
- * is created for the connection.  ^This in-memory database will vanish when
- * the database connection is closed.  Future versions of SQLite might
- * make use of additional special filenames that begin with the ":" character.
- * It is recommended that when a database filename actually does begin with
- * a ":" character you should prefix the filename with a pathname such as
- * "./" to avoid ambiguity.
- *
- * ^If the filename is an empty string, then a private, temporary
- * on-disk database will be created.  ^This private database will be
- * automatically deleted as soon as the database connection is closed.
- *
- * [[URI filenames in sqlite3_open()]] <h3>URI Filenames</h3>
- *
- * ^If [URI filename] interpretation is enabled, and the filename argument
- * begins with "file:", then the filename is interpreted as a URI. ^URI
- * filename interpretation is enabled if the [SQLITE_OPEN_URI] flag is
- * set in the fourth argument to sqlite3_open_v2(), or if it has
- * been enabled globally using the [SQLITE_CONFIG_URI] option with the
- * [sqlite3_config()] method or by the [SQLITE_USE_URI] compile-time option.
- * As of SQLite version 3.7.7, URI filename interpretation is turned off
- * by default, but future releases of SQLite might enable URI filename
- * interpretation by default.  See "[URI filenames]" for additional
- * information.
- *
- * URI filenames are parsed according to RFC 3986. ^If the URI contains an
- * authority, then it must be either an empty string or the string
- * "localhost". ^If the authority is not an empty string or "localhost", an
- * error is returned to the caller. ^The fragment component of a URI, if
- * present, is ignored.
- *
- * ^SQLite uses the path component of the URI as the name of the disk file
- * which contains the database. ^If the path begins with a '/' character,
- * then it is interpreted as an absolute path. ^If the path does not begin
- * with a '/' (meaning that the authority section is omitted from the URI)
- * then the path is interpreted as a relative path.
- *
- * [[core URI query parameters]]
- * The query component of a URI may contain parameters that are interpreted
- * either by SQLite itself, or by a [VFS | custom VFS implementation].
- * SQLite and its built-in [VFSes] interpret the
- * following query parameters:
- *
- * <ul>
- *   <li> <b>vfs</b>: ^The "vfs" parameter may be used to specify the name of
- *     a VFS object that provides the operating system interface that should
- *     be used to access the database file on disk. ^If this option is set to
- *     an empty string the default VFS object is used. ^Specifying an unknown
- *     VFS is an error. ^If sqlite3_open_v2() is used and the vfs option is
- *     present, then the VFS specified by the option takes precedence over
- *     the value passed as the fourth parameter to sqlite3_open_v2().
- *
- *   <li> <b>mode</b>: ^(The mode parameter may be set to either "ro", "rw",
- *     "rwc", or "memory". Attempting to set it to any other value is
- *     an error)^.
- *     ^If "ro" is specified, then the database is opened for read-only
- *     access, just as if the [SQLITE_OPEN_READONLY] flag had been set in the
- *     third argument to sqlite3_open_v2(). ^If the mode option is set to
- *     "rw", then the database is opened for read-write (but not create)
- *     access, as if SQLITE_OPEN_READWRITE (but not SQLITE_OPEN_CREATE) had
- *     been set. ^Value "rwc" is equivalent to setting both
- *     SQLITE_OPEN_READWRITE and SQLITE_OPEN_CREATE.  ^If the mode option is
- *     set to "memory" then a pure [in-memory database] that never reads
- *     or writes from disk is used. ^It is an error to specify a value for
- *     the mode parameter that is less restrictive than that specified by
- *     the flags passed in the third parameter to sqlite3_open_v2().
- *
- *   <li> <b>cache</b>: ^The cache parameter may be set to either "shared" or
- *     "private". ^Setting it to "shared" is equivalent to setting the
- *     SQLITE_OPEN_SHAREDCACHE bit in the flags argument passed to
- *     sqlite3_open_v2(). ^Setting the cache parameter to "private" is
- *     equivalent to setting the SQLITE_OPEN_PRIVATECACHE bit.
- *     ^If sqlite3_open_v2() is used and the "cache" parameter is present in
- *     a URI filename, its value overrides any behavior requested by setting
- *     SQLITE_OPEN_PRIVATECACHE or SQLITE_OPEN_SHAREDCACHE flag.
- *
- *  <li> <b>psow</b>: ^The psow parameter indicates whether or not the
- *     [powersafe overwrite] property does or does not apply to the
- *     storage media on which the database file resides.
- *
- *  <li> <b>nolock</b>: ^The nolock parameter is a boolean query parameter
- *     which if set disables file locking in rollback journal modes.  This
- *     is useful for accessing a database on a filesystem that does not
- *     support locking.  Caution:  Database corruption might result if two
- *     or more processes write to the same database and any one of those
- *     processes uses nolock=1.
- *
- *  <li> <b>immutable</b>: ^The immutable parameter is a boolean query
- *     parameter that indicates that the database file is stored on
- *     read-only media.  ^When immutable is set, SQLite assumes that the
- *     database file cannot be changed, even by a process with higher
- *     privilege, and so the database is opened read-only and all locking
- *     and change detection is disabled.  Caution: Setting the immutable
- *     property on a database file that does in fact change can result
- *     in incorrect query results and/or [SQLITE_CORRUPT] errors.
- *     See also: [SQLITE_IOCAP_IMMUTABLE].
- *
- * </ul>
- *
- * ^Specifying an unknown parameter in the query component of a URI is not an
- * error.  Future versions of SQLite might understand additional query
- * parameters.  See "[query parameters with special meaning to SQLite]" for
- * additional information.
- *
- * [[URI filename examples]] <h3>URI filename examples</h3>
- *
- * <table border="1" align=center cellpadding=5>
- * <tr><th> URI filenames <th> Results
- * <tr><td> file:data.db <td>
- *          Open the file "data.db" in the current directory.
- * <tr><td> file:/home/fred/data.db<br>
- *          file:///home/fred/data.db <br>
- *          file://localhost/home/fred/data.db <br> <td>
- *          Open the database file "/home/fred/data.db".
- * <tr><td> file://darkstar/home/fred/data.db <td>
- *          An error. "darkstar" is not a recognized authority.
- * <tr><td> file:data.db?mode=ro&cache=private <td>
- *          Open file "data.db" in the current directory for read-only access.
- *          Regardless of whether or not shared-cache mode is enabled by
- *          default, use a private cache.
- * <tr><td> file:/home/fred/data.db?vfs=unix-dotfile <td>
- *          Open file "/home/fred/data.db". Use the special VFS "unix-dotfile"
- *          that uses dot-files in place of posix advisory locking.
- * <tr><td> file:data.db?mode=readonly <td>
- *          An error. "readonly" is not a valid option for the "mode" parameter.
- * </table>
- *
- * ^URI hexadecimal escape sequences (%HH) are supported within the path and
- * query components of a URI. A hexadecimal escape sequence consists of a
- * percent sign - "%" - followed by exactly two hexadecimal digits
- * specifying an octet value. ^Before the path or query components of a
- * URI filename are interpreted, they are encoded using UTF-8 and all
- * hexadecimal escape sequences replaced by a single byte containing the
- * corresponding octet. If this process generates an invalid UTF-8 encoding,
- * the results are undefined.
- *
- * See also: [sqlite3_temp_directory]
-*/
-
-int
-sql_init_db(sqlite3 **db);
-
-SQLITE_API int
-sqlite3_open16(const void *filename,	/* Database filename (UTF-16) */
-	       sqlite3 ** ppDb	/* OUT: SQLite db handle */
-	);
-
-SQLITE_API int
-sqlite3_open_v2(const char *filename,	/* Database filename (UTF-8) */
-		sqlite3 ** ppDb,	/* OUT: SQLite db handle */
-		int flags,	/* Flags */
-		const char *zVfs	/* Name of VFS module to use */
-	);
-
-/*
- * CAPI3REF: Obtain Values For URI Parameters
- *
- * These are utility routines, useful to VFS implementations, that check
- * to see if a database file was a URI that contained a specific query
- * parameter, and if so obtains the value of that query parameter.
- *
- * If F is the database filename pointer passed into the xOpen() method of
- * a VFS implementation when the flags parameter to xOpen() has one or
- * more of the [SQLITE_OPEN_URI] or [SQLITE_OPEN_MAIN_DB] bits set and
- * P is the name of the query parameter, then
- * sqlite3_uri_parameter(F,P) returns the value of the P
- * parameter if it exists or a NULL pointer if P does not appear as a
- * query parameter on F.  If P is a query parameter of F
- * has no explicit value, then sqlite3_uri_parameter(F,P) returns
- * a pointer to an empty string.
- *
- * The sqlite3_uri_boolean(F,P,B) routine assumes that P is a boolean
- * parameter and returns true (1) or false (0) according to the value
- * of P.  The sqlite3_uri_boolean(F,P,B) routine returns true (1) if the
- * value of query parameter P is one of "yes", "true", or "on" in any
- * case or if the value begins with a non-zero number.  The
- * sqlite3_uri_boolean(F,P,B) routines returns false (0) if the value of
- * query parameter P is one of "no", "false", or "off" in any case or
- * if the value begins with a numeric zero.  If P is not a query
- * parameter on F or if the value of P is does not match any of the
- * above, then sqlite3_uri_boolean(F,P,B) returns (B!=0).
- *
- * The sqlite3_uri_int64(F,P,D) routine converts the value of P into a
- * 64-bit signed integer and returns that integer, or D if P does not
- * exist.  If the value of P is something other than an integer, then
- * zero is returned.
- *
- * If F is a NULL pointer, then sqlite3_uri_parameter(F,P) returns NULL and
- * sqlite3_uri_boolean(F,P,B) returns B.  If F is not a NULL pointer and
- * is not a database file pathname pointer that SQLite passed into the xOpen
- * VFS method, then the behavior of this routine is undefined and probably
- * undesirable.
-*/
-SQLITE_API const char *
-sqlite3_uri_parameter(const char *zFilename,
-		      const char *zParam);
-
-SQLITE_API int
-sqlite3_uri_boolean(const char *zFile,
-		    const char *zParam, int bDefault);
-
-SQLITE_API sqlite3_int64
-sqlite3_uri_int64(const char *, const char *,
-		  sqlite3_int64);
-
-/*
- * CAPI3REF: Error Codes And Messages
- * METHOD: sqlite3
- *
- * ^If the most recent sqlite3_* API call associated with
- * [database connection] D failed, then the sqlite3_errcode(D) interface
- * returns the numeric [result code] or [extended result code] for that
- * API call.
- * If the most recent API call was successful,
- * then the return value from sqlite3_errcode() is undefined.
- * ^The sqlite3_extended_errcode()
- * interface is the same except that it always returns the
- * [extended result code] even when extended result codes are
- * disabled.
- *
- * ^The sqlite3_errmsg() and sqlite3_errmsg16() return English-language
- * text that describes the error, as either UTF-8 or UTF-16 respectively.
- * ^(Memory to hold the error message string is managed internally.
- * The application does not need to worry about freeing the result.
- * However, the error string might be overwritten or deallocated by
- * subsequent calls to other SQLite interface functions.)^
- *
- * ^The sqlite3_errstr() interface returns the English-language text
- * that describes the [result code], as UTF-8.
- * ^(Memory to hold the error message string is managed internally
- * and must not be freed by the application)^.
- *
- * When the serialized [threading mode] is in use, it might be the
- * case that a second error occurs on a separate thread in between
- * the time of the first error and the call to these interfaces.
- * When that happens, the second error will be reported since these
- * interfaces always report the most recent result.  To avoid
- * this, each thread can obtain exclusive use of the [database connection] D
- * by invoking [sqlite3_mutex_enter]([sqlite3_db_mutex](D)) before beginning
- * to use D and invoking [sqlite3_mutex_leave]([sqlite3_db_mutex](D)) after
- * all calls to the interfaces listed here are completed.
- *
- * If an interface fails with SQLITE_MISUSE, that means the interface
- * was invoked incorrectly by the application.  In that case, the
- * error code and message may or may not be set.
-*/
-SQLITE_API int
-sqlite3_errcode(sqlite3 * db);
-
-SQLITE_API int
-sqlite3_extended_errcode(sqlite3 * db);
-
-SQLITE_API const char *
-sqlite3_errmsg(sqlite3 *);
-
-SQLITE_API const char *
-sqlite3_errstr(int);
-
-/*
- * CAPI3REF: Prepared Statement Object
- * KEYWORDS: {prepared statement} {prepared statements}
- *
- * An instance of this object represents a single SQL statement that
- * has been compiled into binary form and is ready to be evaluated.
- *
- * Think of each SQL statement as a separate computer program.  The
- * original SQL text is source code.  A prepared statement object
- * is the compiled object code.  All SQL must be converted into a
- * prepared statement before it can be run.
- *
- * The life-cycle of a prepared statement object usually goes like this:
- *
- * <ol>
- * <li> Create the prepared statement object using [sqlite3_prepare_v2()].
- * <li> Bind values to [parameters] using the sqlite3_bind_*()
- *      interfaces.
- * <li> Run the SQL by calling [sqlite3_step()] one or more times.
- * <li> Reset the prepared statement using [sqlite3_reset()] then go back
- *      to step 2.  Do this zero or more times.
- * <li> Destroy the object using [sqlite3_finalize()].
- * </ol>
-*/
-typedef struct sqlite3_stmt sqlite3_stmt;
-
-/*
- * CAPI3REF: Run-time Limits
- * METHOD: sqlite3
- *
- * ^(This interface allows the size of various constructs to be limited
- * on a connection by connection basis.  The first parameter is the
- * [database connection] whose limit is to be set or queried.  The
- * second parameter is one of the [limit categories] that define a
- * class of constructs to be size limited.  The third parameter is the
- * new limit for that construct.)^
- *
- * ^If the new limit is a negative number, the limit is unchanged.
- * ^(For each limit category SQLITE_LIMIT_<i>NAME</i> there is a
- * [limits | hard upper bound]
- * set at compile-time by a C preprocessor macro called
- * [limits | SQLITE_MAX_<i>NAME</i>].
- * (The "_LIMIT_" in the name is changed to "_MAX_".))^
- * ^Attempts to increase a limit above its hard upper bound are
- * silently truncated to the hard upper bound.
- *
- * ^Regardless of whether or not the limit was changed, the
- * [sqlite3_limit()] interface returns the prior value of the limit.
- * ^Hence, to find the current value of a limit without changing it,
- * simply invoke this interface with the third parameter set to -1.
- *
- * Run-time limits are intended for use in applications that manage
- * both their own internal database and also databases that are controlled
- * by untrusted external sources.  An example application might be a
- * web browser that has its own databases for storing history and
- * separate databases controlled by JavaScript applications downloaded
- * off the Internet.  The internal databases can be given the
- * large, default limits.  Databases managed by external sources can
- * be given much smaller limits designed to prevent a denial of service
- * attack.. The size of the database
- * created by an untrusted script can be contained using the
- * [max_page_count] [PRAGMA].
- *
- * New run-time limit categories may be added in future releases.
-*/
-SQLITE_API int
-sqlite3_limit(sqlite3 *, int id, int newVal);
-
-/*
- * CAPI3REF: Run-Time Limit Categories
- * KEYWORDS: {limit category} {*limit categories}
- *
- * These constants define various performance limits
- * that can be lowered at run-time using [sqlite3_limit()].
- * The synopsis of the meanings of the various limits is shown below.
- * Additional information is available at [limits | Limits in SQLite].
- *
- * <dl>
- * [[SQLITE_LIMIT_LENGTH]] ^(<dt>SQLITE_LIMIT_LENGTH</dt>
- * <dd>The maximum size of any string or BLOB or table row, in bytes.<dd>)^
- *
- * [[SQLITE_LIMIT_SQL_LENGTH]] ^(<dt>SQLITE_LIMIT_SQL_LENGTH</dt>
- * <dd>The maximum length of an SQL statement, in bytes.</dd>)^
- *
- * [[SQLITE_LIMIT_COLUMN]] ^(<dt>SQLITE_LIMIT_COLUMN</dt>
- * <dd>The maximum number of columns in a table definition or in the
- * result set of a [SELECT] or the maximum number of columns in an index
- * or in an ORDER BY or GROUP BY clause.</dd>)^
- *
- * [[SQLITE_LIMIT_EXPR_DEPTH]] ^(<dt>SQLITE_LIMIT_EXPR_DEPTH</dt>
- * <dd>The maximum depth of the parse tree on any expression.</dd>)^
- *
- * [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(<dt>SQLITE_LIMIT_COMPOUND_SELECT</dt>
- * <dd>The maximum number of terms in a compound SELECT statement.</dd>)^
- *
- * [[SQLITE_LIMIT_VDBE_OP]] ^(<dt>SQLITE_LIMIT_VDBE_OP</dt>
- * <dd>The maximum number of instructions in a virtual machine program
- * used to implement an SQL statement.  This limit is not currently
- * enforced, though that might be added in some future release of
- * SQLite.</dd>)^
- *
- * [[SQLITE_LIMIT_FUNCTION_ARG]] ^(<dt>SQLITE_LIMIT_FUNCTION_ARG</dt>
- * <dd>The maximum number of arguments on a function.</dd>)^
- *
- * [[SQLITE_LIMIT_ATTACHED]] ^(<dt>SQLITE_LIMIT_ATTACHED</dt>
- * <dd>The maximum number of [ATTACH | attached databases].)^</dd>
- *
- * [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]]
- * ^(<dt>SQLITE_LIMIT_LIKE_PATTERN_LENGTH</dt>
- * <dd>The maximum length of the pattern argument to the [LIKE] or
- * [GLOB] operators.</dd>)^
- *
- * [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(<dt>SQLITE_LIMIT_TRIGGER_DEPTH</dt>
- * <dd>The maximum depth of recursion for triggers.</dd>)^
- *
- * [[SQLITE_LIMIT_WORKER_THREADS]] ^(<dt>SQLITE_LIMIT_WORKER_THREADS</dt>
- * <dd>The maximum number of auxiliary worker threads that a single
- * [prepared statement] may start.</dd>)^
- * </dl>
-*/
-#define SQLITE_LIMIT_LENGTH                    0
-#define SQLITE_LIMIT_SQL_LENGTH                1
-#define SQLITE_LIMIT_COLUMN                    2
-#define SQLITE_LIMIT_EXPR_DEPTH                3
-#define SQLITE_LIMIT_COMPOUND_SELECT           4
-#define SQLITE_LIMIT_VDBE_OP                   5
-#define SQLITE_LIMIT_FUNCTION_ARG              6
-#define SQLITE_LIMIT_ATTACHED                  7
-#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH       8
-#define SQLITE_LIMIT_TRIGGER_DEPTH             9
-#define SQLITE_LIMIT_WORKER_THREADS           10
-
-/*
- * CAPI3REF: Compiling An SQL Statement
- * KEYWORDS: {SQL statement compiler}
- * METHOD: sqlite3
- * CONSTRUCTOR: sqlite3_stmt
- *
- * To execute an SQL query, it must first be compiled into a byte-code
- * program using one of these routines.
- *
- * The first argument, "db", is a [database connection] obtained from a
- * prior successful call to [sqlite3_open()], [sqlite3_open_v2()] or
- * [sqlite3_open16()].  The database connection must not have been closed.
- *
- * The second argument, "zSql", is the statement to be compiled, encoded
- * as either UTF-8 or UTF-16.  The sqlite3_prepare() and sqlite3_prepare_v2()
- * interfaces use UTF-8, and sqlite3_prepare16().
- *
- * ^If the nByte argument is negative, then zSql is read up to the
- * first zero terminator. ^If nByte is positive, then it is the
- * number of bytes read from zSql.  ^If nByte is zero, then no prepared
- * statement is generated.
- * If the caller knows that the supplied string is nul-terminated, then
- * there is a small performance advantage to passing an nByte parameter that
- * is the number of bytes in the input string <i>including</i>
- * the nul-terminator.
- *
- * ^If pzTail is not NULL then *pzTail is made to point to the first byte
- * past the end of the first SQL statement in zSql.  These routines only
- * compile the first statement in zSql, so *pzTail is left pointing to
- * what remains uncompiled.
- *
- * ^*ppStmt is left pointing to a compiled [prepared statement] that can be
- * executed using [sqlite3_step()].  ^If there is an error, *ppStmt is set
- * to NULL.  ^If the input text contains no SQL (if the input is an empty
- * string or a comment) then *ppStmt is set to NULL.
- * The calling procedure is responsible for deleting the compiled
- * SQL statement using [sqlite3_finalize()] after it has finished with it.
- * ppStmt may not be NULL.
- *
- * ^On success, the sqlite3_prepare() family of routines return [SQLITE_OK];
- * otherwise an [error code] is returned.
- *
- * The sqlite3_prepare_v2() is
- * recommended for all new programs. The two older interfaces are retained
- * for backwards compatibility, but their use is discouraged.
- * ^In the "v2" interfaces, the prepared statement
- * that is returned (the [sqlite3_stmt] object) contains a copy of the
- * original SQL text. This causes the [sqlite3_step()] interface to
- * behave differently in three ways:
- *
- * <ol>
- * <li>
- * ^If the database schema changes, instead of returning [SQLITE_SCHEMA] as it
- * always used to do, [sqlite3_step()] will automatically recompile the SQL
- * statement and try to run it again. As many as [SQLITE_MAX_SCHEMA_RETRY]
- * retries will occur before sqlite3_step() gives up and returns an error.
- * </li>
- *
- * <li>
- * ^When an error occurs, [sqlite3_step()] will return one of the detailed
- * [error codes] or [extended error codes].  ^The legacy behavior was that
- * [sqlite3_step()] would only return a generic [SQLITE_ERROR] result code
- * and the application would have to make a second call to [sqlite3_reset()]
- * in order to find the underlying cause of the problem. With the "v2" prepare
- * interfaces, the underlying reason for the error is returned immediately.
- * </li>
- *
- * <li>
- * ^If the specific value bound to [parameter | host parameter] in the
- * WHERE clause might influence the choice of query plan for a statement,
- * then the statement will be automatically recompiled, as if there had been
- * a schema change, on the first  [sqlite3_step()] call following any change
- * to the [sqlite3_bind_text | bindings] of that [parameter].
- * ^The specific value of WHERE-clause [parameter] might influence the
- * choice of query plan if the parameter is the left-hand side of a [LIKE]
- * or [GLOB] operator or if the parameter is compared to an indexed column.
- * </li>
- * </ol>
-*/
-SQLITE_API int
-sqlite3_prepare(sqlite3 * db,	/* Database handle */
-		const char *zSql,	/* SQL statement, UTF-8 encoded */
-		int nByte,	/* Maximum length of zSql in bytes. */
-		sqlite3_stmt ** ppStmt,	/* OUT: Statement handle */
-		const char **pzTail	/* OUT: Pointer to unused portion of zSql */
-	);
-
-SQLITE_API int
-sqlite3_prepare_v2(sqlite3 * db,	/* Database handle */
-		   const char *zSql,	/* SQL statement, UTF-8 encoded */
-		   int nByte,	/* Maximum length of zSql in bytes. */
-		   sqlite3_stmt ** ppStmt,	/* OUT: Statement handle */
-		   const char **pzTail	/* OUT: Pointer to unused portion of zSql */
-	);
-/*
- * CAPI3REF: Retrieving Statement SQL
- * METHOD: sqlite3_stmt
- *
- * ^The sqlite3_sql(P) interface returns a pointer to a copy of the UTF-8
- * SQL text used to create [prepared statement] P if P was
- * created by either [sqlite3_prepare_v2()]
- * ^The sqlite3_expanded_sql(P) interface returns a pointer to a UTF-8
- * string containing the SQL text of prepared statement P with
- * [bound parameters] expanded.
- *
- * ^(For example, if a prepared statement is created using the SQL
- * text "SELECT $abc,:xyz" and if parameter $abc is bound to integer 2345
- * and parameter :xyz is unbound, then sqlite3_sql() will return
- * the original string, "SELECT $abc,:xyz" but sqlite3_expanded_sql()
- * will return "SELECT 2345,NULL".)^
- *
- * ^The sqlite3_expanded_sql() interface returns NULL if insufficient memory
- * is available to hold the result, or if the result would exceed the
- * the maximum string length determined by the [SQLITE_LIMIT_LENGTH].
- *
- * ^The [SQLITE_TRACE_SIZE_LIMIT] compile-time option limits the size of
- * bound parameter expansions.  ^The [SQLITE_OMIT_TRACE] compile-time
- * option causes sqlite3_expanded_sql() to always return NULL.
- *
- * ^The string returned by sqlite3_sql(P) is managed by SQLite and is
- * automatically freed when the prepared statement is finalized.
- * ^The string returned by sqlite3_expanded_sql(P), on the other hand,
- * is obtained from [sqlite3_malloc()] and must be free by the application
- * by passing it to [sqlite3_free()].
-*/
-SQLITE_API const char *
-sqlite3_sql(sqlite3_stmt * pStmt);
-
-SQLITE_API char *
-sqlite3_expanded_sql(sqlite3_stmt * pStmt);
-
-/*
- * CAPI3REF: Determine If A Prepared Statement Has Been Reset
- * METHOD: sqlite3_stmt
- *
- * ^The sqlite3_stmt_busy(S) interface returns true (non-zero) if the
- * [prepared statement] S has been stepped at least once using
- * [sqlite3_step(S)] but has neither run to completion (returned
- * [SQLITE_DONE] from [sqlite3_step(S)]) nor
- * been reset using [sqlite3_reset(S)].  ^The sqlite3_stmt_busy(S)
- * interface returns false if S is a NULL pointer.  If S is not a
- * NULL pointer and is not a pointer to a valid [prepared statement]
- * object, then the behavior is undefined and probably undesirable.
- *
- * This interface can be used in combination [sqlite3_next_stmt()]
- * to locate all prepared statements associated with a database
- * connection that are in need of being reset.  This can be used,
- * for example, in diagnostic routines to search for prepared
- * statements that are holding a transaction open.
-*/
-SQLITE_API int
-sqlite3_stmt_busy(sqlite3_stmt *);
-
-/*
- * CAPI3REF: Dynamically Typed Value Object
- * KEYWORDS: {protected sqlite3_value} {unprotected sqlite3_value}
- *
- * SQLite uses the sqlite3_value object to represent all values
- * that can be stored in a database table. SQLite uses dynamic typing
- * for the values it stores.  ^Values stored in sqlite3_value objects
- * can be integers, floating point values, strings, BLOBs, or NULL.
- *
- * An sqlite3_value object may be either "protected" or "unprotected".
- * Some interfaces require a protected sqlite3_value.  Other interfaces
- * will accept either a protected or an unprotected sqlite3_value.
- * Every interface that accepts sqlite3_value arguments specifies
- * whether or not it requires a protected sqlite3_value.  The
- * [sqlite3_value_dup()] interface can be used to construct a new
- * protected sqlite3_value from an unprotected sqlite3_value.
- *
- * The terms "protected" and "unprotected" refer to whether or not
- * a mutex is held.  An internal mutex is held for a protected
- * sqlite3_value object but no mutex is held for an unprotected
- * sqlite3_value object.  If SQLite is compiled to be single-threaded
- * (with [SQLITE_THREADSAFE=0] and with [sqlite3_threadsafe()] returning 0)
- * or if SQLite is run in one of reduced mutex modes
- * [SQLITE_CONFIG_SINGLETHREAD] or [SQLITE_CONFIG_MULTITHREAD]
- * then there is no distinction between protected and unprotected
- * sqlite3_value objects and they can be used interchangeably.  However,
- * for maximum code portability it is recommended that applications
- * still make the distinction between protected and unprotected
- * sqlite3_value objects even when not strictly required.
- *
- * ^The sqlite3_value objects that are passed as parameters into the
- * implementation of [application-defined SQL functions] are protected.
- * ^The sqlite3_value object returned by
- * [sqlite3_column_value()] is unprotected.
- * Unprotected sqlite3_value objects may only be used with
- * [sqlite3_result_value()] and [sqlite3_bind_value()].
- * The [sqlite3_value_blob | sqlite3_value_type()] family of
- * interfaces require protected sqlite3_value objects.
-*/
-typedef struct Mem sqlite3_value;
-
-/*
- * CAPI3REF: SQL Function Context Object
- *
- * The context in which an SQL function executes is stored in an
- * sqlite3_context object.  ^A pointer to an sqlite3_context object
- * is always first parameter to [application-defined SQL functions].
- * The application-defined SQL function implementation will pass this
- * pointer through into calls to [sqlite3_result_int | sqlite3_result()],
- * [sqlite3_aggregate_context()], [sqlite3_user_data()],
- * [sqlite3_context_db_handle()], [sqlite3_get_auxdata()],
- * and/or [sqlite3_set_auxdata()].
-*/
-typedef struct sqlite3_context sqlite3_context;
-
-/*
- * CAPI3REF: Binding Values To Prepared Statements
- * KEYWORDS: {host parameter} {host parameters} {host parameter name}
- * KEYWORDS: {SQL parameter} {SQL parameters} {parameter binding}
- * METHOD: sqlite3_stmt
- *
- * ^(In the SQL statement text input to [sqlite3_prepare_v2()] and its variants,
- * literals may be replaced by a [parameter] that matches one of following
- * templates:
- *
- * <ul>
- * <li>  ?
- * <li>  ?NNN
- * <li>  :VVV
- * <li>  @VVV
- * <li>  $VVV
- * </ul>
- *
- * In the templates above, NNN represents an integer literal,
- * and VVV represents an alphanumeric identifier.)^  ^The values of these
- * parameters (also called "host parameter names" or "SQL parameters")
- * can be set using the sqlite3_bind_*() routines defined here.
- *
- * ^The first argument to the sqlite3_bind_*() routines is always
- * a pointer to the [sqlite3_stmt] object returned from
- * [sqlite3_prepare_v2()] or its variants.
- *
- * ^The second argument is the index of the SQL parameter to be set.
- * ^The leftmost SQL parameter has an index of 1.  ^When the same named
- * SQL parameter is used more than once, second and subsequent
- * occurrences have the same index as the first occurrence.
- * ^The index for named parameters can be looked up using the
- * [sqlite3_bind_parameter_index()] API if desired.  ^The index
- * for "?NNN" parameters is the value of NNN.
- * ^The NNN value must be between 1 and the
- * SQL_BIND_PARAMETER_MAX.
- *
- * ^The third argument is the value to bind to the parameter.
- * ^If the third parameter to sqlite3_bind_text() or sqlite3_bind_text16()
- * or sqlite3_bind_blob() is a NULL pointer then the fourth parameter
- * is ignored and the end result is the same as sqlite3_bind_null().
- *
- * ^(In those routines that have a fourth argument, its value is the
- * number of bytes in the parameter.  To be clear: the value is the
- * number of <u>bytes</u> in the value, not the number of characters.)^
- * ^If the fourth parameter to sqlite3_bind_text() or sqlite3_bind_text16()
- * is negative, then the length of the string is
- * the number of bytes up to the first zero terminator.
- * If the fourth parameter to sqlite3_bind_blob() is negative, then
- * the behavior is undefined.
- * If a non-negative fourth parameter is provided to sqlite3_bind_text()
- * or sqlite3_bind_text16() or sqlite3_bind_text64() then
- * that parameter must be the byte offset
- * where the NUL terminator would occur assuming the string were NUL
- * terminated.  If any NUL characters occur at byte offsets less than
- * the value of the fourth parameter then the resulting string value will
- * contain embedded NULs.  The result of expressions involving strings
- * with embedded NULs is undefined.
- *
- * ^The fifth argument to the BLOB and string binding interfaces
- * is a destructor used to dispose of the BLOB or
- * string after SQLite has finished with it.  ^The destructor is called
- * to dispose of the BLOB or string even if the call to bind API fails.
- * ^If the fifth argument is
- * the special value [SQLITE_STATIC], then SQLite assumes that the
- * information is in static, unmanaged space and does not need to be freed.
- * ^If the fifth argument has the value [SQLITE_TRANSIENT], then
- * SQLite makes its own private copy of the data immediately, before
- * the sqlite3_bind_*() routine returns.
- *
- * ^The sixth argument to sqlite3_bind_text64() must be one of
- * [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE]
- * to specify the encoding of the text in the third parameter.  If
- * the sixth argument to sqlite3_bind_text64() is not one of the
- * allowed values shown above, or if the text encoding is different
- * from the encoding specified by the sixth parameter, then the behavior
- * is undefined.
- *
- * ^The sqlite3_bind_zeroblob() routine binds a BLOB of length N that
- * is filled with zeroes.  ^A zeroblob uses a fixed amount of memory
- * (just an integer to hold its size) while it is being processed.
- * Zeroblobs are intended to serve as placeholders for BLOBs whose
- * content is later written using
- * [sqlite3_blob_open | incremental BLOB I/O] routines.
- * ^A negative value for the zeroblob results in a zero-length BLOB.
- *
- * ^If any of the sqlite3_bind_*() routines are called with a NULL pointer
- * for the [prepared statement] or with a prepared statement for which
- * [sqlite3_step()] has been called more recently than [sqlite3_reset()],
- * then the call will return [SQLITE_MISUSE].  If any sqlite3_bind_()
- * routine is passed a [prepared statement] that has been finalized, the
- * result is undefined and probably harmful.
- *
- * ^Bindings are not cleared by the [sqlite3_reset()] routine.
- * ^Unbound parameters are interpreted as NULL.
- *
- * ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an
- * [error code] if anything goes wrong.
- * ^[SQLITE_TOOBIG] might be returned if the size of a string or BLOB
- * exceeds limits imposed by [sqlite3_limit]([SQLITE_LIMIT_LENGTH]) or
- * [SQLITE_MAX_LENGTH].
- * ^[SQLITE_RANGE] is returned if the parameter
- * index is out of range.  ^[SQLITE_NOMEM] is returned if malloc() fails.
- *
- * See also: [sqlite3_bind_parameter_count()],
- * [sqlite3_bind_parameter_name()], and [sqlite3_bind_parameter_index()].
-*/
-SQLITE_API int
-sqlite3_bind_blob(sqlite3_stmt *, int, const void *,
-		  int n, void (*)(void *));
-
-SQLITE_API int
-sqlite3_bind_blob64(sqlite3_stmt *, int, const void *,
-		    sqlite3_uint64, void (*)(void *));
-
-SQLITE_API int
-sqlite3_bind_double(sqlite3_stmt *, int, double);
-
-SQLITE_API int
-sqlite3_bind_int(sqlite3_stmt *, int, int);
-
-SQLITE_API int
-sqlite3_bind_int64(sqlite3_stmt *, int, sqlite3_int64);
-
-SQLITE_API int
-sqlite3_bind_null(sqlite3_stmt *, int);
-
-SQLITE_API int
-sqlite3_bind_text(sqlite3_stmt *, int, const char *, int,
-		  void (*)(void *));
-
-SQLITE_API int
-sqlite3_bind_text64(sqlite3_stmt *, int, const char *,
-		    sqlite3_uint64, void (*)(void *));
-SQLITE_API int
-sqlite3_bind_value(sqlite3_stmt *, int,
-		   const sqlite3_value *);
-
-SQLITE_API int
-sqlite3_bind_zeroblob(sqlite3_stmt *, int, int n);
-
-SQLITE_API int
-sqlite3_bind_zeroblob64(sqlite3_stmt *, int,
-			sqlite3_uint64);
-
-/*
- * CAPI3REF: Number Of SQL Parameters
- * METHOD: sqlite3_stmt
- *
- * ^This routine can be used to find the number of [SQL parameters]
- * in a [prepared statement].  SQL parameters are tokens of the
- * form "?", "?NNN", ":AAA", "$AAA", or "@AAA" that serve as
- * placeholders for values that are [sqlite3_bind_blob | bound]
- * to the parameters at a later time.
- *
- * ^(This routine actually returns the index of the largest (rightmost)
- * parameter. For all forms except ?NNN, this will correspond to the
- * number of unique parameters.  If parameters of the ?NNN form are used,
- * there may be gaps in the list.)^
- *
- * See also: [sqlite3_bind_blob|sqlite3_bind()],
- * [sqlite3_bind_parameter_name()], and
- * [sqlite3_bind_parameter_index()].
-*/
-SQLITE_API int
-sqlite3_bind_parameter_count(sqlite3_stmt *);
-
-/*
- * CAPI3REF: Name Of A Host Parameter
- * METHOD: sqlite3_stmt
- *
- * ^The sqlite3_bind_parameter_name(P,N) interface returns
- * the name of the N-th [SQL parameter] in the [prepared statement] P.
- * ^(SQL parameters of the form "?NNN" or ":AAA" or "@AAA" or "$AAA"
- * have a name which is the string "?NNN" or ":AAA" or "@AAA" or "$AAA"
- * respectively.
- * In other words, the initial ":" or "$" or "@" or "?"
- * is included as part of the name.)^
- * ^Parameters of the form "?" without a following integer have no name
- * and are referred to as "nameless" or "anonymous parameters".
- *
- * ^The first host parameter has an index of 1, not 0.
- *
- * ^If the value N is out of range or if the N-th parameter is
- * nameless, then NULL is returned.  ^The returned string is
- * always in UTF-8 encoding even if the named parameter was
- * originally specified as UTF-16 in
- *
- * See also: [sqlite3_bind_blob|sqlite3_bind()],
- * [sqlite3_bind_parameter_count()], and
- * [sqlite3_bind_parameter_index()].
-*/
-SQLITE_API const char *
-sqlite3_bind_parameter_name(sqlite3_stmt *, int);
-
-/*
- * CAPI3REF: Index Of A Parameter With A Given Name
- * METHOD: sqlite3_stmt
- *
- * ^Return the index of an SQL parameter given its name.  ^The
- * index value returned is suitable for use as the second
- * parameter to [sqlite3_bind_blob|sqlite3_bind()].  ^A zero
- * is returned if no matching parameter is found.  ^The parameter
- * name must be given in UTF-8
- *
- * See also: [sqlite3_bind_blob|sqlite3_bind()],
- * [sqlite3_bind_parameter_count()], and
- * [sqlite3_bind_parameter_name()].
-*/
-SQLITE_API int
-sqlite3_bind_parameter_index(sqlite3_stmt *,
-			     const char *zName);
-
-/**
- * Get number of the named parameter in the prepared sql
- * statement.
- * @param pStmt Prepared statement.
- * @param zName Parameter name.
- * @param nName Parameter name length.
- *
- * @retval > 0 Number of the parameter.
- * @retval   0 Parameter is not found.
- */
-int
-sqlite3_bind_parameter_lindex(sqlite3_stmt * pStmt, const char *zName,
-			      int nName);
-
-/*
- * CAPI3REF: Reset All Bindings On A Prepared Statement
- * METHOD: sqlite3_stmt
- *
- * ^Contrary to the intuition of many, [sqlite3_reset()] does not reset
- * the [sqlite3_bind_blob | bindings] on a [prepared statement].
- * ^Use this routine to reset all host parameters to NULL.
-*/
-SQLITE_API int
-sqlite3_clear_bindings(sqlite3_stmt *);
-
-/*
- * CAPI3REF: Number Of Columns In A Result Set
- * METHOD: sqlite3_stmt
- *
- * ^Return the number of columns in the result set returned by the
- * [prepared statement]. ^If this routine returns 0, that means the
- * [prepared statement] returns no data (for example an [UPDATE]).
- * ^However, just because this routine returns a positive number does not
- * mean that one or more rows of data will be returned.  ^A SELECT statement
- * will always have a positive sqlite3_column_count() but depending on the
- * WHERE clause constraints and the table content, it might return no rows.
- *
- * See also: [sqlite3_data_count()]
-*/
-SQLITE_API int
-sqlite3_column_count(sqlite3_stmt * pStmt);
-
-/*
- * CAPI3REF: Column Names In A Result Set
- * METHOD: sqlite3_stmt
- *
- * ^These routines return the name assigned to a particular column
- * in the result set of a [SELECT] statement.  ^The sqlite3_column_name()
- * interface returns a pointer to a zero-terminated UTF-8 string
- * and sqlite3_column_name16() returns a pointer to a zero-terminated
- * UTF-16 string.  ^The first parameter is the [prepared statement]
- * that implements the [SELECT] statement. ^The second parameter is the
- * column number.  ^The leftmost column is number 0.
- *
- * ^The returned string pointer is valid until either the [prepared statement]
- * is destroyed by [sqlite3_finalize()] or until the statement is automatically
- * reprepared by the first call to [sqlite3_step()] for a particular run
- * or until the next call to
- * sqlite3_column_name() or sqlite3_column_name16() on the same column.
- *
- * ^If sqlite3_malloc() fails during the processing of either routine
- * (for example during a conversion from UTF-8 to UTF-16) then a
- * NULL pointer is returned.
- *
- * ^The name of a result column is the value of the "AS" clause for
- * that column, if there is an AS clause.  If there is no AS clause
- * then the name of the column is unspecified and may change from
- * one release of SQLite to the next.
-*/
-SQLITE_API const char *
-sqlite3_column_name(sqlite3_stmt *, int N);
-
-/*
- * CAPI3REF: Source Of Data In A Query Result
- * METHOD: sqlite3_stmt
- *
- * ^These routines provide a means to determine the database, table, and
- * table column that is the origin of a particular result column in
- * [SELECT] statement.
- * ^The name of the database or table or column can be returned as
- * either a UTF-8 or UTF-16 string.  ^The _database_ routines return
- * the database name, the _table_ routines return the table name, and
- * the origin_ routines return the column name.
- * ^The returned string is valid until the [prepared statement] is destroyed
- * using [sqlite3_finalize()] or until the statement is automatically
- * reprepared by the first call to [sqlite3_step()] for a particular run
- * or until the same information is requested
- * again in a different encoding.
- *
- * ^The names returned are the original un-aliased names of the
- * database, table, and column.
- *
- * ^The first argument to these interfaces is a [prepared statement].
- * ^These functions return information about the Nth result column returned by
- * the statement, where N is the second function argument.
- * ^The left-most column is column 0 for these routines.
- *
- * ^If the Nth column returned by the statement is an expression or
- * subquery and is not a column value, then all of these functions return
- * NULL.  ^These routine might also return NULL if a memory allocation error
- * occurs.  ^Otherwise, they return the name of the attached database, table,
- * or column that query result column was extracted from.
- *
- * ^As with all other SQLite APIs, those whose names end with "16" return
- * UTF-16 encoded strings and the other functions return UTF-8.
- *
- * ^These APIs are only available if the library was compiled with the
- * [SQLITE_ENABLE_COLUMN_METADATA] C-preprocessor symbol.
- *
- * If two or more threads call one or more of these routines against the same
- * prepared statement and column at the same time then the results are
- * undefined.
- *
- * If two or more threads call one or more
- * [sqlite3_column_database_name | column metadata interfaces]
- * for the same [prepared statement] and result column
- * at the same time then the results are undefined.
-*/
-SQLITE_API const char *
-sqlite3_column_database_name(sqlite3_stmt *,
-			     int);
-SQLITE_API const char *
-sqlite3_column_table_name(sqlite3_stmt *, int);
-
-SQLITE_API const char *
-sqlite3_column_origin_name(sqlite3_stmt *, int);
-
-/*
- * CAPI3REF: Declared Datatype Of A Query Result
- * METHOD: sqlite3_stmt
- *
- * ^(The first parameter is a [prepared statement].
- * If this statement is a [SELECT] statement and the Nth column of the
- * returned result set of that [SELECT] is a table column (not an
- * expression or subquery) then the declared type of the table
- * column is returned.)^  ^If the Nth column of the result set is an
- * expression or subquery, then a NULL pointer is returned.
- * ^The returned string is always UTF-8 encoded.
- *
- * ^(For example, given the database schema:
- *
- * CREATE TABLE t1(c1 VARIANT);
- *
- * and the following statement to be compiled:
- *
- * SELECT c1 + 1, c1 FROM t1;
- *
- * this routine would return the string "VARIANT" for the second result
- * column (i==1), and a NULL pointer for the first result column (i==0).)^
- *
- * ^SQLite uses dynamic run-time typing.  ^So just because a column
- * is declared to contain a particular type does not mean that the
- * data stored in that column is of the declared type.  SQLite is
- * strongly typed, but the typing is dynamic not static.  ^Type
- * is associated with individual values, not with the containers
- * used to hold those values.
-*/
-SQLITE_API const char *
-sqlite3_column_decltype(sqlite3_stmt *, int);
-
-/*
- * CAPI3REF: Evaluate An SQL Statement
- * METHOD: sqlite3_stmt
- *
- * After a [prepared statement] has been prepared using either
- * [sqlite3_prepare_v2()] one of the legacy
- * interfaces [sqlite3_prepare()] function
- * must be called one or more times to evaluate the statement.
- *
- * The details of the behavior of the sqlite3_step() interface depend
- * on whether the statement was prepared using the newer "v2" interface
- * [sqlite3_prepare_v2()] the older legacy
- * interface [sqlite3_prepare()] and [sqlite3_prepare16()].  The use of the
- * new "v2" interface is recommended for new applications but the legacy
- * interface will continue to be supported.
- *
- * ^In the legacy interface, the return value will be either [SQLITE_BUSY],
- * [SQLITE_DONE], [SQLITE_ROW], [SQLITE_ERROR], or [SQLITE_MISUSE].
- * ^With the "v2" interface, any of the other [result codes] or
- * [extended result codes] might be returned as well.
- *
- * ^[SQLITE_BUSY] means that the database engine was unable to acquire the
- * database locks it needs to do its job.  ^If the statement is a [COMMIT]
- * or occurs outside of an explicit transaction, then you can retry the
- * statement.  If the statement is not a [COMMIT] and occurs within an
- * explicit transaction then you should rollback the transaction before
- * continuing.
- *
- * ^[SQLITE_DONE] means that the statement has finished executing
- * successfully.  sqlite3_step() should not be called again on this virtual
- * machine without first calling [sqlite3_reset()] to reset the virtual
- * machine back to its initial state.
- *
- * ^If the SQL statement being executed returns any data, then [SQLITE_ROW]
- * is returned each time a new row of data is ready for processing by the
- * caller. The values may be accessed using the [column access functions].
- * sqlite3_step() is called again to retrieve the next row of data.
- *
- * ^[SQLITE_ERROR] means that a run-time error (such as a constraint
- * violation) has occurred.  sqlite3_step() should not be called again on
- * the VM. More information may be found by calling [sqlite3_errmsg()].
- * ^With the legacy interface, a more specific error code (for example,
- * [SQLITE_INTERRUPT], [SQLITE_SCHEMA], [SQLITE_CORRUPT], and so forth)
- * can be obtained by calling [sqlite3_reset()] on the
- * [prepared statement].  ^In the "v2" interface,
- * the more specific error code is returned directly by sqlite3_step().
- *
- * [SQLITE_MISUSE] means that the this routine was called inappropriately.
- * Perhaps it was called on a [prepared statement] that has
- * already been [sqlite3_finalize | finalized] or on one that had
- * previously returned [SQLITE_ERROR] or [SQLITE_DONE].  Or it could
- * be the case that the same database connection is being used by two or
- * more threads at the same moment in time.
- *
- * For all versions of SQLite up to and including 3.6.23.1, a call to
- * [sqlite3_reset()] was required after sqlite3_step() returned anything
- * other than [SQLITE_ROW] before any subsequent invocation of
- * sqlite3_step().  Failure to reset the prepared statement using
- * [sqlite3_reset()] would result in an [SQLITE_MISUSE] return from
- * sqlite3_step().  But after [version 3.6.23.1] ([dateof:3.6.23.1],
- * sqlite3_step() began
- * calling [sqlite3_reset()] automatically in this circumstance rather
- * than returning [SQLITE_MISUSE].  This is not considered a compatibility
- * break because any application that ever receives an SQLITE_MISUSE error
- * is broken by definition.  The [SQLITE_OMIT_AUTORESET] compile-time option
- * can be used to restore the legacy behavior.
- *
- * <b>Goofy Interface Alert:</b> In the legacy interface, the sqlite3_step()
- * API always returns a generic error code, [SQLITE_ERROR], following any
- * error other than [SQLITE_BUSY] and [SQLITE_MISUSE].  You must call
- * [sqlite3_reset()] or [sqlite3_finalize()] in order to find one of the
- * specific [error codes] that better describes the error.
- * We admit that this is a goofy design.  The problem has been fixed
- * with the "v2" interface.  If you prepare all of your SQL statements
- * using either [sqlite3_prepare_v2()] instead
- * of the legacy [sqlite3_prepare()] interfaces,
- * then the more specific [error codes] are returned directly
- * by sqlite3_step().  The use of the "v2" interface is recommended.
-*/
-SQLITE_API int
-sqlite3_step(sqlite3_stmt *);
-
-/*
- * CAPI3REF: Number of columns in a result set
- * METHOD: sqlite3_stmt
- *
- * ^The sqlite3_data_count(P) interface returns the number of columns in the
- * current row of the result set of [prepared statement] P.
- * ^If prepared statement P does not have results ready to return
- * (via calls to the [sqlite3_column_int | sqlite3_column_*()] of
- * interfaces) then sqlite3_data_count(P) returns 0.
- * ^The sqlite3_data_count(P) routine also returns 0 if P is a NULL pointer.
- * ^The sqlite3_data_count(P) routine returns 0 if the previous call to
- * [sqlite3_step](P) returned [SQLITE_DONE].  ^The sqlite3_data_count(P)
- * will return non-zero if previous call to [sqlite3_step](P) returned
- * [SQLITE_ROW], except in the case of the [PRAGMA incremental_vacuum]
- * where it always returns zero since each step of that multi-step
- * pragma returns 0 columns of data.
- *
- * See also: [sqlite3_column_count()]
-*/
-SQLITE_API int
-sqlite3_data_count(sqlite3_stmt * pStmt);
-
-/*
- * CAPI3REF: Fundamental Datatypes
- * KEYWORDS: SQLITE_TEXT
- *
- * ^(Every value in SQLite has one of five fundamental datatypes:
- *
- * <ul>
- * <li> 64-bit signed integer
- * <li> 64-bit IEEE floating point number
- * <li> string
- * <li> BLOB
- * <li> NULL
- * </ul>)^
- *
- * These constants are codes for each of those types.
- *
- * Note that the SQLITE_TEXT constant was also used in SQLite version 2
- * for a completely different meaning.  Software that links against both
- * SQLite version 2 and SQLite version 3 should use SQLITE3_TEXT, not
- * SQLITE_TEXT.
-*/
-enum sql_type {
-	SQLITE_INTEGER = 1,
-	SQLITE_FLOAT = 2,
-	SQLITE_TEXT = 3,
-	SQLITE_BLOB = 4,
-	SQLITE_NULL = 5,
-};
-/** SQLite type name by code. */
-extern const char *sql_type_strs[];
-
-/*
- * CAPI3REF: Result Values From A Query
- * KEYWORDS: {column access functions}
- * METHOD: sqlite3_stmt
- *
- * ^These routines return information about a single column of the current
- * result row of a query.  ^In every case the first argument is a pointer
- * to the [prepared statement] that is being evaluated (the [sqlite3_stmt*]
- * that was returned from [sqlite3_prepare_v2()] or one of its variants)
- * and the second argument is the index of the column for which information
- * should be returned. ^The leftmost column of the result set has the index 0.
- * ^The number of columns in the result can be determined using
- * [sqlite3_column_count()].
- *
- * If the SQL statement does not currently point to a valid row, or if the
- * column index is out of range, the result is undefined.
- * These routines may only be called when the most recent call to
- * [sqlite3_step()] has returned [SQLITE_ROW] and neither
- * [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently.
- * If any of these routines are called after [sqlite3_reset()] or
- * [sqlite3_finalize()] or after [sqlite3_step()] has returned
- * something other than [SQLITE_ROW], the results are undefined.
- * If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()]
- * are called from a different thread while any of these routines
- * are pending, then the results are undefined.
- *
- * ^The sqlite3_column_type() routine returns the
- * [SQLITE_INTEGER | datatype code] for the initial data type
- * of the result column.  ^The returned value is one of [SQLITE_INTEGER],
- * [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL].  The value
- * returned by sqlite3_column_type() is only meaningful if no type
- * conversions have occurred as described below.  After a type conversion,
- * the value returned by sqlite3_column_type() is undefined.  Future
- * versions of SQLite may change the behavior of sqlite3_column_type()
- * following a type conversion.
- *
- * ^If the result is a BLOB or UTF-8 string then the sqlite3_column_bytes()
- * routine returns the number of bytes in that BLOB or string.
- * ^If the result is a UTF-16 string, then sqlite3_column_bytes() converts
- * the string to UTF-8 and then returns the number of bytes.
- * ^If the result is a numeric value then sqlite3_column_bytes() uses
- * [sqlite3_snprintf()] to convert that value to a UTF-8 string and returns
- * the number of bytes in that string.
- * ^If the result is NULL, then sqlite3_column_bytes() returns zero.
- *
- * ^If the result is a BLOB or UTF-16 string then the sqlite3_column_bytes16()
- * routine returns the number of bytes in that BLOB or string.
- * ^If the result is a UTF-8 string, then sqlite3_column_bytes16() converts
- * the string to UTF-16 and then returns the number of bytes.
- * ^If the result is a numeric value then sqlite3_column_bytes16() uses
- * [sqlite3_snprintf()] to convert that value to a UTF-16 string and returns
- * the number of bytes in that string.
- * ^If the result is NULL, then sqlite3_column_bytes16() returns zero.
- *
- * ^The values returned by [sqlite3_column_bytes()] and
- * [sqlite3_column_bytes16()] do not include the zero terminators at the end
- * of the string.  ^For clarity: the values returned by
- * [sqlite3_column_bytes()] and [sqlite3_column_bytes16()] are the number of
- * bytes in the string, not the number of characters.
- *
- * ^Strings returned by sqlite3_column_text()
- * even empty strings, are always zero-terminated.  ^The return
- * value from sqlite3_column_blob() for a zero-length BLOB is a NULL pointer.
- *
- * <b>Warning:</b> ^The object returned by [sqlite3_column_value()] is an
- * [unprotected sqlite3_value] object.  In a multithreaded environment,
- * an unprotected sqlite3_value object may only be used safely with
- * [sqlite3_bind_value()] and [sqlite3_result_value()].
- * If the [unprotected sqlite3_value] object returned by
- * [sqlite3_column_value()] is used in any other way, including calls
- * to routines like [sqlite3_value_int()], [sqlite3_value_text()],
- * or [sqlite3_value_bytes()], the behavior is not threadsafe.
- *
- * These routines attempt to convert the value where appropriate.  ^For
- * example, if the internal representation is FLOAT and a text result
- * is requested, [sqlite3_snprintf()] is used internally to perform the
- * conversion automatically.  ^(The following table details the conversions
- * that are applied:
- *
- * <blockquote>
- * <table border="1">
- * <tr><th> Internal<br>Type <th> Requested<br>Type <th>  Conversion
- *
- * <tr><td>  NULL    <td> INTEGER   <td> Result is 0
- * <tr><td>  NULL    <td>  FLOAT    <td> Result is 0.0
- * <tr><td>  NULL    <td>   TEXT    <td> Result is a NULL pointer
- * <tr><td>  NULL    <td>   BLOB    <td> Result is a NULL pointer
- * <tr><td> INTEGER  <td>  FLOAT    <td> Convert from integer to float
- * <tr><td> INTEGER  <td>   TEXT    <td> ASCII rendering of the integer
- * <tr><td> INTEGER  <td>   BLOB    <td> Same as INTEGER->TEXT
- * <tr><td>  FLOAT   <td> INTEGER   <td> [CAST] to INTEGER
- * <tr><td>  FLOAT   <td>   TEXT    <td> ASCII rendering of the float
- * <tr><td>  FLOAT   <td>   BLOB    <td> [CAST] to BLOB
- * <tr><td>  TEXT    <td> INTEGER   <td> [CAST] to INTEGER
- * <tr><td>  TEXT    <td>  FLOAT    <td> [CAST] to REAL
- * <tr><td>  TEXT    <td>   BLOB    <td> No change
- * <tr><td>  BLOB    <td> INTEGER   <td> [CAST] to INTEGER
- * <tr><td>  BLOB    <td>  FLOAT    <td> [CAST] to REAL
- * <tr><td>  BLOB    <td>   TEXT    <td> Add a zero terminator if needed
- * </table>
- * </blockquote>)^
- *
- * Note that when type conversions occur, pointers returned by prior
- * calls to sqlite3_column_blob(), sqlite3_column_text(), and/or
- * sqlite3_column_text16() may be invalidated.
- * Type conversions and pointer invalidations might occur
- * in the following cases:
- *
- * <ul>
- * <li> The initial content is a BLOB and sqlite3_column_text() or
- *      sqlite3_column_text16() is called.  A zero-terminator might
- *      need to be added to the string.</li>
- * <li> The initial content is UTF-8 text and sqlite3_column_bytes16() or
- *      sqlite3_column_text16() is called.  The content must be converted
- *      to UTF-16.</li>
- * <li> The initial content is UTF-16 text and sqlite3_column_bytes() or
- *      sqlite3_column_text() is called.  The content must be converted
- *      to UTF-8.</li>
- * </ul>
- *
- * ^Conversions between UTF-16be and UTF-16le are always done in place and do
- * not invalidate a prior pointer, though of course the content of the buffer
- * that the prior pointer references will have been modified.  Other kinds
- * of conversion are done in place when it is possible, but sometimes they
- * are not possible and in those cases prior pointers are invalidated.
- *
- * The safest policy is to invoke these routines
- * in one of the following ways:
- *
- * <ul>
- *  <li>sqlite3_column_text() followed by sqlite3_column_bytes()</li>
- *  <li>sqlite3_column_blob() followed by sqlite3_column_bytes()</li>
- *  <li>sqlite3_column_text16() followed by sqlite3_column_bytes16()</li>
- * </ul>
- *
- * In other words, you should call sqlite3_column_text(),
- * sqlite3_column_blob(), or sqlite3_column_text16() first to force the result
- * into the desired format, then invoke sqlite3_column_bytes() or
- * sqlite3_column_bytes16() to find the size of the result.  Do not mix calls
- * to sqlite3_column_text() or sqlite3_column_blob() with calls to
- * sqlite3_column_bytes16(), and do not mix calls to sqlite3_column_text16()
- * with calls to sqlite3_column_bytes().
- *
- * ^The pointers returned are valid until a type conversion occurs as
- * described above, or until [sqlite3_step()] or [sqlite3_reset()] or
- * [sqlite3_finalize()] is called.  ^The memory space used to hold strings
- * and BLOBs is freed automatically.  Do <em>not</em> pass the pointers returned
- * from [sqlite3_column_blob()], [sqlite3_column_text()], etc. into
- * [sqlite3_free()].
- *
- * ^(If a memory allocation error occurs during the evaluation of any
- * of these routines, a default value is returned.  The default value
- * is either the integer 0, the floating point number 0.0, or a NULL
- * pointer.  Subsequent calls to [sqlite3_errcode()] will return
- * [SQLITE_NOMEM].)^
-*/
-SQLITE_API const void *
-sqlite3_column_blob(sqlite3_stmt *, int iCol);
-
-SQLITE_API int
-sqlite3_column_bytes(sqlite3_stmt *, int iCol);
-
-SQLITE_API int
-sqlite3_column_bytes16(sqlite3_stmt *, int iCol);
-
-SQLITE_API double
-sqlite3_column_double(sqlite3_stmt *, int iCol);
-
-SQLITE_API int
-sqlite3_column_int(sqlite3_stmt *, int iCol);
-
-SQLITE_API sqlite3_int64
-sqlite3_column_int64(sqlite3_stmt *, int iCol);
-
-SQLITE_API const unsigned char *
-sqlite3_column_text(sqlite3_stmt *,
-		    int iCol);
-
-SQLITE_API int
-sqlite3_column_type(sqlite3_stmt *, int iCol);
-
-SQLITE_API sqlite3_value *
-sqlite3_column_value(sqlite3_stmt *,
-		     int iCol);
-
-/*
- * CAPI3REF: Destroy A Prepared Statement Object
- * DESTRUCTOR: sqlite3_stmt
- *
- * ^The sqlite3_finalize() function is called to delete a [prepared statement].
- * ^If the most recent evaluation of the statement encountered no errors
- * or if the statement is never been evaluated, then sqlite3_finalize() returns
- * SQLITE_OK.  ^If the most recent evaluation of statement S failed, then
- * sqlite3_finalize(S) returns the appropriate [error code] or
- * [extended error code].
- *
- * ^The sqlite3_finalize(S) routine can be called at any point during
- * the life cycle of [prepared statement] S:
- * before statement S is ever evaluated, after
- * one or more calls to [sqlite3_reset()], or after any call
- * to [sqlite3_step()] regardless of whether or not the statement has
- * completed execution.
- *
- * ^Invoking sqlite3_finalize() on a NULL pointer is a harmless no-op.
- *
- * The application must finalize every [prepared statement] in order to avoid
- * resource leaks.  It is a grievous error for the application to try to use
- * a prepared statement after it has been finalized.  Any use of a prepared
- * statement after it has been finalized can result in undefined and
- * undesirable behavior such as segfaults and heap corruption.
-*/
-SQLITE_API int
-sqlite3_finalize(sqlite3_stmt * pStmt);
-
-/*
- * CAPI3REF: Reset A Prepared Statement Object
- * METHOD: sqlite3_stmt
- *
- * The sqlite3_reset() function is called to reset a [prepared statement]
- * object back to its initial state, ready to be re-executed.
- * ^Any SQL statement variables that had values bound to them using
- * the [sqlite3_bind_blob | sqlite3_bind_*() API] retain their values.
- * Use [sqlite3_clear_bindings()] to reset the bindings.
- *
- * ^The [sqlite3_reset(S)] interface resets the [prepared statement] S
- * back to the beginning of its program.
- *
- * ^If the most recent call to [sqlite3_step(S)] for the
- * [prepared statement] S returned [SQLITE_ROW] or [SQLITE_DONE],
- * or if [sqlite3_step(S)] has never before been called on S,
- * then [sqlite3_reset(S)] returns [SQLITE_OK].
- *
- * ^If the most recent call to [sqlite3_step(S)] for the
- * [prepared statement] S indicated an error, then
- * [sqlite3_reset(S)] returns an appropriate [error code].
- *
- * ^The [sqlite3_reset(S)] interface does not change the values
- * of any [sqlite3_bind_blob|bindings] on the [prepared statement] S.
-*/
-SQLITE_API int
-sqlite3_reset(sqlite3_stmt * pStmt);
-
-/*
- * CAPI3REF: Create Or Redefine SQL Functions
- * KEYWORDS: {function creation routines}
- * KEYWORDS: {application-defined SQL function}
- * KEYWORDS: {application-defined SQL functions}
- * METHOD: sqlite3
- *
- * ^These functions (collectively known as "function creation routines")
- * are used to add SQL functions or aggregates or to redefine the behavior
- * of existing SQL functions or aggregates.  The only differences between
- * these routines are the text encoding expected for
- * the second parameter (the name of the function being created)
- * and the presence or absence of a destructor callback for
- * the application data pointer.
- *
- * ^The first parameter is the [database connection] to which the SQL
- * function is to be added.  ^If an application uses more than one database
- * connection then application-defined SQL functions must be added
- * to each database connection separately.
- *
- * ^The second parameter is the name of the SQL function to be created or
- * redefined.  ^The length of the name is limited to 255 bytes in a UTF-8
- * representation, exclusive of the zero-terminator.  ^Note that the name
- * length limit is in UTF-8 bytes, not characters nor UTF-16 bytes.
- * ^Any attempt to create a function with a longer name
- * will result in [SQLITE_MISUSE] being returned.
- *
- * ^The third parameter (nArg)
- * is the number of arguments that the SQL function or
- * aggregate takes. ^If this parameter is -1, then the SQL function or
- * aggregate may take any number of arguments between 0 and the limit
- * set by [sqlite3_limit]([SQLITE_LIMIT_FUNCTION_ARG]).  If the third
- * parameter is less than -1 or greater than 127 then the behavior is
- * undefined.
- *
- * ^The fourth parameter, eTextRep, specifies what
- * [SQLITE_UTF8 | text encoding] this SQL function prefers for
- * its parameters.  The application should set this parameter to
- * [SQLITE_UTF16LE] if the function implementation invokes
- * [sqlite3_value_text16le()] on an input, or [SQLITE_UTF16BE] if the
- * implementation invokes [sqlite3_value_text16be()] on an input, or
- * [SQLITE_UTF16] if [sqlite3_value_text16()] is used, or [SQLITE_UTF8]
- * otherwise.  ^The same SQL function may be registered multiple times using
- * different preferred text encodings, with different implementations for
- * each encoding.
- * ^When multiple implementations of the same function are available, SQLite
- * will pick the one that involves the least amount of data conversion.
- *
- * ^The fourth parameter may optionally be ORed with [SQLITE_DETERMINISTIC]
- * to signal that the function will always return the same result given
- * the same inputs within a single SQL statement.  Most SQL functions are
- * deterministic.  The built-in [random()] SQL function is an example of a
- * function that is not deterministic.  The SQLite query planner is able to
- * perform additional optimizations on deterministic functions, so use
- * of the [SQLITE_DETERMINISTIC] flag is recommended where possible.
- *
- * ^(The fifth parameter is an arbitrary pointer.  The implementation of the
- * function can gain access to this pointer using [sqlite3_user_data()].)^
- *
- * ^The sixth, seventh and eighth parameters, xFunc, xStep and xFinal, are
- * pointers to C-language functions that implement the SQL function or
- * aggregate. ^A scalar SQL function requires an implementation of the xFunc
- * callback only; NULL pointers must be passed as the xStep and xFinal
- * parameters. ^An aggregate SQL function requires an implementation of xStep
- * and xFinal and NULL pointer must be passed for xFunc. ^To delete an existing
- * SQL function or aggregate, pass NULL pointers for all three function
- * callbacks.
- *
- * ^(If the ninth parameter to sqlite3_create_function_v2() is not NULL,
- * then it is destructor for the application data pointer.
- * The destructor is invoked when the function is deleted, either by being
- * overloaded or when the database connection closes.)^
- * ^The destructor is also invoked if the call to
- * sqlite3_create_function_v2() fails.
- * ^When the destructor callback of the tenth parameter is invoked, it
- * is passed a single argument which is a copy of the application data
- * pointer which was the fifth parameter to sqlite3_create_function_v2().
- *
- * ^It is permitted to register multiple implementations of the same
- * functions with the same name but with either differing numbers of
- * arguments or differing preferred text encodings.  ^SQLite will use
- * the implementation that most closely matches the way in which the
- * SQL function is used.  ^A function implementation with a non-negative
- * nArg parameter is a better match than a function implementation with
- * a negative nArg.  ^A function where the preferred text encoding
- * matches the database encoding is a better
- * match than a function where the encoding is different.
- * ^A function where the encoding difference is between UTF16le and UTF16be
- * is a closer match than a function where the encoding difference is
- * between UTF8 and UTF16.
- *
- * ^Built-in functions may be overloaded by new application-defined functions.
- *
- * ^An application-defined function is permitted to call other
- * SQLite interfaces.  However, such calls must not
- * close the database connection nor finalize or reset the prepared
- * statement in which the function is running.
-*/
-SQLITE_API int
-sqlite3_create_function(sqlite3 * db,
-			const char *zFunctionName,
-			int nArg,
-			int flags,
-			void *pApp,
-			void (*xFunc) (sqlite3_context *,
-				       int,
-				       sqlite3_value **),
-			void (*xStep) (sqlite3_context *,
-				       int,
-				       sqlite3_value **),
-			void (*xFinal) (sqlite3_context *)
-	);
-
-
-SQLITE_API int
-sqlite3_create_function_v2(sqlite3 * db,
-			   const char *zFunctionName,
-			   int nArg,
-			   int flags,
-			   void *pApp,
-			   void (*xFunc) (sqlite3_context *,
-					  int,
-					  sqlite3_value **),
-			   void (*xStep) (sqlite3_context *,
-					  int,
-					  sqlite3_value **),
-			   void (*xFinal)
-			   (sqlite3_context *),
-			   void (*xDestroy) (void *)
-	);
-
-/*
- * CAPI3REF: Function Flags
- *
- * These constants may be ORed together with the
- * [SQLITE_UTF8 | preferred text encoding] as the fourth argument
- * to [sqlite3_create_function()], [sqlite3_create_function16()], or
- * [sqlite3_create_function_v2()].
-*/
-#define SQLITE_DETERMINISTIC    0x800
-
-/*
- * CAPI3REF: Obtaining SQL Values
- * METHOD: sqlite3_value
- *
- * The C-language implementation of SQL functions and aggregates uses
- * this set of interface routines to access the parameter values on
- * the function or aggregate.
- *
- * The xFunc (for scalar functions) or xStep (for aggregates) parameters
- * to [sqlite3_create_function()] and [sqlite3_create_function16()]
- * define callbacks that implement the SQL functions and aggregates.
- * The 3rd parameter to these callbacks is an array of pointers to
- * [protected sqlite3_value] objects.  There is one [sqlite3_value] object for
- * each parameter to the SQL function.  These routines are used to
- * extract values from the [sqlite3_value] objects.
- *
- * These routines work only with [protected sqlite3_value] objects.
- * Any attempt to use these routines on an [unprotected sqlite3_value]
- * object results in undefined behavior.
- *
- * ^These routines work just like the corresponding [column access functions]
- * except that these routines take a single [protected sqlite3_value] object
- * pointer instead of a [sqlite3_stmt*] pointer and an integer column number.
- *
- * ^The sqlite3_value_text16() interface extracts a UTF-16 string
- * in the native byte-order of the host machine.  ^The
- * sqlite3_value_text16be() and sqlite3_value_text16le() interfaces
- * extract UTF-16 strings as big-endian and little-endian respectively.
- *
- * ^(The sqlite3_value_numeric_type() interface attempts to apply
- * numeric affinity to the value.  This means that an attempt is
- * made to convert the value to an integer or floating point.  If
- * such a conversion is possible without loss of information (in other
- * words, if the value is a string that looks like a number)
- * then the conversion is performed.  Otherwise no conversion occurs.
- * The [SQLITE_INTEGER | datatype] after conversion is returned.)^
- *
- * Please pay particular attention to the fact that the pointer returned
- * from [sqlite3_value_blob()], [sqlite3_value_text()], or
- * [sqlite3_value_text16()] can be invalidated by a subsequent call to
- * [sqlite3_value_bytes()], [sqlite3_value_text()].
- *
- * These routines must be called from the same thread as
- * the SQL function that supplied the [sqlite3_value*] parameters.
-*/
-SQLITE_API const void *
-sqlite3_value_blob(sqlite3_value *);
-
-SQLITE_API int
-sqlite3_value_bytes(sqlite3_value *);
-
-SQLITE_API double
-sqlite3_value_double(sqlite3_value *);
-
-SQLITE_API int
-sqlite3_value_int(sqlite3_value *);
-
-SQLITE_API sqlite3_int64
-sqlite3_value_int64(sqlite3_value *);
-
-SQLITE_API const unsigned char *
-sqlite3_value_text(sqlite3_value *);
-
-SQLITE_API int
-sqlite3_value_type(sqlite3_value *);
-
-SQLITE_API int
-sqlite3_value_numeric_type(sqlite3_value *);
-
-/*
- * CAPI3REF: Finding The Subtype Of SQL Values
- * METHOD: sqlite3_value
- *
- * The sqlite3_value_subtype(V) function returns the subtype for
- * an [application-defined SQL function] argument V.  The subtype
- * information can be used to pass a limited amount of context from
- * one SQL function to another.  Use the [sqlite3_result_subtype()]
- * routine to set the subtype for the return value of an SQL function.
- *
- * SQLite makes no use of subtype itself.  It merely passes the subtype
- * from the result of one [application-defined SQL function] into the
- * input of another.
-*/
-SQLITE_API unsigned int
-sqlite3_value_subtype(sqlite3_value *);
-
-/*
- * CAPI3REF: Copy And Free SQL Values
- * METHOD: sqlite3_value
- *
- * ^The sqlite3_value_dup(V) interface makes a copy of the [sqlite3_value]
- * object D and returns a pointer to that copy.  ^The [sqlite3_value] returned
- * is a [protected sqlite3_value] object even if the input is not.
- * ^The sqlite3_value_dup(V) interface returns NULL if V is NULL or if a
- * memory allocation fails.
- *
- * ^The sqlite3_value_free(V) interface frees an [sqlite3_value] object
- * previously obtained from [sqlite3_value_dup()].  ^If V is a NULL pointer
- * then sqlite3_value_free(V) is a harmless no-op.
-*/
-SQLITE_API sqlite3_value *
-sqlite3_value_dup(const sqlite3_value *);
-
-SQLITE_API void
-sqlite3_value_free(sqlite3_value *);
-
-/*
- * CAPI3REF: Obtain Aggregate Function Context
- * METHOD: sqlite3_context
- *
- * Implementations of aggregate SQL functions use this
- * routine to allocate memory for storing their state.
- *
- * ^The first time the sqlite3_aggregate_context(C,N) routine is called
- * for a particular aggregate function, SQLite
- * allocates N of memory, zeroes out that memory, and returns a pointer
- * to the new memory. ^On second and subsequent calls to
- * sqlite3_aggregate_context() for the same aggregate function instance,
- * the same buffer is returned.  Sqlite3_aggregate_context() is normally
- * called once for each invocation of the xStep callback and then one
- * last time when the xFinal callback is invoked.  ^(When no rows match
- * an aggregate query, the xStep() callback of the aggregate function
- * implementation is never called and xFinal() is called exactly once.
- * In those cases, sqlite3_aggregate_context() might be called for the
- * first time from within xFinal().)^
- *
- * ^The sqlite3_aggregate_context(C,N) routine returns a NULL pointer
- * when first called if N is less than or equal to zero or if a memory
- * allocate error occurs.
- *
- * ^(The amount of space allocated by sqlite3_aggregate_context(C,N) is
- * determined by the N parameter on first successful call.  Changing the
- * value of N in subsequent call to sqlite3_aggregate_context() within
- * the same aggregate function instance will not resize the memory
- * allocation.)^  Within the xFinal callback, it is customary to set
- * N=0 in calls to sqlite3_aggregate_context(C,N) so that no
- * pointless memory allocations occur.
- *
- * ^SQLite automatically frees the memory allocated by
- * sqlite3_aggregate_context() when the aggregate query concludes.
- *
- * The first parameter must be a copy of the
- * [sqlite3_context | SQL function context] that is the first parameter
- * to the xStep or xFinal callback routine that implements the aggregate
- * function.
- *
- * This routine must be called from the same thread in which
- * the aggregate SQL function is running.
-*/
-SQLITE_API void *
-sqlite3_aggregate_context(sqlite3_context *,
-			  int nBytes);
-
-/*
- * CAPI3REF: User Data For Functions
- * METHOD: sqlite3_context
- *
- * ^The sqlite3_user_data() interface returns a copy of
- * the pointer that was the pUserData parameter (the 5th parameter)
- * of the [sqlite3_create_function()]
- * and [sqlite3_create_function16()] routines that originally
- * registered the application defined function.
- *
- * This routine must be called from the same thread in which
- * the application-defined function is running.
-*/
-SQLITE_API void *
-sqlite3_user_data(sqlite3_context *);
-
-/*
- * CAPI3REF: Database Connection For Functions
- * METHOD: sqlite3_context
- *
- * ^The sqlite3_context_db_handle() interface returns a copy of
- * the pointer to the [database connection] (the 1st parameter)
- * of the [sqlite3_create_function()]
- * and [sqlite3_create_function16()] routines that originally
- * registered the application defined function.
-*/
-SQLITE_API sqlite3 *
-sqlite3_context_db_handle(sqlite3_context *);
-
-/*
- * CAPI3REF: Function Auxiliary Data
- * METHOD: sqlite3_context
- *
- * These functions may be used by (non-aggregate) SQL functions to
- * associate metadata with argument values. If the same value is passed to
- * multiple invocations of the same SQL function during query execution, under
- * some circumstances the associated metadata may be preserved.  An example
- * of where this might be useful is in a regular-expression matching
- * function. The compiled version of the regular expression can be stored as
- * metadata associated with the pattern string.
- * Then as long as the pattern string remains the same,
- * the compiled regular expression can be reused on multiple
- * invocations of the same function.
- *
- * ^The sqlite3_get_auxdata() interface returns a pointer to the metadata
- * associated by the sqlite3_set_auxdata() function with the Nth argument
- * value to the application-defined function. ^If there is no metadata
- * associated with the function argument, this sqlite3_get_auxdata() interface
- * returns a NULL pointer.
- *
- * ^The sqlite3_set_auxdata(C,N,P,X) interface saves P as metadata for the N-th
- * argument of the application-defined function.  ^Subsequent
- * calls to sqlite3_get_auxdata(C,N) return P from the most recent
- * sqlite3_set_auxdata(C,N,P,X) call if the metadata is still valid or
- * NULL if the metadata has been discarded.
- * ^After each call to sqlite3_set_auxdata(C,N,P,X) where X is not NULL,
- * SQLite will invoke the destructor function X with parameter P exactly
- * once, when the metadata is discarded.
- * SQLite is free to discard the metadata at any time, including: <ul>
- * <li> ^(when the corresponding function parameter changes)^, or
- * <li> ^(when [sqlite3_reset()] or [sqlite3_finalize()] is called for the
- *      SQL statement)^, or
- * <li> ^(when sqlite3_set_auxdata() is invoked again on the same
- *       parameter)^, or
- * <li> ^(during the original sqlite3_set_auxdata() call when a memory
- *      allocation error occurs.)^ </ul>
- *
- * Note the last bullet in particular.  The destructor X in
- * sqlite3_set_auxdata(C,N,P,X) might be called immediately, before the
- * sqlite3_set_auxdata() interface even returns.  Hence sqlite3_set_auxdata()
- * should be called near the end of the function implementation and the
- * function implementation should not make any use of P after
- * sqlite3_set_auxdata() has been called.
- *
- * ^(In practice, metadata is preserved between function calls for
- * function parameters that are compile-time constants, including literal
- * values and [parameters] and expressions composed from the same.)^
- *
- * These routines must be called from the same thread in which
- * the SQL function is running.
-*/
-SQLITE_API void *
-sqlite3_get_auxdata(sqlite3_context *, int N);
-
-SQLITE_API void
-sqlite3_set_auxdata(sqlite3_context *, int N, void *,
-		    void (*)(void *));
-
-/*
- * CAPI3REF: Constants Defining Special Destructor Behavior
- *
- * These are special values for the destructor that is passed in as the
- * final argument to routines like [sqlite3_result_blob()].  ^If the destructor
- * argument is SQLITE_STATIC, it means that the content pointer is constant
- * and will never change.  It does not need to be destroyed.  ^The
- * SQLITE_TRANSIENT value means that the content will likely change in
- * the near future and that SQLite should make its own private copy of
- * the content before returning.
- *
- * The typedef is necessary to work around problems in certain
- * C++ compilers.
-*/
-typedef void (*sqlite3_destructor_type) (void *);
-#define SQLITE_STATIC      ((sqlite3_destructor_type)0)
-#define SQLITE_TRANSIENT   ((sqlite3_destructor_type)-1)
-
-/*
- * CAPI3REF: Setting The Result Of An SQL Function
- * METHOD: sqlite3_context
- *
- * These routines are used by the xFunc or xFinal callbacks that
- * implement SQL functions and aggregates.  See
- * [sqlite3_create_function()] and [sqlite3_create_function16()]
- * for additional information.
- *
- * These functions work very much like the [parameter binding] family of
- * functions used to bind values to host parameters in prepared statements.
- * Refer to the [SQL parameter] documentation for additional information.
- *
- * ^The sqlite3_result_blob() interface sets the result from
- * an application-defined function to be the BLOB whose content is pointed
- * to by the second parameter and which is N bytes long where N is the
- * third parameter.
- *
- * ^The sqlite3_result_zeroblob(C,N) and sqlite3_result_zeroblob64(C,N)
- * interfaces set the result of the application-defined function to be
- * a BLOB containing all zero bytes and N bytes in size.
- *
- * ^The sqlite3_result_double() interface sets the result from
- * an application-defined function to be a floating point value specified
- * by its 2nd argument.
- *
- * ^The sqlite3_result_error()
- * cause the implemented SQL function to throw an exception.
- * ^SQLite uses the string pointed to by the
- * 2nd parameter of sqlite3_result_error() as the text of an error message.  ^SQLite interprets the error
- * message string from sqlite3_result_error() as UTF-8.
- * ^If the third parameter to sqlite3_result_error()
- * negative then SQLite takes as the error
- * message all text up through the first zero character.
- * ^If the third parameter to sqlite3_result_error() or
- * sqlite3_result_error16() is non-negative then SQLite takes that many
- * bytes (not characters) from the 2nd parameter as the error message.
- * ^The sqlite3_result_error() and sqlite3_result_error16()
- * routines make a private copy of the error message text before
- * they return.  Hence, the calling function can deallocate or
- * modify the text after they return without harm.
- * ^The sqlite3_result_error_code() function changes the error code
- * returned by SQLite as a result of an error in a function.  ^By default,
- * the error code is SQLITE_ERROR.  ^A subsequent call to sqlite3_result_error()
- * or sqlite3_result_error16() resets the error code to SQLITE_ERROR.
- *
- * ^The sqlite3_result_error_toobig() interface causes SQLite to throw an
- * error indicating that a string or BLOB is too long to represent.
- *
- * ^The sqlite3_result_error_nomem() interface causes SQLite to throw an
- * error indicating that a memory allocation failed.
- *
- * ^The sqlite3_result_int() interface sets the return value
- * of the application-defined function to be the 32-bit signed integer
- * value given in the 2nd argument.
- * ^The sqlite3_result_int64() interface sets the return value
- * of the application-defined function to be the 64-bit signed integer
- * value given in the 2nd argument.
- *
- * ^The sqlite3_result_null() interface sets the return value
- * of the application-defined function to be NULL.
- *
- * ^The sqlite3_result_text()
- * set the return value of the application-defined function to be
- * a text string which is represented as UTF-8, UTF-16 native byte order,
- * UTF-16 little endian, or UTF-16 big endian, respectively.
- * ^The sqlite3_result_text64() interface sets the return value of an
- * application-defined function to be a text string in an encoding
- * specified by the fifth (and last) parameter, which must be one
- * of [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE].
- * ^SQLite takes the text result from the application from
- * the 2nd parameter of the sqlite3_result_text* interfaces.
- * ^If the 3rd parameter to the sqlite3_result_text* interfaces
- * is negative, then SQLite takes result text from the 2nd parameter
- * through the first zero character.
- * ^If the 3rd parameter to the sqlite3_result_text* interfaces
- * is non-negative, then as many bytes (not characters) of the text
- * pointed to by the 2nd parameter are taken as the application-defined
- * function result.  If the 3rd parameter is non-negative, then it
- * must be the byte offset into the string where the NUL terminator would
- * appear if the string where NUL terminated.  If any NUL characters occur
- * in the string at a byte offset that is less than the value of the 3rd
- * parameter, then the resulting string will contain embedded NULs and the
- * result of expressions operating on strings with embedded NULs is undefined.
- * ^If the 4th parameter to the sqlite3_result_text* interfaces
- * or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that
- * function as the destructor on the text or BLOB result when it has
- * finished using that result.
- * ^If the 4th parameter to the sqlite3_result_text* interfaces or to
- * sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite
- * assumes that the text or BLOB result is in constant space and does not
- * copy the content of the parameter nor call a destructor on the content
- * when it has finished using that result.
- * ^If the 4th parameter to the sqlite3_result_text* interfaces
- * or sqlite3_result_blob is the special constant SQLITE_TRANSIENT
- * then SQLite makes a copy of the result into space obtained from
- * from [sqlite3_malloc()] before it returns.
- *
- * ^The sqlite3_result_value() interface sets the result of
- * the application-defined function to be a copy of the
- * [unprotected sqlite3_value] object specified by the 2nd parameter.  ^The
- * sqlite3_result_value() interface makes a copy of the [sqlite3_value]
- * so that the [sqlite3_value] specified in the parameter may change or
- * be deallocated after sqlite3_result_value() returns without harm.
- * ^A [protected sqlite3_value] object may always be used where an
- * [unprotected sqlite3_value] object is required, so either
- * kind of [sqlite3_value] object can be used with this interface.
- *
- * If these routines are called from within the different thread
- * than the one containing the application-defined function that received
- * the [sqlite3_context] pointer, the results are undefined.
-*/
-SQLITE_API void
-sqlite3_result_blob(sqlite3_context *, const void *,
-		    int, void (*)(void *));
-
-SQLITE_API void
-sqlite3_result_blob64(sqlite3_context *, const void *,
-		      sqlite3_uint64, void (*)(void *));
-
-SQLITE_API void
-sqlite3_result_double(sqlite3_context *, double);
-
-SQLITE_API void
-sqlite3_result_error(sqlite3_context *, const char *,
-		     int);
-
-SQLITE_API void
-sqlite3_result_error_toobig(sqlite3_context *);
-
-SQLITE_API void
-sqlite3_result_error_nomem(sqlite3_context *);
-
-SQLITE_API void
-sqlite3_result_error_code(sqlite3_context *, int);
-
-SQLITE_API void
-sqlite3_result_int(sqlite3_context *, int);
-
-SQLITE_API void
-sqlite3_result_int64(sqlite3_context *, sqlite3_int64);
-
-SQLITE_API void
-sqlite3_result_null(sqlite3_context *);
-
-SQLITE_API void
-sqlite3_result_text(sqlite3_context *, const char *,
-		    int, void (*)(void *));
-
-SQLITE_API void
-sqlite3_result_text64(sqlite3_context *, const char *,
-		      sqlite3_uint64, void (*)(void *));
-
-SQLITE_API void
-sqlite3_result_value(sqlite3_context *,
-		     sqlite3_value *);
-
-SQLITE_API void
-sqlite3_result_zeroblob(sqlite3_context *, int n);
-
-SQLITE_API int
-sqlite3_result_zeroblob64(sqlite3_context *,
-			  sqlite3_uint64 n);
-
-/*
- * CAPI3REF: Setting The Subtype Of An SQL Function
- * METHOD: sqlite3_context
- *
- * The sqlite3_result_subtype(C,T) function causes the subtype of
- * the result from the [application-defined SQL function] with
- * [sqlite3_context] C to be the value T.  Only the lower 8 bits
- * of the subtype T are preserved in current versions of SQLite;
- * higher order bits are discarded.
- * The number of subtype bytes preserved by SQLite might increase
- * in future releases of SQLite.
-*/
-SQLITE_API void
-sqlite3_result_subtype(sqlite3_context *, unsigned int);
-
-#ifdef SQLITE_HAS_CODEC
-/*
- * Specify the key for an encrypted database.  This routine should be
- * called right after sqlite3_open().
- *
- * The code to implement this API is not available in the public release
- * of SQLite.
-*/
-SQLITE_API int
-sqlite3_key(sqlite3 * db,	/* Database to be rekeyed */
-	    const void *pKey, int nKey	/* The key */
-	);
-
-SQLITE_API int
-sqlite3_key_v2(sqlite3 * db,	/* Database to be rekeyed */
-	       const void *pKey, int nKey	/* The key */
-	);
-
-/*
- * Change the key on an open database.  If the current database is not
- * encrypted, this routine will encrypt it.  If pNew==0 or nNew==0, the
- * database is decrypted.
- *
- * The code to implement this API is not available in the public release
- * of SQLite.
-*/
-SQLITE_API int
-sqlite3_rekey(sqlite3 * db,	/* Database to be rekeyed */
-	      const void *pKey, int nKey	/* The new key */
-	);
-
-SQLITE_API int
-sqlite3_rekey_v2(sqlite3 * db,	/* Database to be rekeyed */
-		 const void *pKey, int nKey	/* The new key */
-	);
-
-/*
- * Specify the activation key for a SEE database.  Unless
- * activated, none of the SEE routines will work.
-*/
-SQLITE_API void
-sqlite3_activate_see(const char *zPassPhrase	/* Activation phrase */
-	);
-#endif
-
-#ifdef SQLITE_ENABLE_CEROD
-/*
- * Specify the activation key for a CEROD database.  Unless
- * activated, none of the CEROD routines will work.
-*/
-SQLITE_API void
-sqlite3_activate_cerod(const char *zPassPhrase	/* Activation phrase */
-	);
-#endif
-
-/*
- * CAPI3REF: Suspend Execution For A Short Time
- *
- * The sqlite3_sleep() function causes the current thread to suspend execution
- * for at least a number of milliseconds specified in its parameter.
- *
- * If the operating system does not support sleep requests with
- * millisecond time resolution, then the time will be rounded up to
- * the nearest second. The number of milliseconds of sleep actually
- * requested from the operating system is returned.
- *
- * ^SQLite implements this interface by calling the xSleep()
- * method of the default [sqlite3_vfs] object.  If the xSleep() method
- * of the default VFS is not implemented correctly, or not implemented at
- * all, then the behavior of sqlite3_sleep() may deviate from the description
- * in the previous paragraphs.
-*/
-SQLITE_API int
-sqlite3_sleep(int);
-
-/*
- * CAPI3REF: Name Of The Folder Holding Temporary Files
- *
- * ^(If this global variable is made to point to a string which is
- * the name of a folder (a.k.a. directory), then all temporary files
- * created by SQLite when using a built-in [sqlite3_vfs | VFS]
- * will be placed in that directory.)^  ^If this variable
- * is a NULL pointer, then SQLite performs a search for an appropriate
- * temporary file directory.
- *
- * Applications are strongly discouraged from using this global variable.
- * It is highly recommended that applications
- * neither read nor write this variable.  This global variable is a relic
- * that exists for backwards compatibility of legacy applications and should
- * be avoided in new projects.
- *
- * It is not safe to read or modify this variable in more than one
- * thread at a time.  It is not safe to read or modify this variable
- * if a [database connection] is being used at the same time in a separate
- * thread.
- * It is intended that this variable be set once
- * as part of process initialization and before any SQLite interface
- * routines have been called and that this variable remain unchanged
- * thereafter.
- *
- * ^The [temp_store_directory pragma] may modify this variable and cause
- * it to point to memory obtained from [sqlite3_malloc].  ^Furthermore,
- * the [temp_store_directory pragma] always assumes that any string
- * that this variable points to is held in memory obtained from
- * [sqlite3_malloc] and the pragma may attempt to free that memory
- * using [sqlite3_free].
- * Hence, if this variable is modified directly, either it should be
- * made NULL or made to point to memory obtained from [sqlite3_malloc]
- * or else the use of the [temp_store_directory pragma] should be avoided.
- * Except when requested by the [temp_store_directory pragma], SQLite
- * does not free the memory that sqlite3_temp_directory points to.  If
- * the application wants that memory to be freed, it must do
- * so itself, taking care to only do so after all [database connection]
- * objects have been destroyed.
-*/
-SQLITE_API SQLITE_EXTERN char *
-sqlite3_temp_directory;
-
-/*
- * CAPI3REF: Name Of The Folder Holding Database Files
- *
- * ^(If this global variable is made to point to a string which is
- * the name of a folder (a.k.a. directory), then all database files
- * specified with a relative pathname and created or accessed by
- * SQLite when using a built-in windows [sqlite3_vfs | VFS] will be assumed
- * to be relative to that directory.)^ ^If this variable is a NULL
- * pointer, then SQLite assumes that all database files specified
- * with a relative pathname are relative to the current directory
- * for the process. It is ignored by the unix VFS.
- *
- * Changing the value of this variable while a database connection is
- * open can result in a corrupt database.
- *
- * It is not safe to read or modify this variable in more than one
- * thread at a time.  It is not safe to read or modify this variable
- * if a [database connection] is being used at the same time in a separate
- * thread.
- * It is intended that this variable be set once
- * as part of process initialization and before any SQLite interface
- * routines have been called and that this variable remain unchanged
- * thereafter.
- *
- * ^The [data_store_directory pragma] may modify this variable and cause
- * it to point to memory obtained from [sqlite3_malloc].  ^Furthermore,
- * the [data_store_directory pragma] always assumes that any string
- * that this variable points to is held in memory obtained from
- * [sqlite3_malloc] and the pragma may attempt to free that memory
- * using [sqlite3_free].
- * Hence, if this variable is modified directly, either it should be
- * made NULL or made to point to memory obtained from [sqlite3_malloc]
- * or else the use of the [data_store_directory pragma] should be avoided.
-*/
-SQLITE_API SQLITE_EXTERN char *
-sqlite3_data_directory;
-
-/*
- * CAPI3REF: Test For Auto-Commit Mode
- * KEYWORDS: {autocommit mode}
- * METHOD: sqlite3
- *
- * ^The sqlite3_get_autocommit() interface returns non-zero or
- * zero if the given database connection is or is not in autocommit mode,
- * respectively.  ^Autocommit mode is on by default.
- * ^Autocommit mode is disabled by a [BEGIN] statement.
- * ^Autocommit mode is re-enabled by a [COMMIT] or [ROLLBACK].
- *
- * If certain kinds of errors occur on a statement within a multi-statement
- * transaction (errors including [SQLITE_FULL], [SQLITE_IOERR],
- * [SQLITE_NOMEM], [SQLITE_BUSY], and [SQLITE_INTERRUPT]) then the
- * transaction might be rolled back automatically.  The only way to
- * find out whether SQLite automatically rolled back the transaction after
- * an error is to use this function.
- *
- * If another thread changes the autocommit status of the database
- * connection while this routine is running, then the return value
- * is undefined.
-*/
-SQLITE_API int
-sqlite3_get_autocommit(sqlite3 *);
-
-/*
- * CAPI3REF: Find The Database Handle Of A Prepared Statement
- * METHOD: sqlite3_stmt
- *
- * ^The sqlite3_db_handle interface returns the [database connection] handle
- * to which a [prepared statement] belongs.  ^The [database connection]
- * returned by sqlite3_db_handle is the same [database connection]
- * that was the first argument
- * to the [sqlite3_prepare_v2()] call (or its variants) that was used to
- * create the statement in the first place.
-*/
-SQLITE_API sqlite3 *
-sqlite3_db_handle(sqlite3_stmt *);
-
-/*
- * CAPI3REF: Return The Filename For A Database Connection
- * METHOD: sqlite3
- *
- * ^The sqlite3_db_filename(D,N) interface returns a pointer to a filename
- * associated with database N of connection D.  ^The main database file
- * has the name "main".  If there is no attached database N on the database
- * connection D, or if database N is a temporary or in-memory database, then
- * a NULL pointer is returned.
- *
- * ^The filename returned by this function is the output of the
- * xFullPathname method of the [VFS].  ^In other words, the filename
- * will be an absolute pathname, even if the filename used
- * to open the database originally was a URI or relative pathname.
-*/
-SQLITE_API const char *
-sqlite3_db_filename(sqlite3 * db);
-
-/*
- * CAPI3REF: Determine if a database is read-only
- * METHOD: sqlite3
- *
- * ^The sqlite3_db_readonly(D,N) interface returns 1 if the database N
- * of connection D is read-only, 0 if it is read/write, or -1 if N is not
- * the name of a database on connection D.
-*/
-SQLITE_API int
-sqlite3_db_readonly(sqlite3 * db);
-
-/*
- * CAPI3REF: Find the next prepared statement
- * METHOD: sqlite3
- *
- * ^This interface returns a pointer to the next [prepared statement] after
- * pStmt associated with the [database connection] pDb.  ^If pStmt is NULL
- * then this interface returns a pointer to the first prepared statement
- * associated with the database connection pDb.  ^If no prepared statement
- * satisfies the conditions of this routine, it returns NULL.
- *
- * The [database connection] pointer D in a call to
- * [sqlite3_next_stmt(D,S)] must refer to an open database
- * connection and in particular must not be a NULL pointer.
-*/
-SQLITE_API sqlite3_stmt *
-sqlite3_next_stmt(sqlite3 * pDb,
-		  sqlite3_stmt * pStmt);
-
-/*
- * CAPI3REF: Commit And Rollback Notification Callbacks
- * METHOD: sqlite3
- *
- * ^The sqlite3_commit_hook() interface registers a callback
- * function to be invoked whenever a transaction is [COMMIT | committed].
- * ^Any callback set by a previous call to sqlite3_commit_hook()
- * for the same database connection is overridden.
- * ^The sqlite3_rollback_hook() interface registers a callback
- * function to be invoked whenever a transaction is [ROLLBACK | rolled back].
- * ^Any callback set by a previous call to sqlite3_rollback_hook()
- * for the same database connection is overridden.
- * ^The pArg argument is passed through to the callback.
- * ^If the callback on a commit hook function returns non-zero,
- * then the commit is converted into a rollback.
- *
- * ^The sqlite3_commit_hook(D,C,P) and sqlite3_rollback_hook(D,C,P) functions
- * return the P argument from the previous call of the same function
- * on the same [database connection] D, or NULL for
- * the first call for each function on D.
- *
- * The commit and rollback hook callbacks are not reentrant.
- * The callback implementation must not do anything that will modify
- * the database connection that invoked the callback.  Any actions
- * to modify the database connection must be deferred until after the
- * completion of the [sqlite3_step()] call that triggered the commit
- * or rollback hook in the first place.
- * Note that running any other SQL statements, including SELECT statements,
- * or merely calling [sqlite3_prepare_v2()] and [sqlite3_step()] will modify
- * the database connections for the meaning of "modify" in this paragraph.
- *
- * ^Registering a NULL function disables the callback.
- *
- * ^When the commit hook callback routine returns zero, the [COMMIT]
- * operation is allowed to continue normally.  ^If the commit hook
- * returns non-zero, then the [COMMIT] is converted into a [ROLLBACK].
- * ^The rollback hook is invoked on a rollback that results from a commit
- * hook returning non-zero, just as it would be with any other rollback.
- *
- * ^For the purposes of this API, a transaction is said to have been
- * rolled back if an explicit "ROLLBACK" statement is executed, or
- * an error or constraint causes an implicit rollback to occur.
- * ^The rollback callback is not invoked if a transaction is
- * automatically rolled back because the database connection is closed.
- *
- * See also the [sqlite3_update_hook()] interface.
-*/
-SQLITE_API void *
-sqlite3_commit_hook(sqlite3 *, int (*)(void *),
-		    void *);
-
-SQLITE_API void *
-sqlite3_rollback_hook(sqlite3 *, void (*)(void *),
-		      void *);
-
-/*
- * CAPI3REF: Enable Or Disable Shared Pager Cache
- *
- * ^(This routine enables or disables the sharing of the database cache
- * and schema data structures between [database connection | connections]
- * to the same database. Sharing is enabled if the argument is true
- * and disabled if the argument is false.)^
- *
- * ^Cache sharing is enabled and disabled for an entire process.
- * This is a change as of SQLite [version 3.5.0] ([dateof:3.5.0]).
- * In prior versions of SQLite,
- * sharing was enabled or disabled for each thread separately.
- *
- * ^(The cache sharing mode set by this interface effects all subsequent
- * calls to [sqlite3_open()], [sqlite3_open_v2()], and [sqlite3_open16()].
- * Existing database connections continue use the sharing mode
- * that was in effect at the time they were opened.)^
- *
- * ^(This routine returns [SQLITE_OK] if shared cache was enabled or disabled
- * successfully.  An [error code] is returned otherwise.)^
- *
- * ^Shared cache is disabled by default. But this might change in
- * future releases of SQLite.  Applications that care about shared
- * cache setting should set it explicitly.
- *
- * Note: This method is disabled on MacOS X 10.7 and iOS version 5.0
- * and will always return SQLITE_MISUSE. On those systems,
- * shared cache mode should be enabled per-database connection via
- * [sqlite3_open_v2()] with [SQLITE_OPEN_SHAREDCACHE].
- *
- * This interface is threadsafe on processors where writing a
- * 32-bit integer is atomic.
- *
- * See Also:  [SQLite Shared-Cache Mode]
-*/
-SQLITE_API int
-sqlite3_enable_shared_cache(int);
-
-/*
- * CAPI3REF: Attempt To Free Heap Memory
- *
- * ^The sqlite3_release_memory() interface attempts to free N bytes
- * of heap memory by deallocating non-essential memory allocations
- * held by the database library.   Memory used to cache database
- * pages to improve performance is an example of non-essential memory.
- * ^sqlite3_release_memory() returns the number of bytes actually freed,
- * which might be more or less than the amount requested.
- * ^The sqlite3_release_memory() routine is a no-op returning zero
- * if SQLite is not compiled with [SQLITE_ENABLE_MEMORY_MANAGEMENT].
- *
- * See also: [sqlite3_db_release_memory()]
-*/
-SQLITE_API int
-sqlite3_release_memory(int);
-
-/*
- * CAPI3REF: Free Memory Used By A Database Connection
- * METHOD: sqlite3
- *
- * ^The sqlite3_db_release_memory(D) interface attempts to free as much heap
- * memory as possible from database connection D. Unlike the
- * [sqlite3_release_memory()] interface, this interface is in effect even
- * when the [SQLITE_ENABLE_MEMORY_MANAGEMENT] compile-time option is
- * omitted.
- *
- * See also: [sqlite3_release_memory()]
-*/
-SQLITE_API int
-sqlite3_db_release_memory(sqlite3 *);
-
-/*
- * CAPI3REF: Impose A Limit On Heap Size
- *
- * ^The sqlite3_soft_heap_limit64() interface sets and/or queries the
- * soft limit on the amount of heap memory that may be allocated by SQLite.
- * ^SQLite strives to keep heap memory utilization below the soft heap
- * limit by reducing the number of pages held in the page cache
- * as heap memory usages approaches the limit.
- * ^The soft heap limit is "soft" because even though SQLite strives to stay
- * below the limit, it will exceed the limit rather than generate
- * an [SQLITE_NOMEM] error.  In other words, the soft heap limit
- * is advisory only.
- *
- * ^The return value from sqlite3_soft_heap_limit64() is the size of
- * the soft heap limit prior to the call, or negative in the case of an
- * error.  ^If the argument N is negative
- * then no change is made to the soft heap limit.  Hence, the current
- * size of the soft heap limit can be determined by invoking
- * sqlite3_soft_heap_limit64() with a negative argument.
- *
- * ^If the argument N is zero then the soft heap limit is disabled.
- *
- * ^(The soft heap limit is not enforced in the current implementation
- * if one or more of following conditions are true:
- *
- * <ul>
- * <li> The soft heap limit is set to zero.
- * <li> Memory accounting is disabled using a combination of the
- *      [sqlite3_config]([SQLITE_CONFIG_MEMSTATUS],...) start-time option and
- *      the [SQLITE_DEFAULT_MEMSTATUS] compile-time option.
- * <li> An alternative page cache implementation is specified using
- *      [sqlite3_config]([SQLITE_CONFIG_PCACHE2],...).
- * <li> The page cache allocates from its own memory pool supplied
- *      by [sqlite3_config]([SQLITE_CONFIG_PAGECACHE],...) rather than
- *      from the heap.
- * </ul>)^
- *
- * Beginning with SQLite [version 3.7.3] ([dateof:3.7.3]),
- * the soft heap limit is enforced
- * regardless of whether or not the [SQLITE_ENABLE_MEMORY_MANAGEMENT]
- * compile-time option is invoked.  With [SQLITE_ENABLE_MEMORY_MANAGEMENT],
- * the soft heap limit is enforced on every memory allocation.  Without
- * [SQLITE_ENABLE_MEMORY_MANAGEMENT], the soft heap limit is only enforced
- * when memory is allocated by the page cache.  Testing suggests that because
- * the page cache is the predominate memory user in SQLite, most
- * applications will achieve adequate soft heap limit enforcement without
- * the use of [SQLITE_ENABLE_MEMORY_MANAGEMENT].
- *
- * The circumstances under which SQLite will enforce the soft heap limit may
- * changes in future releases of SQLite.
-*/
-SQLITE_API sqlite3_int64
-sqlite3_soft_heap_limit64(sqlite3_int64 N);
-
-/*
- * CAPI3REF: Extract Metadata About A Column Of A Table
- * METHOD: sqlite3
- *
- * ^(The sqlite3_table_column_metadata(X,D,T,C,....) routine returns
- * information about column C of table T in database D
- * on [database connection] X.)^  ^The sqlite3_table_column_metadata()
- * interface returns SQLITE_OK and fills in the non-NULL pointers in
- * the final five arguments with appropriate values if the specified
- * column exists.  ^The sqlite3_table_column_metadata() interface returns
- * SQLITE_ERROR and if the specified column does not exist.
- * ^If the column-name parameter to sqlite3_table_column_metadata() is a
- * NULL pointer, then this routine simply checks for the existence of the
- * table and returns SQLITE_OK if the table exists and SQLITE_ERROR if it
- * does not.
- *
- * ^The column is identified by the second, third and fourth parameters to
- * this function. ^(The second parameter is either the name of the database
- * (i.e. "main", "temp", or an attached database) containing the specified
- * table or NULL.)^ ^If it is NULL, then all attached databases are searched
- * for the table using the same algorithm used by the database engine to
- * resolve unqualified table references.
- *
- * ^The third and fourth parameters to this function are the table and column
- * name of the desired column, respectively.
- *
- * ^Metadata is returned by writing to the memory locations passed as the 5th
- * and subsequent parameters to this function. ^Any of these arguments may be
- * NULL, in which case the corresponding element of metadata is omitted.
- *
- * ^(<blockquote>
- * <table border="1">
- * <tr><th> Parameter <th> Output<br>Type <th>  Description
- *
- * <tr><td> 5th <td> const char* <td> Data type
- * <tr><td> 6th <td> const char* <td> Name of default collation sequence
- * <tr><td> 7th <td> int         <td> True if column has a NOT NULL constraint
- * <tr><td> 8th <td> int         <td> True if column is part of the PRIMARY KEY
- * <tr><td> 9th <td> int         <td> True if column is [AUTOINCREMENT]
- * </table>
- * </blockquote>)^
- *
- * ^The memory pointed to by the character pointers returned for the
- * declaration type and collation sequence is valid until the next
- * call to any SQLite API function.
- *
- * ^If the specified table is actually a view, an [error code] is returned.
- *
- * ^This function causes all database schemas to be read from disk and
- * parsed, if that has not already been done, and returns an error if
- * any errors are encountered while loading the schema.
-*/
-SQLITE_API int
-sqlite3_table_column_metadata(sqlite3 * db,
-			      const char *zTableName,
-			      const char *zColumnName,
-			      char const **pzDataType,
-			      char const **pzCollSeq,
-			      int *pNotNull,
-			      int *pPrimaryKey,
-			      int *pAutoinc);
-
-/*
- * CAPI3REF: A Handle To An Open BLOB
- * KEYWORDS: {BLOB handle} {BLOB handles}
- *
- * An instance of this object represents an open BLOB on which
- * [sqlite3_blob_open | incremental BLOB I/O] can be performed.
- * ^Objects of this type are created by [sqlite3_blob_open()]
- * and destroyed by [sqlite3_blob_close()].
- * ^The [sqlite3_blob_read()] and [sqlite3_blob_write()] interfaces
- * can be used to read or write small subsections of the BLOB.
- * ^The [sqlite3_blob_bytes()] interface returns the size of the BLOB in bytes.
-*/
-typedef struct sqlite3_blob sqlite3_blob;
-
-/*
- * CAPI3REF: Close A BLOB Handle
- * DESTRUCTOR: sqlite3_blob
- *
- * ^This function closes an open [BLOB handle]. ^(The BLOB handle is closed
- * unconditionally.  Even if this routine returns an error code, the
- * handle is still closed.)^
- *
- * ^If the blob handle being closed was opened for read-write access, and if
- * the database is in auto-commit mode and there are no other open read-write
- * blob handles or active write statements, the current transaction is
- * committed. ^If an error occurs while committing the transaction, an error
- * code is returned and the transaction rolled back.
- *
- * Calling this function with an argument that is not a NULL pointer or an
- * open blob handle results in undefined behaviour. ^Calling this routine
- * with a null pointer (such as would be returned by a failed call to
- * [sqlite3_blob_open()]) is a harmless no-op. ^Otherwise, if this function
- * is passed a valid open blob handle, the values returned by the
- * sqlite3_errcode() and sqlite3_errmsg() functions are set before returning.
-*/
-SQLITE_API int
-sqlite3_blob_close(sqlite3_blob *);
-
-/*
- * CAPI3REF: Return The Size Of An Open BLOB
- * METHOD: sqlite3_blob
- *
- * ^Returns the size in bytes of the BLOB accessible via the
- * successfully opened [BLOB handle] in its only argument.  ^The
- * incremental blob I/O routines can only read or overwriting existing
- * blob content; they cannot change the size of a blob.
- *
- * This routine only works on a [BLOB handle] which has been created
- * by a prior successful call to [sqlite3_blob_open()] and which has not
- * been closed by [sqlite3_blob_close()].  Passing any other pointer in
- * to this routine results in undefined and probably undesirable behavior.
-*/
-SQLITE_API int
-sqlite3_blob_bytes(sqlite3_blob *);
-
-/*
- * CAPI3REF: Read Data From A BLOB Incrementally
- * METHOD: sqlite3_blob
- *
- * ^(This function is used to read data from an open [BLOB handle] into a
- * caller-supplied buffer. N bytes of data are copied into buffer Z
- * from the open BLOB, starting at offset iOffset.)^
- *
- * ^If offset iOffset is less than N bytes from the end of the BLOB,
- * [SQLITE_ERROR] is returned and no data is read.  ^If N or iOffset is
- * less than zero, [SQLITE_ERROR] is returned and no data is read.
- * ^The size of the blob (and hence the maximum value of N+iOffset)
- * can be determined using the [sqlite3_blob_bytes()] interface.
- *
- * ^An attempt to read from an expired [BLOB handle] fails with an
- * error code of [SQLITE_ABORT].
- *
- * ^(On success, sqlite3_blob_read() returns SQLITE_OK.
- * Otherwise, an [error code] or an [extended error code] is returned.)^
- *
- * This routine only works on a [BLOB handle] which has been created
- * by a prior successful call to [sqlite3_blob_open()] and which has not
- * been closed by [sqlite3_blob_close()].  Passing any other pointer in
- * to this routine results in undefined and probably undesirable behavior.
- *
- * See also: [sqlite3_blob_write()].
-*/
-SQLITE_API int
-sqlite3_blob_read(sqlite3_blob *, void *Z, int N,
-		  int iOffset);
-
-/*
- * CAPI3REF: Write Data Into A BLOB Incrementally
- * METHOD: sqlite3_blob
- *
- * ^(This function is used to write data into an open [BLOB handle] from a
- * caller-supplied buffer. N bytes of data are copied from the buffer Z
- * into the open BLOB, starting at offset iOffset.)^
- *
- * ^(On success, sqlite3_blob_write() returns SQLITE_OK.
- * Otherwise, an  [error code] or an [extended error code] is returned.)^
- * ^Unless SQLITE_MISUSE is returned, this function sets the
- * [database connection] error code and message accessible via
- * [sqlite3_errcode()] and [sqlite3_errmsg()] and related functions.
- *
- * ^If the [BLOB handle] passed as the first argument was not opened for
- * writing (the flags parameter to [sqlite3_blob_open()] was zero),
- * this function returns [SQLITE_READONLY].
- *
- * This function may only modify the contents of the BLOB; it is
- * not possible to increase the size of a BLOB using this API.
- * ^If offset iOffset is less than N bytes from the end of the BLOB,
- * [SQLITE_ERROR] is returned and no data is written. The size of the
- * BLOB (and hence the maximum value of N+iOffset) can be determined
- * using the [sqlite3_blob_bytes()] interface. ^If N or iOffset are less
- * than zero [SQLITE_ERROR] is returned and no data is written.
- *
- * ^An attempt to write to an expired [BLOB handle] fails with an
- * error code of [SQLITE_ABORT].  ^Writes to the BLOB that occurred
- * before the [BLOB handle] expired are not rolled back by the
- * expiration of the handle, though of course those changes might
- * have been overwritten by the statement that expired the BLOB handle
- * or by other independent statements.
- *
- * This routine only works on a [BLOB handle] which has been created
- * by a prior successful call to [sqlite3_blob_open()] and which has not
- * been closed by [sqlite3_blob_close()].  Passing any other pointer in
- * to this routine results in undefined and probably undesirable behavior.
- *
- * See also: [sqlite3_blob_read()].
-*/
-SQLITE_API int
-sqlite3_blob_write(sqlite3_blob *, const void *z, int n,
-		   int iOffset);
-
-/*
- * CAPI3REF: Virtual File System Objects
- *
- * A virtual filesystem (VFS) is an [sqlite3_vfs] object
- * that SQLite uses to interact
- * with the underlying operating system.  Most SQLite builds come with a
- * single default VFS that is appropriate for the host computer.
- * New VFSes can be registered and existing VFSes can be unregistered.
- * The following interfaces are provided.
- *
- * ^The sqlite3_vfs_find() interface returns a pointer to a VFS given its name.
- * ^Names are case sensitive.
- * ^Names are zero-terminated UTF-8 strings.
- * ^If there is no match, a NULL pointer is returned.
- * ^If zVfsName is NULL then the default VFS is returned.
- *
- * ^New VFSes are registered with sqlite3_vfs_register().
- * ^Each new VFS becomes the default VFS if the makeDflt flag is set.
- * ^The same VFS can be registered multiple times without injury.
- * ^To make an existing VFS into the default VFS, register it again
- * with the makeDflt flag set.  If two different VFSes with the
- * same name are registered, the behavior is undefined.  If a
- * VFS is registered with a name that is NULL or an empty string,
- * then the behavior is undefined.
- *
- * ^Unregister a VFS with the sqlite3_vfs_unregister() interface.
- * ^(If the default VFS is unregistered, another VFS is chosen as
- * the default.  The choice for the new VFS is arbitrary.)^
-*/
-SQLITE_API sqlite3_vfs *
-sqlite3_vfs_find(const char *zVfsName);
-
-SQLITE_API int
-sqlite3_vfs_register(sqlite3_vfs *, int makeDflt);
-
-SQLITE_API int
-sqlite3_vfs_unregister(sqlite3_vfs *);
-
-/*
- * CAPI3REF: Mutexes
- *
- * The SQLite core uses these routines for thread
- * synchronization. Though they are intended for internal
- * use by SQLite, code that links against SQLite is
- * permitted to use any of these routines.
- *
- * The SQLite source code contains multiple implementations
- * of these mutex routines.  An appropriate implementation
- * is selected automatically at compile-time.  The following
- * implementations are available in the SQLite core:
- *
- * <ul>
- * <li>   SQLITE_MUTEX_PTHREADS
- * <li>   SQLITE_MUTEX_W32
- * <li>   SQLITE_MUTEX_NOOP
- * </ul>
- *
- * The SQLITE_MUTEX_NOOP implementation is a set of routines
- * that does no real locking and is appropriate for use in
- * a single-threaded application.
- *
- * If SQLite is compiled with the SQLITE_MUTEX_APPDEF preprocessor
- * macro defined (with "-DSQLITE_MUTEX_APPDEF=1"), then no mutex
- * implementation is included with the library. In this case the
- * application must supply a custom mutex implementation using the
- * [SQLITE_CONFIG_MUTEX] option of the sqlite3_config() function
- * before calling sqlite3_initialize() or any other public sqlite3_
- * function that calls sqlite3_initialize().
- *
- * ^The sqlite3_mutex_alloc() routine allocates a new
- * mutex and returns a pointer to it. ^The sqlite3_mutex_alloc()
- * routine returns NULL if it is unable to allocate the requested
- * mutex.  The argument to sqlite3_mutex_alloc() must one of these
- * integer constants:
- *
- * <ul>
- * <li>  SQLITE_MUTEX_FAST
- * <li>  SQLITE_MUTEX_RECURSIVE
- * <li>  SQLITE_MUTEX_STATIC_MASTER
- * <li>  SQLITE_MUTEX_STATIC_MEM
- * <li>  SQLITE_MUTEX_STATIC_OPEN
- * <li>  SQLITE_MUTEX_STATIC_PRNG
- * <li>  SQLITE_MUTEX_STATIC_LRU
- * <li>  SQLITE_MUTEX_STATIC_PMEM
- * <li>  SQLITE_MUTEX_STATIC_APP1
- * <li>  SQLITE_MUTEX_STATIC_APP2
- * <li>  SQLITE_MUTEX_STATIC_APP3
- * <li>  SQLITE_MUTEX_STATIC_VFS1
- * <li>  SQLITE_MUTEX_STATIC_VFS2
- * <li>  SQLITE_MUTEX_STATIC_VFS3
- * </ul>
- *
- * ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE)
- * cause sqlite3_mutex_alloc() to create
- * a new mutex.  ^The new mutex is recursive when SQLITE_MUTEX_RECURSIVE
- * is used but not necessarily so when SQLITE_MUTEX_FAST is used.
- * The mutex implementation does not need to make a distinction
- * between SQLITE_MUTEX_RECURSIVE and SQLITE_MUTEX_FAST if it does
- * not want to.  SQLite will only request a recursive mutex in
- * cases where it really needs one.  If a faster non-recursive mutex
- * implementation is available on the host platform, the mutex subsystem
- * might return such a mutex in response to SQLITE_MUTEX_FAST.
- *
- * ^The other allowed parameters to sqlite3_mutex_alloc() (anything other
- * than SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE) each return
- * a pointer to a static preexisting mutex.  ^Nine static mutexes are
- * used by the current version of SQLite.  Future versions of SQLite
- * may add additional static mutexes.  Static mutexes are for internal
- * use by SQLite only.  Applications that use SQLite mutexes should
- * use only the dynamic mutexes returned by SQLITE_MUTEX_FAST or
- * SQLITE_MUTEX_RECURSIVE.
- *
- * ^Note that if one of the dynamic mutex parameters (SQLITE_MUTEX_FAST
- * or SQLITE_MUTEX_RECURSIVE) is used then sqlite3_mutex_alloc()
- * returns a different mutex on every call.  ^For the static
- * mutex types, the same mutex is returned on every call that has
- * the same type number.
- *
- * ^The sqlite3_mutex_free() routine deallocates a previously
- * allocated dynamic mutex.  Attempting to deallocate a static
- * mutex results in undefined behavior.
- *
- * ^The sqlite3_mutex_enter() and sqlite3_mutex_try() routines attempt
- * to enter a mutex.  ^If another thread is already within the mutex,
- * sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
- * SQLITE_BUSY.  ^The sqlite3_mutex_try() interface returns [SQLITE_OK]
- * upon successful entry.  ^(Mutexes created using
- * SQLITE_MUTEX_RECURSIVE can be entered multiple times by the same thread.
- * In such cases, the
- * mutex must be exited an equal number of times before another thread
- * can enter.)^  If the same thread tries to enter any mutex other
- * than an SQLITE_MUTEX_RECURSIVE more than once, the behavior is undefined.
- *
- * ^The sqlite3_mutex_leave() routine exits a mutex that was
- * previously entered by the same thread.   The behavior
- * is undefined if the mutex is not currently entered by the
- * calling thread or is not currently allocated.
- *
- * ^If the argument to sqlite3_mutex_enter(), sqlite3_mutex_try(), or
- * sqlite3_mutex_leave() is a NULL pointer, then all three routines
- * behave as no-ops.
- *
- * See also: [sqlite3_mutex_held()] and [sqlite3_mutex_notheld()].
-*/
-SQLITE_API sqlite3_mutex *
-sqlite3_mutex_alloc(int);
-
-SQLITE_API void
-sqlite3_mutex_free(sqlite3_mutex *);
-
-SQLITE_API void
-sqlite3_mutex_enter(sqlite3_mutex *);
-
-SQLITE_API int
-sqlite3_mutex_try(sqlite3_mutex *);
-
-SQLITE_API void
-sqlite3_mutex_leave(sqlite3_mutex *);
-
-/*
- * CAPI3REF: Mutex Methods Object
- *
- * An instance of this structure defines the low-level routines
- * used to allocate and use mutexes.
- *
- * Usually, the default mutex implementations provided by SQLite are
- * sufficient, however the application has the option of substituting a custom
- * implementation for specialized deployments or systems for which SQLite
- * does not provide a suitable implementation. In this case, the application
- * creates and populates an instance of this structure to pass
- * to sqlite3_config() along with the [SQLITE_CONFIG_MUTEX] option.
- * Additionally, an instance of this structure can be used as an
- * output variable when querying the system for the current mutex
- * implementation, using the [SQLITE_CONFIG_GETMUTEX] option.
- *
- * ^The xMutexInit method defined by this structure is invoked as
- * part of system initialization by the sqlite3_initialize() function.
- * ^The xMutexInit routine is called by SQLite exactly once for each
- * effective call to [sqlite3_initialize()].
- *
- * ^The xMutexEnd method defined by this structure is invoked as
- * part of system shutdown by the sqlite3_shutdown() function. The
- * implementation of this method is expected to release all outstanding
- * resources obtained by the mutex methods implementation, especially
- * those obtained by the xMutexInit method.  ^The xMutexEnd()
- * interface is invoked exactly once for each call to [sqlite3_shutdown()].
- *
- * ^(The remaining seven methods defined by this structure (xMutexAlloc,
- * xMutexFree, xMutexEnter, xMutexTry, xMutexLeave, xMutexHeld and
- * xMutexNotheld) implement the following interfaces (respectively):
- *
- * <ul>
- *   <li>  [sqlite3_mutex_alloc()] </li>
- *   <li>  [sqlite3_mutex_free()] </li>
- *   <li>  [sqlite3_mutex_enter()] </li>
- *   <li>  [sqlite3_mutex_try()] </li>
- *   <li>  [sqlite3_mutex_leave()] </li>
- *   <li>  [sqlite3_mutex_held()] </li>
- *   <li>  [sqlite3_mutex_notheld()] </li>
- * </ul>)^
- *
- * The only difference is that the public sqlite3_XXX functions enumerated
- * above silently ignore any invocations that pass a NULL pointer instead
- * of a valid mutex handle. The implementations of the methods defined
- * by this structure are not required to handle this case, the results
- * of passing a NULL pointer instead of a valid mutex handle are undefined
- * (i.e. it is acceptable to provide an implementation that segfaults if
- * it is passed a NULL pointer).
- *
- * The xMutexInit() method must be threadsafe.  It must be harmless to
- * invoke xMutexInit() multiple times within the same process and without
- * intervening calls to xMutexEnd().  Second and subsequent calls to
- * xMutexInit() must be no-ops.
- *
- * xMutexInit() must not use SQLite memory allocation ([sqlite3_malloc()]
- * and its associates).  Similarly, xMutexAlloc() must not use SQLite memory
- * allocation for a static mutex.  ^However xMutexAlloc() may use SQLite
- * memory allocation for a fast or recursive mutex.
- *
- * ^SQLite will invoke the xMutexEnd() method when [sqlite3_shutdown()] is
- * called, but only if the prior call to xMutexInit returned SQLITE_OK.
- * If xMutexInit fails in any way, it is expected to clean up after itself
- * prior to returning.
-*/
-typedef struct sqlite3_mutex_methods sqlite3_mutex_methods;
-struct sqlite3_mutex_methods {
-	int (*xMutexInit) (void);
-	int (*xMutexEnd) (void);
-	sqlite3_mutex *(*xMutexAlloc) (int);
-	void (*xMutexFree) (sqlite3_mutex *);
-	void (*xMutexEnter) (sqlite3_mutex *);
-	int (*xMutexTry) (sqlite3_mutex *);
-	void (*xMutexLeave) (sqlite3_mutex *);
-	int (*xMutexHeld) (sqlite3_mutex *);
-	int (*xMutexNotheld) (sqlite3_mutex *);
-};
-
-/*
- * CAPI3REF: Mutex Verification Routines
- *
- * The sqlite3_mutex_held() and sqlite3_mutex_notheld() routines
- * are intended for use inside assert() statements.  The SQLite core
- * never uses these routines except inside an assert() and applications
- * are advised to follow the lead of the core.  The SQLite core only
- * provides implementations for these routines when it is compiled
- * with the SQLITE_DEBUG flag.  External mutex implementations
- * are only required to provide these routines if SQLITE_DEBUG is
- * defined and if NDEBUG is not defined.
- *
- * These routines should return true if the mutex in their argument
- * is held or not held, respectively, by the calling thread.
- *
- * The implementation is not required to provide versions of these
- * routines that actually work. If the implementation does not provide working
- * versions of these routines, it should at least provide stubs that always
- * return true so that one does not get spurious assertion failures.
- *
- * If the argument to sqlite3_mutex_held() is a NULL pointer then
- * the routine should return 1.   This seems counter-intuitive since
- * clearly the mutex cannot be held if it does not exist.  But
- * the reason the mutex does not exist is because the build is not
- * using mutexes.  And we do not want the assert() containing the
- * call to sqlite3_mutex_held() to fail, so a non-zero return is
- * the appropriate thing to do.  The sqlite3_mutex_notheld()
- * interface should also return 1 when given a NULL pointer.
-*/
-#ifndef NDEBUG
-SQLITE_API int
-sqlite3_mutex_held(sqlite3_mutex *);
-
-SQLITE_API int
-sqlite3_mutex_notheld(sqlite3_mutex *);
-#endif
-
-/*
- * CAPI3REF: Mutex Types
- *
- * The [sqlite3_mutex_alloc()] interface takes a single argument
- * which is one of these integer constants.
- *
- * The set of static mutexes may change from one SQLite release to the
- * next.  Applications that override the built-in mutex logic must be
- * prepared to accommodate additional static mutexes.
-*/
-#define SQLITE_MUTEX_FAST             0
-#define SQLITE_MUTEX_RECURSIVE        1
-#define SQLITE_MUTEX_STATIC_MASTER    2
-#define SQLITE_MUTEX_STATIC_MEM       3	/* sqlite3_malloc() */
-#define SQLITE_MUTEX_STATIC_MEM2      4	/* NOT USED */
-#define SQLITE_MUTEX_STATIC_OPEN      4	/* sqlite3BtreeOpen() */
-#define SQLITE_MUTEX_STATIC_PRNG      5	/* sqlite3_randomness() */
-#define SQLITE_MUTEX_STATIC_LRU       6	/* lru page list */
-#define SQLITE_MUTEX_STATIC_LRU2      7	/* NOT USED */
-#define SQLITE_MUTEX_STATIC_PMEM      7	/* sqlite3PageMalloc() */
-#define SQLITE_MUTEX_STATIC_APP1      8	/* For use by application */
-#define SQLITE_MUTEX_STATIC_APP2      9	/* For use by application */
-#define SQLITE_MUTEX_STATIC_APP3     10	/* For use by application */
-#define SQLITE_MUTEX_STATIC_VFS1     11	/* For use by built-in VFS */
-#define SQLITE_MUTEX_STATIC_VFS2     12	/* For use by extension VFS */
-#define SQLITE_MUTEX_STATIC_VFS3     13	/* For use by application VFS */
-
-/*
- * CAPI3REF: Retrieve the mutex for a database connection
- * METHOD: sqlite3
- *
- * ^This interface returns a pointer the [sqlite3_mutex] object that
- * serializes access to the [database connection] given in the argument
- * when the [threading mode] is Serialized.
- * ^If the [threading mode] is Single-thread or Multi-thread then this
- * routine returns a NULL pointer.
-*/
-SQLITE_API sqlite3_mutex *
-sqlite3_db_mutex(sqlite3 *);
-
-/*
- * CAPI3REF: Low-Level Control Of Database Files
- * METHOD: sqlite3
- *
- * ^The [sqlite3_file_control()] interface makes a direct call to the
- * xFileControl method for the [sqlite3_io_methods] object associated
- * with a particular database identified by the second argument. ^The
- * name of the database is "main" for the main database or "temp" for the
- * TEMP database, or the name that appears after the AS keyword for
- * databases that are added using the [ATTACH] SQL command.
- * ^A NULL pointer can be used in place of "main" to refer to the
- * main database file.
- * ^The third and fourth parameters to this routine
- * are passed directly through to the second and third parameters of
- * the xFileControl method.  ^The return value of the xFileControl
- * method becomes the return value of this routine.
- *
- * ^The SQLITE_FCNTL_FILE_POINTER value for the op parameter causes
- * a pointer to the underlying [sqlite3_file] object to be written into
- * the space pointed to by the 4th parameter.  ^The SQLITE_FCNTL_FILE_POINTER
- * case is a short-circuit path which does not actually invoke the
- * underlying sqlite3_io_methods.xFileControl method.
- *
- * ^If the second parameter (zDbName) does not match the name of any
- * open database file, then SQLITE_ERROR is returned.  ^This error
- * code is not remembered and will not be recalled by [sqlite3_errcode()]
- * or [sqlite3_errmsg()].  The underlying xFileControl method might
- * also return SQLITE_ERROR.  There is no way to distinguish between
- * an incorrect zDbName and an SQLITE_ERROR return from the underlying
- * xFileControl method.
- *
- * See also: [SQLITE_FCNTL_LOCKSTATE]
-*/
-SQLITE_API int
-sqlite3_file_control(sqlite3 *, int op, void *);
-
-/*
- * CAPI3REF: Testing Interface
- *
- * ^The sqlite3_test_control() interface is used to read out internal
- * state of SQLite and to inject faults into SQLite for testing
- * purposes.  ^The first parameter is an operation code that determines
- * the number, meaning, and operation of all subsequent parameters.
- *
- * This interface is not for use by applications.  It exists solely
- * for verifying the correct operation of the SQLite library.  Depending
- * on how the SQLite library is compiled, this interface might not exist.
- *
- * The details of the operation codes, their meanings, the parameters
- * they take, and what they do are all subject to change without notice.
- * Unlike most of the SQLite API, this function is not guaranteed to
- * operate consistently from one release to the next.
-*/
-SQLITE_API int
-sqlite3_test_control(int op, ...);
-
-/*
- * CAPI3REF: Testing Interface Operation Codes
- *
- * These constants are the valid operation code parameters used
- * as the first argument to [sqlite3_test_control()].
- *
- * These parameters and their meanings are subject to change
- * without notice.  These values are for testing purposes only.
- * Applications should not use any of these parameters or the
- * [sqlite3_test_control()] interface.
-*/
-#define SQLITE_TESTCTRL_FIRST                    5
-#define SQLITE_TESTCTRL_PRNG_SAVE                5
-#define SQLITE_TESTCTRL_PRNG_RESTORE             6
-#define SQLITE_TESTCTRL_PRNG_RESET               7
-#define SQLITE_TESTCTRL_BITVEC_TEST              8
-#define SQLITE_TESTCTRL_FAULT_INSTALL            9
-#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS     10
-#define SQLITE_TESTCTRL_PENDING_BYTE            11
-#define SQLITE_TESTCTRL_ASSERT                  12
-#define SQLITE_TESTCTRL_ALWAYS                  13
-#define SQLITE_TESTCTRL_RESERVE                 14
-#define SQLITE_TESTCTRL_OPTIMIZATIONS           15
-#define SQLITE_TESTCTRL_ISKEYWORD               16
-#define SQLITE_TESTCTRL_SCRATCHMALLOC           17
-#define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
-#define SQLITE_TESTCTRL_EXPLAIN_STMT            19	/* NOT USED */
-#define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD    19
-#define SQLITE_TESTCTRL_NEVER_CORRUPT           20
-#define SQLITE_TESTCTRL_VDBE_COVERAGE           21
-#define SQLITE_TESTCTRL_BYTEORDER               22
-#define SQLITE_TESTCTRL_ISINIT                  23
-#define SQLITE_TESTCTRL_SORTER_MMAP             24
-#define SQLITE_TESTCTRL_IMPOSTER                25
-#define SQLITE_TESTCTRL_LAST                    25
-
-/*
- * CAPI3REF: SQLite Runtime Status
- *
- * ^These interfaces are used to retrieve runtime status information
- * about the performance of SQLite, and optionally to reset various
- * highwater marks.  ^The first argument is an integer code for
- * the specific parameter to measure.  ^(Recognized integer codes
- * are of the form [status parameters | SQLITE_STATUS_...].)^
- * ^The current value of the parameter is returned into *pCurrent.
- * ^The highest recorded value is returned in *pHighwater.  ^If the
- * resetFlag is true, then the highest record value is reset after
- * *pHighwater is written.  ^(Some parameters do not record the highest
- * value.  For those parameters
- * nothing is written into *pHighwater and the resetFlag is ignored.)^
- * ^(Other parameters record only the highwater mark and not the current
- * value.  For these latter parameters nothing is written into *pCurrent.)^
- *
- * ^The sqlite3_status() and sqlite3_status64() routines return
- * SQLITE_OK on success and a non-zero [error code] on failure.
- *
- * If either the current value or the highwater mark is too large to
- * be represented by a 32-bit integer, then the values returned by
- * sqlite3_status() are undefined.
- *
- * See also: [sqlite3_db_status()]
-*/
-SQLITE_API int
-sqlite3_status(int op, int *pCurrent, int *pHighwater,
-	       int resetFlag);
-
-SQLITE_API int
-sqlite3_status64(int op, sqlite3_int64 * pCurrent,
-		 sqlite3_int64 * pHighwater,
-		 int resetFlag);
-
-/*
- * CAPI3REF: Status Parameters
- * KEYWORDS: {status parameters}
- *
- * These integer constants designate various run-time status parameters
- * that can be returned by [sqlite3_status()].
- *
- * <dl>
- * [[SQLITE_STATUS_MEMORY_USED]] ^(<dt>SQLITE_STATUS_MEMORY_USED</dt>
- * <dd>This parameter is the current amount of memory checked out
- * using [sqlite3_malloc()], either directly or indirectly.  The
- * figure includes calls made to [sqlite3_malloc()] by the application
- * and internal memory usage by the SQLite library.  Scratch memory
- * controlled by [SQLITE_CONFIG_SCRATCH] and auxiliary page-cache
- * memory controlled by [SQLITE_CONFIG_PAGECACHE] is not included in
- * this parameter.  The amount returned is the sum of the allocation
- * sizes as reported by the xSize method in [sqlite3_mem_methods].</dd>)^
- *
- * [[SQLITE_STATUS_MALLOC_SIZE]] ^(<dt>SQLITE_STATUS_MALLOC_SIZE</dt>
- * <dd>This parameter records the largest memory allocation request
- * handed to [sqlite3_malloc()] or [sqlite3_realloc()] (or their
- * internal equivalents).  Only the value returned in the
- * *pHighwater parameter to [sqlite3_status()] is of interest.
- * The value written into the *pCurrent parameter is undefined.</dd>)^
- *
- * [[SQLITE_STATUS_MALLOC_COUNT]] ^(<dt>SQLITE_STATUS_MALLOC_COUNT</dt>
- * <dd>This parameter records the number of separate memory allocations
- * currently checked out.</dd>)^
- *
- * [[SQLITE_STATUS_PAGECACHE_USED]] ^(<dt>SQLITE_STATUS_PAGECACHE_USED</dt>
- * <dd>This parameter returns the number of pages used out of the
- * [pagecache memory allocator] that was configured using
- * [SQLITE_CONFIG_PAGECACHE].  The
- * value returned is in pages, not in bytes.</dd>)^
- *
- * [[SQLITE_STATUS_PAGECACHE_OVERFLOW]]
- * ^(<dt>SQLITE_STATUS_PAGECACHE_OVERFLOW</dt>
- * <dd>This parameter returns the number of bytes of page cache
- * allocation which could not be satisfied by the [SQLITE_CONFIG_PAGECACHE]
- * buffer and where forced to overflow to [sqlite3_malloc()].  The
- * returned value includes allocations that overflowed because they
- * where too large (they were larger than the "sz" parameter to
- * [SQLITE_CONFIG_PAGECACHE]) and allocations that overflowed because
- * no space was left in the page cache.</dd>)^
- *
- * [[SQLITE_STATUS_PAGECACHE_SIZE]] ^(<dt>SQLITE_STATUS_PAGECACHE_SIZE</dt>
- * <dd>This parameter records the largest memory allocation request
- * handed to [pagecache memory allocator].  Only the value returned in the
- * *pHighwater parameter to [sqlite3_status()] is of interest.
- * The value written into the *pCurrent parameter is undefined.</dd>)^
- *
- * [[SQLITE_STATUS_SCRATCH_USED]] ^(<dt>SQLITE_STATUS_SCRATCH_USED</dt>
- * <dd>This parameter returns the number of allocations used out of the
- * [scratch memory allocator] configured using
- * [SQLITE_CONFIG_SCRATCH].  The value returned is in allocations, not
- * in bytes.  Since a single thread may only have one scratch allocation
- * outstanding at time, this parameter also reports the number of threads
- * using scratch memory at the same time.</dd>)^
- *
- * [[SQLITE_STATUS_SCRATCH_OVERFLOW]] ^(<dt>SQLITE_STATUS_SCRATCH_OVERFLOW</dt>
- * <dd>This parameter returns the number of bytes of scratch memory
- * allocation which could not be satisfied by the [SQLITE_CONFIG_SCRATCH]
- * buffer and where forced to overflow to [sqlite3_malloc()].  The values
- * returned include overflows because the requested allocation was too
- * larger (that is, because the requested allocation was larger than the
- * "sz" parameter to [SQLITE_CONFIG_SCRATCH]) and because no scratch buffer
- * slots were available.
- * </dd>)^
- *
- * [[SQLITE_STATUS_SCRATCH_SIZE]] ^(<dt>SQLITE_STATUS_SCRATCH_SIZE</dt>
- * <dd>This parameter records the largest memory allocation request
- * handed to [scratch memory allocator].  Only the value returned in the
- * *pHighwater parameter to [sqlite3_status()] is of interest.
- * The value written into the *pCurrent parameter is undefined.</dd>)^
- *
- * [[SQLITE_STATUS_PARSER_STACK]] ^(<dt>SQLITE_STATUS_PARSER_STACK</dt>
- * <dd>The *pHighwater parameter records the deepest parser stack.
- * The *pCurrent value is undefined.  The *pHighwater value is only
- * meaningful if SQLite is compiled with [YYTRACKMAXSTACKDEPTH].</dd>)^
- * </dl>
- *
- * New status parameters may be added from time to time.
-*/
-#define SQLITE_STATUS_MEMORY_USED          0
-#define SQLITE_STATUS_PAGECACHE_USED       1
-#define SQLITE_STATUS_PAGECACHE_OVERFLOW   2
-#define SQLITE_STATUS_SCRATCH_USED         3
-#define SQLITE_STATUS_SCRATCH_OVERFLOW     4
-#define SQLITE_STATUS_MALLOC_SIZE          5
-#define SQLITE_STATUS_PARSER_STACK         6
-#define SQLITE_STATUS_PAGECACHE_SIZE       7
-#define SQLITE_STATUS_SCRATCH_SIZE         8
-#define SQLITE_STATUS_MALLOC_COUNT         9
-
-/*
- * CAPI3REF: Database Connection Status
- * METHOD: sqlite3
- *
- * ^This interface is used to retrieve runtime status information
- * about a single [database connection].  ^The first argument is the
- * database connection object to be interrogated.  ^The second argument
- * is an integer constant, taken from the set of
- * [SQLITE_DBSTATUS options], that
- * determines the parameter to interrogate.  The set of
- * [SQLITE_DBSTATUS options] is likely
- * to grow in future releases of SQLite.
- *
- * ^The current value of the requested parameter is written into *pCur
- * and the highest instantaneous value is written into *pHiwtr.  ^If
- * the resetFlg is true, then the highest instantaneous value is
- * reset back down to the current value.
- *
- * ^The sqlite3_db_status() routine returns SQLITE_OK on success and a
- * non-zero [error code] on failure.
- *
- * See also: [sqlite3_status()] and [sqlite3_stmt_status()].
-*/
-SQLITE_API int
-sqlite3_db_status(sqlite3 *, int op, int *pCur,
-		  int *pHiwtr, int resetFlg);
-
-/*
- * CAPI3REF: Status Parameters for database connections
- * KEYWORDS: {SQLITE_DBSTATUS options}
- *
- * These constants are the available integer "verbs" that can be passed as
- * the second argument to the [sqlite3_db_status()] interface.
- *
- * New verbs may be added in future releases of SQLite. Existing verbs
- * might be discontinued. Applications should check the return code from
- * [sqlite3_db_status()] to make sure that the call worked.
- * The [sqlite3_db_status()] interface will return a non-zero error code
- * if a discontinued or unsupported verb is invoked.
- *
- * <dl>
- * [[SQLITE_DBSTATUS_LOOKASIDE_USED]] ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_USED</dt>
- * <dd>This parameter returns the number of lookaside memory slots currently
- * checked out.</dd>)^
- *
- * [[SQLITE_DBSTATUS_LOOKASIDE_HIT]] ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_HIT</dt>
- * <dd>This parameter returns the number malloc attempts that were
- * satisfied using lookaside memory. Only the high-water value is meaningful;
- * the current value is always zero.)^
- *
- * [[SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE]]
- * ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE</dt>
- * <dd>This parameter returns the number malloc attempts that might have
- * been satisfied using lookaside memory but failed due to the amount of
- * memory requested being larger than the lookaside slot size.
- * Only the high-water value is meaningful;
- * the current value is always zero.)^
- *
- * [[SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL]]
- * ^(<dt>SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL</dt>
- * <dd>This parameter returns the number malloc attempts that might have
- * been satisfied using lookaside memory but failed due to all lookaside
- * memory already being in use.
- * Only the high-water value is meaningful;
- * the current value is always zero.)^
- *
- * [[SQLITE_DBSTATUS_CACHE_USED]] ^(<dt>SQLITE_DBSTATUS_CACHE_USED</dt>
- * <dd>This parameter returns the approximate number of bytes of heap
- * memory used by all pager caches associated with the database connection.)^
- * ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_USED is always 0.
- *
- * [[SQLITE_DBSTATUS_CACHE_USED_SHARED]]
- * ^(<dt>SQLITE_DBSTATUS_CACHE_USED_SHARED</dt>
- * <dd>This parameter is similar to DBSTATUS_CACHE_USED, except that if a
- * pager cache is shared between two or more connections the bytes of heap
- * memory used by that pager cache is divided evenly between the attached
- * connections.)^  In other words, if none of the pager caches associated
- * with the database connection are shared, this request returns the same
- * value as DBSTATUS_CACHE_USED. Or, if one or more or the pager caches are
- * shared, the value returned by this call will be smaller than that returned
- * by DBSTATUS_CACHE_USED. ^The highwater mark associated with
- * SQLITE_DBSTATUS_CACHE_USED_SHARED is always 0.
- *
- * [[SQLITE_DBSTATUS_SCHEMA_USED]] ^(<dt>SQLITE_DBSTATUS_SCHEMA_USED</dt>
- * <dd>This parameter returns the approximate number of bytes of heap
- * memory used to store the schema for all databases associated
- * with the connection - main, temp, and any [ATTACH]-ed databases.)^
- * ^The full amount of memory used by the schemas is reported, even if the
- * schema memory is shared with other database connections due to
- * [shared cache mode] being enabled.
- * ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0.
- *
- * [[SQLITE_DBSTATUS_STMT_USED]] ^(<dt>SQLITE_DBSTATUS_STMT_USED</dt>
- * <dd>This parameter returns the approximate number of bytes of heap
- * and lookaside memory used by all prepared statements associated with
- * the database connection.)^
- * ^The highwater mark associated with SQLITE_DBSTATUS_STMT_USED is always 0.
- * </dd>
- *
- * [[SQLITE_DBSTATUS_CACHE_HIT]] ^(<dt>SQLITE_DBSTATUS_CACHE_HIT</dt>
- * <dd>This parameter returns the number of pager cache hits that have
- * occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_HIT
- * is always 0.
- * </dd>
- *
- * [[SQLITE_DBSTATUS_CACHE_MISS]] ^(<dt>SQLITE_DBSTATUS_CACHE_MISS</dt>
- * <dd>This parameter returns the number of pager cache misses that have
- * occurred.)^ ^The highwater mark associated with SQLITE_DBSTATUS_CACHE_MISS
- * is always 0.
- * </dd>
- *
- * [[SQLITE_DBSTATUS_CACHE_WRITE]] ^(<dt>SQLITE_DBSTATUS_CACHE_WRITE</dt>
- * <dd>This parameter returns the number of dirty cache entries that have
- * been written to disk. Specifically, the number of pages written to the
- * wal file in wal mode databases, or the number of pages written to the
- * database file in rollback mode databases. Any pages written as part of
- * transaction rollback or database recovery operations are not included.
- * If an IO or other error occurs while writing a page to disk, the effect
- * on subsequent SQLITE_DBSTATUS_CACHE_WRITE requests is undefined.)^ ^The
- * highwater mark associated with SQLITE_DBSTATUS_CACHE_WRITE is always 0.
- * </dd>
- *
- * [[SQLITE_DBSTATUS_DEFERRED_FKS]] ^(<dt>SQLITE_DBSTATUS_DEFERRED_FKS</dt>
- * <dd>This parameter returns zero for the current value if and only if
- * all foreign key constraints (deferred or immediate) have been
- * resolved.)^  ^The highwater mark is always 0.
- * </dd>
- * </dl>
-*/
-#define SQLITE_DBSTATUS_LOOKASIDE_USED       0
-#define SQLITE_DBSTATUS_CACHE_USED           1
-#define SQLITE_DBSTATUS_SCHEMA_USED          2
-#define SQLITE_DBSTATUS_STMT_USED            3
-#define SQLITE_DBSTATUS_LOOKASIDE_HIT        4
-#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE  5
-#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL  6
-#define SQLITE_DBSTATUS_CACHE_HIT            7
-#define SQLITE_DBSTATUS_CACHE_MISS           8
-#define SQLITE_DBSTATUS_CACHE_WRITE          9
-#define SQLITE_DBSTATUS_DEFERRED_FKS        10
-#define SQLITE_DBSTATUS_CACHE_USED_SHARED   11
-#define SQLITE_DBSTATUS_MAX                 11	/* Largest defined DBSTATUS */
-
-/*
- * CAPI3REF: Prepared Statement Status
- * METHOD: sqlite3_stmt
- *
- * ^(Each prepared statement maintains various
- * [SQLITE_STMTSTATUS counters] that measure the number
- * of times it has performed specific operations.)^  These counters can
- * be used to monitor the performance characteristics of the prepared
- * statements.  For example, if the number of table steps greatly exceeds
- * the number of table searches or result rows, that would tend to indicate
- * that the prepared statement is using a full table scan rather than
- * an index.
- *
- * ^(This interface is used to retrieve and reset counter values from
- * a [prepared statement].  The first argument is the prepared statement
- * object to be interrogated.  The second argument
- * is an integer code for a specific [SQLITE_STMTSTATUS counter]
- * to be interrogated.)^
- * ^The current value of the requested counter is returned.
- * ^If the resetFlg is true, then the counter is reset to zero after this
- * interface call returns.
- *
- * See also: [sqlite3_status()] and [sqlite3_db_status()].
-*/
-SQLITE_API int
-sqlite3_stmt_status(sqlite3_stmt *, int op,
-		    int resetFlg);
-
-/*
- * CAPI3REF: Status Parameters for prepared statements
- * KEYWORDS: {SQLITE_STMTSTATUS counter} {SQLITE_STMTSTATUS counters}
- *
- * These preprocessor macros define integer codes that name counter
- * values associated with the [sqlite3_stmt_status()] interface.
- * The meanings of the various counters are as follows:
- *
- * <dl>
- * [[SQLITE_STMTSTATUS_FULLSCAN_STEP]] <dt>SQLITE_STMTSTATUS_FULLSCAN_STEP</dt>
- * <dd>^This is the number of times that SQLite has stepped forward in
- * a table as part of a full table scan.  Large numbers for this counter
- * may indicate opportunities for performance improvement through
- * careful use of indices.</dd>
- *
- * [[SQLITE_STMTSTATUS_SORT]] <dt>SQLITE_STMTSTATUS_SORT</dt>
- * <dd>^This is the number of sort operations that have occurred.
- * A non-zero value in this counter may indicate an opportunity to
- * improvement performance through careful use of indices.</dd>
- *
- * [[SQLITE_STMTSTATUS_AUTOINDEX]] <dt>SQLITE_STMTSTATUS_AUTOINDEX</dt>
- * <dd>^This is the number of rows inserted into transient indices that
- * were created automatically in order to help joins run faster.
- * A non-zero value in this counter may indicate an opportunity to
- * improvement performance by adding permanent indices that do not
- * need to be reinitialized each time the statement is run.</dd>
- *
- * [[SQLITE_STMTSTATUS_VM_STEP]] <dt>SQLITE_STMTSTATUS_VM_STEP</dt>
- * <dd>^This is the number of virtual machine operations executed
- * by the prepared statement if that number is less than or equal
- * to 2147483647.  The number of virtual machine operations can be
- * used as a proxy for the total work done by the prepared statement.
- * If the number of virtual machine operations exceeds 2147483647
- * then the value returned by this statement status code is undefined.
- * </dd>
- * </dl>
-*/
-#define SQLITE_STMTSTATUS_FULLSCAN_STEP     1
-#define SQLITE_STMTSTATUS_SORT              2
-#define SQLITE_STMTSTATUS_AUTOINDEX         3
-#define SQLITE_STMTSTATUS_VM_STEP           4
-
-/*
- * CAPI3REF: Custom Page Cache Object
- *
- * The sqlite3_pcache type is opaque.  It is implemented by
- * the pluggable module.  The SQLite core has no knowledge of
- * its size or internal structure and never deals with the
- * sqlite3_pcache object except by holding and passing pointers
- * to the object.
- *
- * See [sqlite3_pcache_methods2] for additional information.
-*/
-typedef struct sqlite3_pcache sqlite3_pcache;
-
-/*
- * CAPI3REF: Custom Page Cache Object
- *
- * The sqlite3_pcache_page object represents a single page in the
- * page cache.  The page cache will allocate instances of this
- * object.  Various methods of the page cache use pointers to instances
- * of this object as parameters or as their return value.
- *
- * See [sqlite3_pcache_methods2] for additional information.
-*/
-typedef struct sqlite3_pcache_page sqlite3_pcache_page;
-struct sqlite3_pcache_page {
-	void *pBuf;	/* The content of the page */
-	void *pExtra;	/* Extra information associated with the page */
-};
-
-/*
- * CAPI3REF: Application Defined Page Cache.
- * KEYWORDS: {page cache}
- *
- * ^(The [sqlite3_config]([SQLITE_CONFIG_PCACHE2], ...) interface can
- * register an alternative page cache implementation by passing in an
- * instance of the sqlite3_pcache_methods2 structure.)^
- * In many applications, most of the heap memory allocated by
- * SQLite is used for the page cache.
- * By implementing a
- * custom page cache using this API, an application can better control
- * the amount of memory consumed by SQLite, the way in which
- * that memory is allocated and released, and the policies used to
- * determine exactly which parts of a database file are cached and for
- * how long.
- *
- * The alternative page cache mechanism is an
- * extreme measure that is only needed by the most demanding applications.
- * The built-in page cache is recommended for most uses.
- *
- * ^(The contents of the sqlite3_pcache_methods2 structure are copied to an
- * internal buffer by SQLite within the call to [sqlite3_config].  Hence
- * the application may discard the parameter after the call to
- * [sqlite3_config()] returns.)^
- *
- * [[the xInit() page cache method]]
- * ^(The xInit() method is called once for each effective
- * call to [sqlite3_initialize()])^
- * (usually only once during the lifetime of the process). ^(The xInit()
- * method is passed a copy of the sqlite3_pcache_methods2.pArg value.)^
- * The intent of the xInit() method is to set up global data structures
- * required by the custom page cache implementation.
- * ^(If the xInit() method is NULL, then the
- * built-in default page cache is used instead of the application defined
- * page cache.)^
- *
- * [[the xShutdown() page cache method]]
- * ^The xShutdown() method is called by [sqlite3_shutdown()].
- * It can be used to clean up
- * any outstanding resources before process shutdown, if required.
- * ^The xShutdown() method may be NULL.
- *
- * ^SQLite automatically serializes calls to the xInit method,
- * so the xInit method need not be threadsafe.  ^The
- * xShutdown method is only called from [sqlite3_shutdown()] so it does
- * not need to be threadsafe either.  All other methods must be threadsafe
- * in multithreaded applications.
- *
- * ^SQLite will never invoke xInit() more than once without an intervening
- * call to xShutdown().
- *
- * [[the xCreate() page cache methods]]
- * ^SQLite invokes the xCreate() method to construct a new cache instance.
- * SQLite will typically create one cache instance for each open database file,
- * though this is not guaranteed. ^The
- * first parameter, szPage, is the size in bytes of the pages that must
- * be allocated by the cache.  ^szPage will always a power of two.  ^The
- * second parameter szExtra is a number of bytes of extra storage
- * associated with each page cache entry.  ^The szExtra parameter will
- * a number less than 250.  SQLite will use the
- * extra szExtra bytes on each page to store metadata about the underlying
- * database page on disk.  The value passed into szExtra depends
- * on the SQLite version, the target platform, and how SQLite was compiled.
- * ^The third argument to xCreate(), bPurgeable, is true if the cache being
- * created will be used to cache database pages of a file stored on disk, or
- * false if it is used for an in-memory database. The cache implementation
- * does not have to do anything special based with the value of bPurgeable;
- * it is purely advisory.  ^On a cache where bPurgeable is false, SQLite will
- * never invoke xUnpin() except to deliberately delete a page.
- * ^In other words, calls to xUnpin() on a cache with bPurgeable set to
- * false will always have the "discard" flag set to true.
- * ^Hence, a cache created with bPurgeable false will
- * never contain any unpinned pages.
- *
- * [[the xCachesize() page cache method]]
- * ^(The xCachesize() method may be called at any time by SQLite to set the
- * suggested maximum cache-size (number of pages stored by) the cache
- * instance passed as the first argument. This is the value configured using
- * the SQLite "[PRAGMA cache_size]" command.)^  As with the bPurgeable
- * parameter, the implementation is not required to do anything with this
- * value; it is advisory only.
- *
- * [[the xPagecount() page cache methods]]
- * The xPagecount() method must return the number of pages currently
- * stored in the cache, both pinned and unpinned.
- *
- * [[the xFetch() page cache methods]]
- * The xFetch() method locates a page in the cache and returns a pointer to
- * an sqlite3_pcache_page object associated with that page, or a NULL pointer.
- * The pBuf element of the returned sqlite3_pcache_page object will be a
- * pointer to a buffer of szPage bytes used to store the content of a
- * single database page.  The pExtra element of sqlite3_pcache_page will be
- * a pointer to the szExtra bytes of extra storage that SQLite has requested
- * for each entry in the page cache.
- *
- * The page to be fetched is determined by the key. ^The minimum key value
- * is 1.  After it has been retrieved using xFetch, the page is considered
- * to be "pinned".
- *
- * If the requested page is already in the page cache, then the page cache
- * implementation must return a pointer to the page buffer with its content
- * intact.  If the requested page is not already in the cache, then the
- * cache implementation should use the value of the createFlag
- * parameter to help it determined what action to take:
- *
- * <table border=1 width=85% align=center>
- * <tr><th> createFlag <th> Behavior when page is not already in cache
- * <tr><td> 0 <td> Do not allocate a new page.  Return NULL.
- * <tr><td> 1 <td> Allocate a new page if it easy and convenient to do so.
- *                 Otherwise return NULL.
- * <tr><td> 2 <td> Make every effort to allocate a new page.  Only return
- *                 NULL if allocating a new page is effectively impossible.
- * </table>
- *
- * ^(SQLite will normally invoke xFetch() with a createFlag of 0 or 1.  SQLite
- * will only use a createFlag of 2 after a prior call with a createFlag of 1
- * failed.)^  In between the to xFetch() calls, SQLite may
- * attempt to unpin one or more cache pages by spilling the content of
- * pinned pages to disk and synching the operating system disk cache.
- *
- * [[the xUnpin() page cache method]]
- * ^xUnpin() is called by SQLite with a pointer to a currently pinned page
- * as its second argument.  If the third parameter, discard, is non-zero,
- * then the page must be evicted from the cache.
- * ^If the discard parameter is
- * zero, then the page may be discarded or retained at the discretion of
- * page cache implementation. ^The page cache implementation
- * may choose to evict unpinned pages at any time.
- *
- * The cache must not perform any reference counting. A single
- * call to xUnpin() unpins the page regardless of the number of prior calls
- * to xFetch().
- *
- * [[the xRekey() page cache methods]]
- * The xRekey() method is used to change the key value associated with the
- * page passed as the second argument. If the cache
- * previously contains an entry associated with newKey, it must be
- * discarded. ^Any prior cache entry associated with newKey is guaranteed not
- * to be pinned.
- *
- * When SQLite calls the xTruncate() method, the cache must discard all
- * existing cache entries with page numbers (keys) greater than or equal
- * to the value of the iLimit parameter passed to xTruncate(). If any
- * of these pages are pinned, they are implicitly unpinned, meaning that
- * they can be safely discarded.
- *
- * [[the xDestroy() page cache method]]
- * ^The xDestroy() method is used to delete a cache allocated by xCreate().
- * All resources associated with the specified cache should be freed. ^After
- * calling the xDestroy() method, SQLite considers the [sqlite3_pcache*]
- * handle invalid, and will not use it with any other sqlite3_pcache_methods2
- * functions.
- *
- * [[the xShrink() page cache method]]
- * ^SQLite invokes the xShrink() method when it wants the page cache to
- * free up as much of heap memory as possible.  The page cache implementation
- * is not obligated to free any memory, but well-behaved implementations should
- * do their best.
-*/
-typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2;
-struct sqlite3_pcache_methods2 {
-	int iVersion;
-	void *pArg;
-	int (*xInit) (void *);
-	void (*xShutdown) (void *);
-	sqlite3_pcache *(*xCreate) (int szPage, int szExtra,
-				    int bPurgeable);
-	void (*xCachesize) (sqlite3_pcache *, int nCachesize);
-	int (*xPagecount) (sqlite3_pcache *);
-	sqlite3_pcache_page *(*xFetch) (sqlite3_pcache *, unsigned key,
-					int createFlag);
-	void (*xUnpin) (sqlite3_pcache *, sqlite3_pcache_page *,
-			int discard);
-	void (*xRekey) (sqlite3_pcache *, sqlite3_pcache_page *,
-			unsigned oldKey, unsigned newKey);
-	void (*xTruncate) (sqlite3_pcache *, unsigned iLimit);
-	void (*xDestroy) (sqlite3_pcache *);
-	void (*xShrink) (sqlite3_pcache *);
-};
-
-/*
- * This is the obsolete pcache_methods object that has now been replaced
- * by sqlite3_pcache_methods2.  This object is not used by SQLite.  It is
- * retained in the header file for backwards compatibility only.
-*/
-typedef struct sqlite3_pcache_methods sqlite3_pcache_methods;
-struct sqlite3_pcache_methods {
-	void *pArg;
-	int (*xInit) (void *);
-	void (*xShutdown) (void *);
-	sqlite3_pcache *(*xCreate) (int szPage, int bPurgeable);
-	void (*xCachesize) (sqlite3_pcache *, int nCachesize);
-	int (*xPagecount) (sqlite3_pcache *);
-	void *(*xFetch) (sqlite3_pcache *, unsigned key,
-			 int createFlag);
-	void (*xUnpin) (sqlite3_pcache *, void *, int discard);
-	void (*xRekey) (sqlite3_pcache *, void *, unsigned oldKey,
-			unsigned newKey);
-	void (*xTruncate) (sqlite3_pcache *, unsigned iLimit);
-	void (*xDestroy) (sqlite3_pcache *);
-};
-
-/*
- * CAPI3REF: String Comparison
- *
- * ^The [sqlite3_stricmp()] and [sqlite3_strnicmp()] APIs allow applications
- * and extensions to compare the contents of two buffers containing UTF-8
- * strings in a case-independent fashion, using the same definition of "case
- * independence" that SQLite uses internally when comparing identifiers.
-*/
-SQLITE_API int
-sqlite3_stricmp(const char *, const char *);
-
-SQLITE_API int
-sqlite3_strnicmp(const char *, const char *, int);
-
-/*
- * CAPI3REF: String Globbing
-*
- * ^The [sqlite3_strglob(P,X)] interface returns zero if and only if
- * string X matches the [GLOB] pattern P.
- * ^The definition of [GLOB] pattern matching used in
- * [sqlite3_strglob(P,X)] is the same as for the "X GLOB P" operator in the
- * SQL dialect understood by SQLite.  ^The [sqlite3_strglob(P,X)] function
- * is case sensitive.
- *
- * Note that this routine returns zero on a match and non-zero if the strings
- * do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()].
- *
- * See also: [sqlite3_strlike()].
-*/
-SQLITE_API int
-sqlite3_strglob(const char *zGlob, const char *zStr);
-
-/*
- * CAPI3REF: String LIKE Matching
-*
- * ^The [sqlite3_strlike(P,X,E)] interface returns zero if and only if
- * string X matches the [LIKE] pattern P with escape character E.
- * ^The definition of [LIKE] pattern matching used in
- * [sqlite3_strlike(P,X,E)] is the same as for the "X LIKE P ESCAPE E"
- * operator in the SQL dialect understood by SQLite.  ^For "X LIKE P" without
- * the ESCAPE clause, set the E parameter of [sqlite3_strlike(P,X,E)] to 0.
- * ^As with the LIKE operator, the [sqlite3_strlike(P,X,E)] function is case
- * insensitive - equivalent upper and lower case ASCII characters match
- * one another.
- *
- * ^The [sqlite3_strlike(P,X,E)] function matches Unicode characters, though
- * only ASCII characters are case folded.
- *
- * Note that this routine returns zero on a match and non-zero if the strings
- * do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()].
- *
- * See also: [sqlite3_strglob()].
-*/
-SQLITE_API int
-sqlite3_strlike(const char *zGlob, const char *zStr,
-		unsigned int cEsc);
-
-/*
- * CAPI3REF: Error Logging Interface
- *
- * ^The [sqlite3_log()] interface writes a message into the [error log]
- * established by the [SQLITE_CONFIG_LOG] option to [sqlite3_config()].
- * ^If logging is enabled, the zFormat string and subsequent arguments are
- * used with [sqlite3_snprintf()] to generate the final output string.
- *
- * The sqlite3_log() interface is intended for use by extensions,
- * collating functions, and SQL functions.  While there is nothing
- * to prevent an application from calling sqlite3_log(), doing so
- * is considered bad form.
- *
- * The zFormat string must not be NULL.
- *
- * To avoid deadlocks and other threading problems, the sqlite3_log() routine
- * will not use dynamically allocated memory.  The log message is stored in
- * a fixed-length buffer on the stack.  If the log message is longer than
- * a few hundred characters, it will be truncated to the length of the
- * buffer.
-*/
-SQLITE_API void
-sqlite3_log(int iErrCode, const char *zFormat, ...);
-
-/*
- * CAPI3REF: Write-Ahead Log Commit Hook
- * METHOD: sqlite3
- *
- * ^The [sqlite3_wal_hook()] function is used to register a callback that
- * is invoked each time data is committed to a database in wal mode.
- *
- * ^(The callback is invoked by SQLite after the commit has taken place and
- * the associated write-lock on the database released)^, so the implementation
- * may read, write or [checkpoint] the database as required.
- *
- * ^The first parameter passed to the callback function when it is invoked
- * is a copy of the third parameter passed to sqlite3_wal_hook() when
- * registering the callback. ^The second is a copy of the database handle.
- * ^The third parameter is the name of the database that was written to -
- * either "main" or the name of an [ATTACH]-ed database. ^The fourth parameter
- * is the number of pages currently in the write-ahead log file,
- * including those that were just committed.
- *
- * The callback function should normally return [SQLITE_OK].  ^If an error
- * code is returned, that error will propagate back up through the
- * SQLite code base to cause the statement that provoked the callback
- * to report an error, though the commit will have still occurred. If the
- * callback returns [SQLITE_ROW] or [SQLITE_DONE], or if it returns a value
- * that does not correspond to any valid SQLite error code, the results
- * are undefined.
- *
- * A single database handle may have at most a single write-ahead log callback
- * registered at one time. ^Calling [sqlite3_wal_hook()] replaces any
- * previously registered write-ahead log callback. ^Note that the
- * [sqlite3_wal_autocheckpoint()] interface and the
- * [wal_autocheckpoint pragma] both invoke [sqlite3_wal_hook()] and will
- * overwrite any prior [sqlite3_wal_hook()] settings.
-*/
-SQLITE_API void *
-sqlite3_wal_hook(sqlite3 *,
-		 int (*)(void *, sqlite3 *,
-			 const char *, int), void *);
-
-/*
- * CAPI3REF: Checkpoint Mode Values
- * KEYWORDS: {checkpoint mode}
- *
- * These constants define all valid values for the "checkpoint mode" passed
- * as the third parameter to the [sqlite3_wal_checkpoint_v2()] interface.
- * See the [sqlite3_wal_checkpoint_v2()] documentation for details on the
- * meaning of each of these checkpoint modes.
-*/
-#define SQLITE_CHECKPOINT_PASSIVE  0	/* Do as much as possible w/o blocking */
-#define SQLITE_CHECKPOINT_FULL     1	/* Wait for writers, then checkpoint */
-#define SQLITE_CHECKPOINT_RESTART  2	/* Like FULL but wait for for readers */
-#define SQLITE_CHECKPOINT_TRUNCATE 3	/* Like RESTART but also truncate WAL */
-
-/*
- * CAPI3REF: Prepared Statement Scan Status Opcodes
- * KEYWORDS: {scanstatus options}
- *
- * The following constants can be used for the T parameter to the
- * [sqlite3_stmt_scanstatus(S,X,T,V)] interface.  Each constant designates a
- * different metric for sqlite3_stmt_scanstatus() to return.
- *
- * When the value returned to V is a string, space to hold that string is
- * managed by the prepared statement S and will be automatically freed when
- * S is finalized.
- *
- * <dl>
- * [[SQLITE_SCANSTAT_NLOOP]] <dt>SQLITE_SCANSTAT_NLOOP</dt>
- * <dd>^The [sqlite3_int64] variable pointed to by the T parameter will be
- * set to the total number of times that the X-th loop has run.</dd>
- *
- * [[SQLITE_SCANSTAT_NVISIT]] <dt>SQLITE_SCANSTAT_NVISIT</dt>
- * <dd>^The [sqlite3_int64] variable pointed to by the T parameter will be set
- * to the total number of rows examined by all iterations of the X-th loop.</dd>
- *
- * [[SQLITE_SCANSTAT_EST]] <dt>SQLITE_SCANSTAT_EST</dt>
- * <dd>^The "double" variable pointed to by the T parameter will be set to the
- * query planner's estimate for the average number of rows output from each
- * iteration of the X-th loop.  If the query planner's estimates was accurate,
- * then this value will approximate the quotient NVISIT/NLOOP and the
- * product of this value for all prior loops with the same SELECTID will
- * be the NLOOP value for the current loop.
- *
- * [[SQLITE_SCANSTAT_NAME]] <dt>SQLITE_SCANSTAT_NAME</dt>
- * <dd>^The "const char *" variable pointed to by the T parameter will be set
- * to a zero-terminated UTF-8 string containing the name of the index or table
- * used for the X-th loop.
- *
- * [[SQLITE_SCANSTAT_EXPLAIN]] <dt>SQLITE_SCANSTAT_EXPLAIN</dt>
- * <dd>^The "const char *" variable pointed to by the T parameter will be set
- * to a zero-terminated UTF-8 string containing the [EXPLAIN QUERY PLAN]
- * description for the X-th loop.
- *
- * [[SQLITE_SCANSTAT_SELECTID]] <dt>SQLITE_SCANSTAT_SELECT</dt>
- * <dd>^The "int" variable pointed to by the T parameter will be set to the
- * "select-id" for the X-th loop.  The select-id identifies which query or
- * subquery the loop is part of.  The main query has a select-id of zero.
- * The select-id is the same value as is output in the first column
- * of an [EXPLAIN QUERY PLAN] query.
- * </dl>
-*/
-#define SQLITE_SCANSTAT_NLOOP    0
-#define SQLITE_SCANSTAT_NVISIT   1
-#define SQLITE_SCANSTAT_EST      2
-#define SQLITE_SCANSTAT_NAME     3
-#define SQLITE_SCANSTAT_EXPLAIN  4
-#define SQLITE_SCANSTAT_SELECTID 5
-
-/*
- * CAPI3REF: Prepared Statement Scan Status
- * METHOD: sqlite3_stmt
- *
- * This interface returns information about the predicted and measured
- * performance for pStmt.  Advanced applications can use this
- * interface to compare the predicted and the measured performance and
- * issue warnings and/or rerun [ANALYZE] if discrepancies are found.
- *
- * Since this interface is expected to be rarely used, it is only
- * available if SQLite is compiled using the [SQLITE_ENABLE_STMT_SCANSTATUS]
- * compile-time option.
- *
- * The "iScanStatusOp" parameter determines which status information to return.
- * The "iScanStatusOp" must be one of the [scanstatus options] or the behavior
- * of this interface is undefined.
- * ^The requested measurement is written into a variable pointed to by
- * the "pOut" parameter.
- * Parameter "idx" identifies the specific loop to retrieve statistics for.
- * Loops are numbered starting from zero. ^If idx is out of range - less than
- * zero or greater than or equal to the total number of loops used to implement
- * the statement - a non-zero value is returned and the variable that pOut
- * points to is unchanged.
- *
- * ^Statistics might not be available for all loops in all statements. ^In cases
- * where there exist loops with no available statistics, this function behaves
- * as if the loop did not exist - it returns non-zero and leave the variable
- * that pOut points to unchanged.
- *
- * See also: [sqlite3_stmt_scanstatus_reset()]
-*/
-SQLITE_API int
-sqlite3_stmt_scanstatus(sqlite3_stmt * pStmt,	/* Prepared statement for which info desired */
-			int idx,	/* Index of loop to report on */
-			int iScanStatusOp,	/* Information desired.  SQLITE_SCANSTAT_* */
-			void *pOut	/* Result written here */
-	);
-
-/*
- * CAPI3REF: Zero Scan-Status Counters
- * METHOD: sqlite3_stmt
- *
- * ^Zero all [sqlite3_stmt_scanstatus()] related event counters.
- *
- * This API is only available if the library is built with pre-processor
- * symbol [SQLITE_ENABLE_STMT_SCANSTATUS] defined.
-*/
-SQLITE_API void
-sqlite3_stmt_scanstatus_reset(sqlite3_stmt *);
-
-/*
- * CAPI3REF: Flush caches to disk mid-transaction
- *
- * ^If a write-transaction is open on [database connection] D when the
- * [sqlite3_db_cacheflush(D)] interface invoked, any dirty
- * pages in the pager-cache that are not currently in use are written out
- * to disk. A dirty page may be in use if a database cursor created by an
- * active SQL statement is reading from it, or if it is page 1 of a database
- * file (page 1 is always "in use").  ^The [sqlite3_db_cacheflush(D)]
- * interface flushes caches for all schemas - "main", "temp", and
- * any [attached] databases.
- *
- * ^If this function needs to obtain extra database locks before dirty pages
- * can be flushed to disk, it does so. ^If those locks cannot be obtained
- * immediately and there is a busy-handler callback configured, it is invoked
- * in the usual manner. ^If the required lock still cannot be obtained, then
- * the database is skipped and an attempt made to flush any dirty pages
- * belonging to the next (if any) database. ^If any databases are skipped
- * because locks cannot be obtained, but no other error occurs, this
- * function returns SQLITE_BUSY.
- *
- * ^If any other error occurs while flushing dirty pages to disk (for
- * example an IO error or out-of-memory condition), then processing is
- * abandoned and an SQLite [error code] is returned to the caller immediately.
- *
- * ^Otherwise, if no error occurs, [sqlite3_db_cacheflush()] returns SQLITE_OK.
- *
- * ^This function does not set the database handle error code or message
- * returned by the [sqlite3_errcode()] and [sqlite3_errmsg()] functions.
-*/
-SQLITE_API int
-sqlite3_db_cacheflush(sqlite3 *);
-
-/*
- * CAPI3REF: Low-level system error code
- *
- * ^Attempt to return the underlying operating system error code or error
- * number that caused the most recent I/O error or failure to open a file.
- * The return value is OS-dependent.  For example, on unix systems, after
- * [sqlite3_open_v2()] returns [SQLITE_CANTOPEN], this interface could be
- * called to get back the underlying "errno" that caused the problem, such
- * as ENOSPC, EAUTH, EISDIR, and so forth.
-*/
-SQLITE_API int
-sqlite3_system_errno(sqlite3 *);
-
-/*
- * CAPI3REF: Database Snapshot
- * KEYWORDS: {snapshot} {sqlite3_snapshot}
- * EXPERIMENTAL
- *
- * An instance of the snapshot object records the state of a [WAL mode]
- * database for some specific point in history.
- *
- * In [WAL mode], multiple [database connections] that are open on the
- * same database file can each be reading a different historical version
- * of the database file.  When a [database connection] begins a read
- * transaction, that connection sees an unchanging copy of the database
- * as it existed for the point in time when the transaction first started.
- * Subsequent changes to the database from other connections are not seen
- * by the reader until a new read transaction is started.
- *
- * The sqlite3_snapshot object records state information about an historical
- * version of the database file so that it is possible to later open a new read
- * transaction that sees that historical version of the database rather than
- * the most recent version.
- *
- * The constructor for this object is [sqlite3_snapshot_get()].  The
- * [sqlite3_snapshot_open()] method causes a fresh read transaction to refer
- * to an historical snapshot (if possible).  The destructor for
- * sqlite3_snapshot objects is [sqlite3_snapshot_free()].
-*/
-typedef struct sqlite3_snapshot {
-	unsigned char hidden[48];
-} sqlite3_snapshot;
-
-/*
- * CAPI3REF: Record A Database Snapshot
- * EXPERIMENTAL
- *
- * ^The [sqlite3_snapshot_get(D,S,P)] interface attempts to make a
- * new [sqlite3_snapshot] object that records the current state of
- * schema S in database connection D.  ^On success, the
- * [sqlite3_snapshot_get(D,S,P)] interface writes a pointer to the newly
- * created [sqlite3_snapshot] object into *P and returns SQLITE_OK.
- * If there is not already a read-transaction open on schema S when
- * this function is called, one is opened automatically.
- *
- * The following must be true for this function to succeed. If any of
- * the following statements are false when sqlite3_snapshot_get() is
- * called, SQLITE_ERROR is returned. The final value of *P is undefined
- * in this case.
- *
- * <ul>
- *   <li> The database handle must be in [autocommit mode].
- *
- *   <li> Schema S of [database connection] D must be a [WAL mode] database.
- *
- *   <li> There must not be a write transaction open on schema S of database
- *        connection D.
- *
- *   <li> One or more transactions must have been written to the current wal
- *        file since it was created on disk (by any connection). This means
- *        that a snapshot cannot be taken on a wal mode database with no wal
- *        file immediately after it is first opened. At least one transaction
- *        must be written to it first.
- * </ul>
- *
- * This function may also return SQLITE_NOMEM.  If it is called with the
- * database handle in autocommit mode but fails for some other reason,
- * whether or not a read transaction is opened on schema S is undefined.
- *
- * The [sqlite3_snapshot] object returned from a successful call to
- * [sqlite3_snapshot_get()] must be freed using [sqlite3_snapshot_free()]
- * to avoid a memory leak.
- *
- * The [sqlite3_snapshot_get()] interface is only available when the
- * SQLITE_ENABLE_SNAPSHOT compile-time option is used.
-*/
-SQLITE_API SQLITE_EXPERIMENTAL int
-sqlite3_snapshot_get(sqlite3 * db,
-		     const char *zSchema,
-		     sqlite3_snapshot ** ppSnapshot);
-
-/*
- * CAPI3REF: Start a read transaction on an historical snapshot
- * EXPERIMENTAL
- *
- * ^The [sqlite3_snapshot_open(D,S,P)] interface starts a
- * read transaction for schema S of
- * [database connection] D such that the read transaction
- * refers to historical [snapshot] P, rather than the most
- * recent change to the database.
- * ^The [sqlite3_snapshot_open()] interface returns SQLITE_OK on success
- * or an appropriate [error code] if it fails.
- *
- * ^In order to succeed, a call to [sqlite3_snapshot_open(D,S,P)] must be
- * the first operation following the [BEGIN] that takes the schema S
- * out of [autocommit mode].
- * ^In other words, schema S must not currently be in
- * a transaction for [sqlite3_snapshot_open(D,S,P)] to work, but the
- * database connection D must be out of [autocommit mode].
- * ^A [snapshot] will fail to open if it has been overwritten by a
- * [checkpoint].
- * ^(A call to [sqlite3_snapshot_open(D,S,P)] will fail if the
- * database connection D does not know that the database file for
- * schema S is in [WAL mode].  A database connection might not know
- * that the database file is in [WAL mode] if there has been no prior
- * I/O on that database connection, or if the database entered [WAL mode]
- * after the most recent I/O on the database connection.)^
- * (Hint: Run "[PRAGMA application_id]" against a newly opened
- * database connection in order to make it ready to use snapshots.)
- *
- * The [sqlite3_snapshot_open()] interface is only available when the
- * SQLITE_ENABLE_SNAPSHOT compile-time option is used.
-*/
-SQLITE_API SQLITE_EXPERIMENTAL int
-sqlite3_snapshot_open(sqlite3 * db,
-		      const char *zSchema,
-		      sqlite3_snapshot *pSnapshot);
-
-/*
- * CAPI3REF: Destroy a snapshot
- * EXPERIMENTAL
- *
- * ^The [sqlite3_snapshot_free(P)] interface destroys [sqlite3_snapshot] P.
- * The application must eventually free every [sqlite3_snapshot] object
- * using this routine to avoid a memory leak.
- *
- * The [sqlite3_snapshot_free()] interface is only available when the
- * SQLITE_ENABLE_SNAPSHOT compile-time option is used.
-*/
-SQLITE_API SQLITE_EXPERIMENTAL void
-sqlite3_snapshot_free(sqlite3_snapshot *);
-
-/*
- * CAPI3REF: Compare the ages of two snapshot handles.
- * EXPERIMENTAL
- *
- * The sqlite3_snapshot_cmp(P1, P2) interface is used to compare the ages
- * of two valid snapshot handles.
- *
- * If the two snapshot handles are not associated with the same database
- * file, the result of the comparison is undefined.
- *
- * Additionally, the result of the comparison is only valid if both of the
- * snapshot handles were obtained by calling sqlite3_snapshot_get() since the
- * last time the wal file was deleted. The wal file is deleted when the
- * database is changed back to rollback mode or when the number of database
- * clients drops to zero. If either snapshot handle was obtained before the
- * wal file was last deleted, the value returned by this function
- * is undefined.
- *
- * Otherwise, this API returns a negative value if P1 refers to an older
- * snapshot than P2, zero if the two handles refer to the same database
- * snapshot, and a positive value if P1 is a newer snapshot than P2.
-*/
-SQLITE_API SQLITE_EXPERIMENTAL int
-sqlite3_snapshot_cmp(sqlite3_snapshot
-		     * p1,
-		     sqlite3_snapshot
-		     * p2);
-
-/*
- * CAPI3REF: Recover snapshots from a wal file
- * EXPERIMENTAL
- *
- * If all connections disconnect from a database file but do not perform
- * a checkpoint, the existing wal file is opened along with the database
- * file the next time the database is opened. At this point it is only
- * possible to successfully call sqlite3_snapshot_open() to open the most
- * recent snapshot of the database (the one at the head of the wal file),
- * even though the wal file may contain other valid snapshots for which
- * clients have sqlite3_snapshot handles.
- *
- * This function attempts to scan the wal file associated with database zDb
- * of database handle db and make all valid snapshots available to
- * sqlite3_snapshot_open(). It is an error if there is already a read
- * transaction open on the database, or if the database is not a wal mode
- * database.
- *
- * SQLITE_OK is returned if successful, or an SQLite error code otherwise.
-*/
-SQLITE_API SQLITE_EXPERIMENTAL int
-sqlite3_snapshot_recover(sqlite3 * db,
-			 const char * zDb);
-
-/*
- * Undo the hack that converts floating point types to integer for
- * builds on processors without floating point support.
-*/
-#ifdef SQLITE_OMIT_FLOATING_POINT
-#undef double
-#endif
-
-#ifdef __cplusplus
-//}				/* End of the 'extern "C"' block */
-#endif
-#endif				/* SQLITE3_H */
diff --git a/src/box/sql/sqliteInt.h b/src/box/sql/sqliteInt.h
index f2a74ce..54456a2 100644
--- a/src/box/sql/sqliteInt.h
+++ b/src/box/sql/sqliteInt.h
@@ -123,15 +123,6 @@
 
 #include "sqliteLimit.h"
 
-/* Disable nuisance warnings on Borland compilers */
-#if defined(__BORLANDC__)
-#pragma warn -rch		/* unreachable code */
-#pragma warn -ccc		/* Condition is always true or false */
-#pragma warn -aus		/* Assigned value is never used */
-#pragma warn -csu		/* Comparing signed and unsigned */
-#pragma warn -spa		/* Suspicious pointer arithmetic */
-#endif
-
 /*
  * Include standard header files as necessary
  */
@@ -197,17 +188,6 @@
 #define SQLITE_DEFAULT_MEMSTATUS 1
 #endif
 
-/*
- * Exactly one of the following macros must be defined in order to
- * specify which memory allocation subsystem to use.
- *
- *     SQLITE_SYSTEM_MALLOC          // Use normal system malloc()
- *     SQLITE_ZERO_MALLOC            // Use a stub allocator that always fails
- *     SQLITE_MEMDEBUG               // Debugging version of system malloc()
- *
- * If none of the above are defined, then set SQLITE_SYSTEM_MALLOC as
- * the default.
- */
 #if defined(SQLITE_SYSTEM_MALLOC) \
   + defined(SQLITE_ZERO_MALLOC) \
   + defined(SQLITE_MEMDEBUG)>1
@@ -432,18 +412,6 @@ struct sqlite3_vfs {
 #define SQLITE_LIMIT_TRIGGER_DEPTH             9
 #define SQLITE_LIMIT_WORKER_THREADS           10
 
-typedef struct sqlite3_mem_methods sqlite3_mem_methods;
-struct sqlite3_mem_methods {
-	void *(*xMalloc) (int);	/* Memory allocation function */
-	void (*xFree) (void *);	/* Free a prior allocation */
-	void *(*xRealloc) (void *, int);	/* Resize an allocation */
-	int (*xSize) (void *);	/* Return the size of an allocation */
-	int (*xRoundup) (int);	/* Round up request size to allocation size */
-	int (*xInit) (void *);	/* Initialize the memory allocator */
-	void (*xShutdown) (void *);	/* Deinitialize the memory allocator */
-	void *pAppData;	/* Argument to xInit() and xShutdown() */
-};
-
 typedef struct sqlite3_pcache sqlite3_pcache;
 
 typedef struct sqlite3_pcache_page sqlite3_pcache_page;
@@ -804,8 +772,6 @@ sqlite3_os_end(void);
 #define SQLITE_CONFIG_SINGLETHREAD  1	/* nil */
 #define SQLITE_CONFIG_MULTITHREAD   2	/* nil */
 #define SQLITE_CONFIG_SERIALIZED    3	/* nil */
-#define SQLITE_CONFIG_MALLOC        4	/* sqlite3_mem_methods* */
-#define SQLITE_CONFIG_GETMALLOC     5	/* sqlite3_mem_methods* */
 #define SQLITE_CONFIG_SCRATCH       6	/* void*, int sz, int N */
 #define SQLITE_CONFIG_PAGECACHE     7	/* void*, int sz, int N */
 #define SQLITE_CONFIG_HEAP          8	/* void*, int nByte, int min */
@@ -3326,7 +3292,6 @@ struct Sqlite3Config {
 	int szLookaside;	/* Default lookaside buffer size */
 	int nLookaside;		/* Default lookaside buffer count */
 	int nStmtSpill;		/* Stmt-journal spill-to-disk threshold */
-	sqlite3_mem_methods m;	/* Low-level memory allocation interface */
 	sqlite3_pcache_methods2 pcache2;	/* Low-level page-cache interface */
 	void *pHeap;		/* Heap storage space */
 	int nHeap;		/* Size of pHeap[] */
@@ -3534,7 +3499,7 @@ unsigned sqlite3Strlen30(const char *);
 enum field_type sqlite3ColumnType(Column *);
 #define sqlite3StrNICmp sqlite3_strnicmp
 
-int sqlite3MallocInit(void);
+void sqlite3MallocInit(void);
 void sqlite3MallocEnd(void);
 void *sqlite3Malloc(u64);
 void *sqlite3MallocZero(u64);
@@ -3577,17 +3542,6 @@ int sqlite3HeapNearlyFull(void);
 #define sqlite3StackFree(D,P)       sqlite3DbFree(D,P)
 #endif
 
-/* Do not allow both MEMSYS5 and MEMSYS3 to be defined together.  If they
- * are, disable MEMSYS3
- */
-#ifdef SQLITE_ENABLE_MEMSYS5
-const sqlite3_mem_methods *sqlite3MemGetMemsys5(void);
-#undef SQLITE_ENABLE_MEMSYS3
-#endif
-#ifdef SQLITE_ENABLE_MEMSYS3
-const sqlite3_mem_methods *sqlite3MemGetMemsys3(void);
-#endif
-
 sqlite3_int64 sqlite3StatusValue(int);
 void sqlite3StatusUp(int, int);
 void sqlite3StatusDown(int, int);
diff --git a/src/box/sql/status.c b/src/box/sql/status.c
index 963d3d8..8742bbf 100644
--- a/src/box/sql/status.c
+++ b/src/box/sql/status.c
@@ -246,8 +246,7 @@ sqlite3_db_status(sqlite3 * db,	/* The database connection whose status is desir
 				HashElem *p;
 
 				nByte +=
-				    sqlite3GlobalConfig.m.
-				    xRoundup(sizeof(HashElem)) *
+				    ROUND8(sizeof(HashElem)) *
 				    (pSchema->tblHash.count +
 				     pSchema->trigHash.count +
 				     pSchema->fkeyHash.count);
-- 
2.11.0

^ permalink raw reply	[flat|nested] 6+ messages in thread

* [tarantool-patches] [PATCH 4/4] sql: Remove dead defines from sqliteInt.h
  2018-03-26 15:56 [tarantool-patches] [PATCH 0/4] Cleanup SQL memory and threading subsystems Kirill Yukhin
                   ` (2 preceding siblings ...)
  2018-03-26 15:56 ` [tarantool-patches] [PATCH 3/4] sql: remove dead memory allocation systems Kirill Yukhin
@ 2018-03-26 15:56 ` Kirill Yukhin
  2018-03-27 11:31 ` [tarantool-patches] Re: [PATCH 0/4] Cleanup SQL memory and threading subsystems v.shpilevoy
  4 siblings, 0 replies; 6+ messages in thread
From: Kirill Yukhin @ 2018-03-26 15:56 UTC (permalink / raw)
  To: v.shpilevoy; +Cc: tarantool-patches, Kirill Yukhin

Massive removal of SQL legacy backend resulted in many unused macros.
The patch removes them, partially though. Also, some minor
coding style fixes done in sqliteInt.h.
---
 src/box/sql/global.c    |   1 -
 src/box/sql/main.c      |  64 ----------------------
 src/box/sql/os.c        |   2 +-
 src/box/sql/os_unix.c   |  37 ++-----------
 src/box/sql/sqliteInt.h | 137 +++++++++---------------------------------------
 5 files changed, 30 insertions(+), 211 deletions(-)

diff --git a/src/box/sql/global.c b/src/box/sql/global.c
index 2304cbb..cd6f9c4 100644
--- a/src/box/sql/global.c
+++ b/src/box/sql/global.c
@@ -202,7 +202,6 @@ SQLITE_WSD struct Sqlite3Config sqlite3Config = {
 	512,			/* szLookaside */
 	125,			/* nLookaside */
 	0,			/* nStmtSpill */
-	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},	/* pcache2 */
 	(void *)0,		/* pHeap */
 	0,			/* nHeap */
 	0, 0,			/* mnHeap, mxHeap */
diff --git a/src/box/sql/main.c b/src/box/sql/main.c
index 89c028d..1881e93 100644
--- a/src/box/sql/main.c
+++ b/src/box/sql/main.c
@@ -815,36 +815,15 @@ sqlite3ErrName(int rc)
 		case SQLITE_BUSY:
 			zName = "SQLITE_BUSY";
 			break;
-		case SQLITE_BUSY_RECOVERY:
-			zName = "SQLITE_BUSY_RECOVERY";
-			break;
-		case SQLITE_BUSY_SNAPSHOT:
-			zName = "SQLITE_BUSY_SNAPSHOT";
-			break;
 		case SQLITE_LOCKED:
 			zName = "SQLITE_LOCKED";
 			break;
-		case SQLITE_LOCKED_SHAREDCACHE:
-			zName = "SQLITE_LOCKED_SHAREDCACHE";
-			break;
 		case SQLITE_NOMEM:
 			zName = "SQLITE_NOMEM";
 			break;
 		case SQLITE_READONLY:
 			zName = "SQLITE_READONLY";
 			break;
-		case SQLITE_READONLY_RECOVERY:
-			zName = "SQLITE_READONLY_RECOVERY";
-			break;
-		case SQLITE_READONLY_CANTLOCK:
-			zName = "SQLITE_READONLY_CANTLOCK";
-			break;
-		case SQLITE_READONLY_ROLLBACK:
-			zName = "SQLITE_READONLY_ROLLBACK";
-			break;
-		case SQLITE_READONLY_DBMOVED:
-			zName = "SQLITE_READONLY_DBMOVED";
-			break;
 		case SQLITE_INTERRUPT:
 			zName = "SQLITE_INTERRUPT";
 			break;
@@ -938,18 +917,6 @@ sqlite3ErrName(int rc)
 		case SQLITE_CANTOPEN:
 			zName = "SQLITE_CANTOPEN";
 			break;
-		case SQLITE_CANTOPEN_NOTEMPDIR:
-			zName = "SQLITE_CANTOPEN_NOTEMPDIR";
-			break;
-		case SQLITE_CANTOPEN_ISDIR:
-			zName = "SQLITE_CANTOPEN_ISDIR";
-			break;
-		case SQLITE_CANTOPEN_FULLPATH:
-			zName = "SQLITE_CANTOPEN_FULLPATH";
-			break;
-		case SQLITE_CANTOPEN_CONVPATH:
-			zName = "SQLITE_CANTOPEN_CONVPATH";
-			break;
 		case SQLITE_PROTOCOL:
 			zName = "SQLITE_PROTOCOL";
 			break;
@@ -983,9 +950,6 @@ sqlite3ErrName(int rc)
 		case SQLITE_CONSTRAINT_NOTNULL:
 			zName = "SQLITE_CONSTRAINT_NOTNULL";
 			break;
-		case SQLITE_CONSTRAINT_COMMITHOOK:
-			zName = "SQLITE_CONSTRAINT_COMMITHOOK";
-			break;
 		case SQLITE_CONSTRAINT_FUNCTION:
 			zName = "SQLITE_CONSTRAINT_FUNCTION";
 			break;
@@ -1016,18 +980,9 @@ sqlite3ErrName(int rc)
 		case SQLITE_NOTICE:
 			zName = "SQLITE_NOTICE";
 			break;
-		case SQLITE_NOTICE_RECOVER_WAL:
-			zName = "SQLITE_NOTICE_RECOVER_WAL";
-			break;
-		case SQLITE_NOTICE_RECOVER_ROLLBACK:
-			zName = "SQLITE_NOTICE_RECOVER_ROLLBACK";
-			break;
 		case SQLITE_WARNING:
 			zName = "SQLITE_WARNING";
 			break;
-		case SQLITE_WARNING_AUTOINDEX:
-			zName = "SQLITE_WARNING_AUTOINDEX";
-			break;
 		case SQLITE_DONE:
 			zName = "SQLITE_DONE";
 			break;
@@ -1299,25 +1254,6 @@ sqlite3CreateFunc(sqlite3 * db,
 	return SQLITE_OK;
 }
 
-/*
- * Create new user functions.
- */
-int
-sqlite3_create_function(sqlite3 * db,
-			const char *zFunc,
-			int nArg,
-			int flags,
-			void *p,
-			void (*xSFunc) (sqlite3_context *, int,
-					sqlite3_value **),
-			void (*xStep) (sqlite3_context *, int,
-				       sqlite3_value **),
-			void (*xFinal) (sqlite3_context *))
-{
-	return sqlite3_create_function_v2(db, zFunc, nArg, flags, p, xSFunc,
-					  xStep, xFinal, 0);
-}
-
 int
 sqlite3_create_function_v2(sqlite3 * db,
 			   const char *zFunc,
diff --git a/src/box/sql/os.c b/src/box/sql/os.c
index ae98831..38d3585 100644
--- a/src/box/sql/os.c
+++ b/src/box/sql/os.c
@@ -287,7 +287,7 @@ sqlite3OsOpen(sqlite3_vfs * pVfs,
 	DO_OS_MALLOC_TEST(0);
 	/* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed
 	 * down into the VFS layer.  Some SQLITE_OPEN_ flags (for example,
-	 * SQLITE_OPEN_FULLMUTEX or SQLITE_OPEN_SHAREDCACHE) are blocked before
+	 * SQLITE_OPEN_SHAREDCACHE) are blocked before
 	 * reaching the VFS.
 	 */
 	rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x87f7f, pFlagsOut);
diff --git a/src/box/sql/os_unix.c b/src/box/sql/os_unix.c
index 4285d9f..8dce6f0 100644
--- a/src/box/sql/os_unix.c
+++ b/src/box/sql/os_unix.c
@@ -250,7 +250,6 @@ static pid_t randomnessPid = 0;
 #else
 #define UNIXFILE_DIRSYNC    0x00
 #endif
-#define UNIXFILE_PSOW        0x10	/* SQLITE_IOCAP_POWERSAFE_OVERWRITE */
 #define UNIXFILE_DELETE      0x20	/* Delete on close */
 #define UNIXFILE_URI         0x40	/* Filename might have query parameters */
 #define UNIXFILE_NOLOCK      0x80	/* Do no file locking */
@@ -3274,24 +3273,6 @@ fcntlSizeHint(unixFile * pFile, i64 nByte)
 	return SQLITE_OK;
 }
 
-/*
- * If *pArg is initially negative then this is a query.  Set *pArg to
- * 1 or 0 depending on whether or not bit mask of pFile->ctrlFlags is set.
- *
- * If *pArg is 0 or 1, then clear or set the mask bit of pFile->ctrlFlags.
- */
-static void
-unixModeBit(unixFile * pFile, unsigned char mask, int *pArg)
-{
-	if (*pArg < 0) {
-		*pArg = (pFile->ctrlFlags & mask) != 0;
-	} else if ((*pArg) == 0) {
-		pFile->ctrlFlags &= ~mask;
-	} else {
-		pFile->ctrlFlags |= mask;
-	}
-}
-
 /* Forward declaration */
 static int unixGetTempname(int nBuf, char *zBuf);
 
@@ -3322,10 +3303,6 @@ unixFileControl(sqlite3_file * id, int op, void *pArg)
 			SimulateIOErrorBenign(0);
 			return rc;
 		}
-	case SQLITE_FCNTL_POWERSAFE_OVERWRITE:{
-			unixModeBit(pFile, UNIXFILE_PSOW, (int *)pArg);
-			return SQLITE_OK;
-		}
 	case SQLITE_FCNTL_VFSNAME:{
 			*(char **)pArg =
 			    sqlite3_mprintf("%s", pFile->pVfs->zName);
@@ -3416,14 +3393,10 @@ unixSectorSize(sqlite3_file * NotUsed)
  * available to turn it off and URI query parameter available to turn it off.
  */
 static int
-unixDeviceCharacteristics(sqlite3_file * id)
+unixDeviceCharacteristics(sqlite3_file * pNotUsed)
 {
-	unixFile *p = (unixFile *) id;
-	int rc = 0;
-	if (p->ctrlFlags & UNIXFILE_PSOW) {
-		rc |= SQLITE_IOCAP_POWERSAFE_OVERWRITE;
-	}
-	return rc;
+	UNUSED_PARAMETER(pNotUsed);
+	return SQLITE_OK;
 }
 
 #if SQLITE_MAX_MMAP_SIZE>0
@@ -3965,10 +3938,6 @@ fillInUnixFile(sqlite3_vfs * pVfs,	/* Pointer to vfs object */
 #if SQLITE_MAX_MMAP_SIZE>0
 	pNew->mmapSizeMax = sqlite3GlobalConfig.szMmap;
 #endif
-	if (sqlite3_uri_boolean(((ctrlFlags & UNIXFILE_URI) ? zFilename : 0),
-				"psow", SQLITE_POWERSAFE_OVERWRITE)) {
-		pNew->ctrlFlags |= UNIXFILE_PSOW;
-	}
 	if (strcmp(pVfs->zName, "unix-excl") == 0) {
 		pNew->ctrlFlags |= UNIXFILE_EXCL;
 	}
diff --git a/src/box/sql/sqliteInt.h b/src/box/sql/sqliteInt.h
index 54456a2..6a6fb66 100644
--- a/src/box/sql/sqliteInt.h
+++ b/src/box/sql/sqliteInt.h
@@ -69,15 +69,6 @@
 #include "box/txn.h"
 
 /*
- * Make sure the Tcl calling convention macro is defined.  This macro is
- * only used by test code and Tcl integration code.
- */
-#ifndef SQLITE_TCLAPI
-#define SQLITE_TCLAPI
-#endif
-
-
-/*
  * These #defines should enable >2GB file support on POSIX if the
  * underlying operating system supports it.  If the OS lacks
  * large file support, these should be no-ops.
@@ -412,36 +403,6 @@ struct sqlite3_vfs {
 #define SQLITE_LIMIT_TRIGGER_DEPTH             9
 #define SQLITE_LIMIT_WORKER_THREADS           10
 
-typedef struct sqlite3_pcache sqlite3_pcache;
-
-typedef struct sqlite3_pcache_page sqlite3_pcache_page;
-struct sqlite3_pcache_page {
-	void *pBuf;	/* The content of the page */
-	void *pExtra;	/* Extra information associated with the page */
-};
-
-typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2;
-struct sqlite3_pcache_methods2 {
-	int iVersion;
-	void *pArg;
-	int (*xInit) (void *);
-	void (*xShutdown) (void *);
-	sqlite3_pcache *(*xCreate) (int szPage, int szExtra,
-				    int bPurgeable);
-	void (*xCachesize) (sqlite3_pcache *, int nCachesize);
-	int (*xPagecount) (sqlite3_pcache *);
-	sqlite3_pcache_page *(*xFetch) (sqlite3_pcache *, unsigned key,
-					int createFlag);
-	void (*xUnpin) (sqlite3_pcache *, sqlite3_pcache_page *,
-			int discard);
-	void (*xRekey) (sqlite3_pcache *, sqlite3_pcache_page *,
-			unsigned oldKey, unsigned newKey);
-	void (*xTruncate) (sqlite3_pcache *, unsigned iLimit);
-	void (*xDestroy) (sqlite3_pcache *);
-	void (*xShrink) (sqlite3_pcache *);
-};
-
-
 #define SQLITE_OK           0	/* Successful result */
 /* beginning-of-error-codes */
 #define SQLITE_ERROR        1	/* SQL error or missing database */
@@ -506,90 +467,90 @@ sqlite3_strnicmp(const char *, const char *, int);
  const void *
 sqlite3_value_blob(sqlite3_value *);
 
- int
+int
 sqlite3_value_bytes(sqlite3_value *);
 
- double
+double
 sqlite3_value_double(sqlite3_value *);
 
- int
+int
 sqlite3_value_int(sqlite3_value *);
 
- sqlite3_int64
+sqlite3_int64
 sqlite3_value_int64(sqlite3_value *);
 
- const unsigned char *
+const unsigned char *
 sqlite3_value_text(sqlite3_value *);
 
- int
+int
 sqlite3_value_type(sqlite3_value *);
 
- int
+int
 sqlite3_value_numeric_type(sqlite3_value *);
 
 sqlite3 *
 sqlite3_context_db_handle(sqlite3_context *);
 
 
- void
+void
 sqlite3_result_blob(sqlite3_context *, const void *,
 		    int, void (*)(void *));
 
- void
+void
 sqlite3_result_blob64(sqlite3_context *, const void *,
 		      sqlite3_uint64, void (*)(void *));
 
- void
+void
 sqlite3_result_double(sqlite3_context *, double);
 
- void
+void
 sqlite3_result_error(sqlite3_context *, const char *,
 		     int);
 
- void
+void
 sqlite3_result_error_toobig(sqlite3_context *);
 
- void
+void
 sqlite3_result_error_nomem(sqlite3_context *);
 
- void
+void
 sqlite3_result_error_code(sqlite3_context *, int);
 
- void
+void
 sqlite3_result_int(sqlite3_context *, int);
 
- void
+void
 sqlite3_result_int64(sqlite3_context *, sqlite3_int64);
 
- void
+void
 sqlite3_result_null(sqlite3_context *);
 
- void
+void
 sqlite3_result_text(sqlite3_context *, const char *,
 		    int, void (*)(void *));
 
- void
+void
 sqlite3_result_text64(sqlite3_context *, const char *,
 		      sqlite3_uint64, void (*)(void *));
 
- void
+void
 sqlite3_result_value(sqlite3_context *,
 		     sqlite3_value *);
 
- void
+void
 sqlite3_result_zeroblob(sqlite3_context *, int n);
 
- int
+int
 sqlite3_result_zeroblob64(sqlite3_context *,
 			  sqlite3_uint64 n);
 
- char *
+char *
 sqlite3_mprintf(const char *, ...);
- char *
+char *
 sqlite3_vmprintf(const char *, va_list);
- char *
+char *
 sqlite3_snprintf(int, char *, const char *, ...);
- char *
+char *
 sqlite3_vsnprintf(int, char *, const char *, va_list);
 
 int
@@ -688,30 +649,14 @@ sqlite3_exec(sqlite3 *,	/* An open database */
 #define SQLITE_IOERR_GETTEMPPATH       (SQLITE_IOERR | (25<<8))
 #define SQLITE_IOERR_CONVPATH          (SQLITE_IOERR | (26<<8))
 #define SQLITE_IOERR_VNODE             (SQLITE_IOERR | (27<<8))
-#define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))
-#define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))
-#define SQLITE_BUSY_SNAPSHOT           (SQLITE_BUSY   |  (2<<8))
-#define SQLITE_CANTOPEN_NOTEMPDIR      (SQLITE_CANTOPEN | (1<<8))
-#define SQLITE_CANTOPEN_ISDIR          (SQLITE_CANTOPEN | (2<<8))
-#define SQLITE_CANTOPEN_FULLPATH       (SQLITE_CANTOPEN | (3<<8))
-#define SQLITE_CANTOPEN_CONVPATH       (SQLITE_CANTOPEN | (4<<8))
-#define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))
-#define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))
-#define SQLITE_READONLY_ROLLBACK       (SQLITE_READONLY | (3<<8))
-#define SQLITE_READONLY_DBMOVED        (SQLITE_READONLY | (4<<8))
 #define SQLITE_ABORT_ROLLBACK          (SQLITE_ABORT | (2<<8))
 #define SQLITE_CONSTRAINT_CHECK        (SQLITE_CONSTRAINT | (1<<8))
-#define SQLITE_CONSTRAINT_COMMITHOOK   (SQLITE_CONSTRAINT | (2<<8))
 #define SQLITE_CONSTRAINT_FOREIGNKEY   (SQLITE_CONSTRAINT | (3<<8))
 #define SQLITE_CONSTRAINT_FUNCTION     (SQLITE_CONSTRAINT | (4<<8))
 #define SQLITE_CONSTRAINT_NOTNULL      (SQLITE_CONSTRAINT | (5<<8))
 #define SQLITE_CONSTRAINT_PRIMARYKEY   (SQLITE_CONSTRAINT | (6<<8))
 #define SQLITE_CONSTRAINT_TRIGGER      (SQLITE_CONSTRAINT | (7<<8))
 #define SQLITE_CONSTRAINT_UNIQUE       (SQLITE_CONSTRAINT | (8<<8))
-#define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))
-#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
-#define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))
-#define SQLITE_OK_LOAD_PERMANENTLY     (SQLITE_OK | (1<<8))
 
 enum sql_type {
 	SQLITE_INTEGER = 1,
@@ -769,16 +714,8 @@ sqlite3_initialize(void);
 int
 sqlite3_os_end(void);
 
-#define SQLITE_CONFIG_SINGLETHREAD  1	/* nil */
-#define SQLITE_CONFIG_MULTITHREAD   2	/* nil */
-#define SQLITE_CONFIG_SERIALIZED    3	/* nil */
 #define SQLITE_CONFIG_SCRATCH       6	/* void*, int sz, int N */
-#define SQLITE_CONFIG_PAGECACHE     7	/* void*, int sz, int N */
-#define SQLITE_CONFIG_HEAP          8	/* void*, int nByte, int min */
 #define SQLITE_CONFIG_MEMSTATUS     9	/* boolean */
-#define SQLITE_CONFIG_MUTEX        10	/* sqlite3_mutex_methods* */
-#define SQLITE_CONFIG_GETMUTEX     11	/* sqlite3_mutex_methods* */
-/* previously SQLITE_CONFIG_CHUNKALLOC 12 which is now unused. */
 #define SQLITE_CONFIG_LOOKASIDE    13	/* int int */
 #define SQLITE_CONFIG_LOG          16	/* xFunc, void* */
 #define SQLITE_CONFIG_URI          17	/* int */
@@ -788,12 +725,9 @@ sqlite3_os_end(void);
 #define SQLITE_CONFIG_PMASZ               24	/* unsigned int szPma */
 #define SQLITE_CONFIG_STMTJRNL_SPILL      25	/* int nByte */
 
-#define SQLITE_DBCONFIG_MAINDBNAME            1000	/* const char* */
 #define SQLITE_DBCONFIG_LOOKASIDE             1001	/* void* int int */
 #define SQLITE_DBCONFIG_ENABLE_FKEY           1002	/* int int* */
 #define SQLITE_DBCONFIG_ENABLE_TRIGGER        1003	/* int int* */
-#define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004	/* int int* */
-#define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005	/* int int* */
 #define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE      1006	/* int int* */
 
 #define SQLITE_TRACE_STMT       0x01
@@ -844,9 +778,6 @@ sqlite3_create_function_v2(sqlite3 * db,
 #define SQLITE_OPEN_MEMORY           0x00000080	/* Ok for sqlite3_open_v2() */
 #define SQLITE_OPEN_MAIN_DB          0x00000100	/* VFS only */
 #define SQLITE_OPEN_TEMP_DB          0x00000200	/* VFS only */
-#define SQLITE_OPEN_TRANSIENT_DB     0x00000400	/* VFS only */
-#define SQLITE_OPEN_NOMUTEX          0x00008000	/* Ok for sqlite3_open_v2() */
-#define SQLITE_OPEN_FULLMUTEX        0x00010000	/* Ok for sqlite3_open_v2() */
 #define SQLITE_OPEN_SHAREDCACHE      0x00020000	/* Ok for sqlite3_open_v2() */
 #define SQLITE_OPEN_PRIVATECACHE     0x00040000	/* Ok for sqlite3_open_v2() */
 
@@ -961,21 +892,6 @@ sqlite3_limit(sqlite3 *, int id, int newVal);
 #define SQLITE_SYNC_FULL          0x00003
 #define SQLITE_SYNC_DATAONLY      0x00010
 
-#define SQLITE_IOCAP_ATOMIC                 0x00000001
-#define SQLITE_IOCAP_ATOMIC512              0x00000002
-#define SQLITE_IOCAP_ATOMIC1K               0x00000004
-#define SQLITE_IOCAP_ATOMIC2K               0x00000008
-#define SQLITE_IOCAP_ATOMIC4K               0x00000010
-#define SQLITE_IOCAP_ATOMIC8K               0x00000020
-#define SQLITE_IOCAP_ATOMIC16K              0x00000040
-#define SQLITE_IOCAP_ATOMIC32K              0x00000080
-#define SQLITE_IOCAP_ATOMIC64K              0x00000100
-#define SQLITE_IOCAP_SAFE_APPEND            0x00000200
-#define SQLITE_IOCAP_SEQUENTIAL             0x00000400
-#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN  0x00000800
-#define SQLITE_IOCAP_POWERSAFE_OVERWRITE    0x00001000
-#define SQLITE_IOCAP_IMMUTABLE              0x00002000
-
 int
 sqlite3_uri_boolean(const char *zFile,
 		    const char *zParam, int bDefault);
@@ -3292,7 +3208,6 @@ struct Sqlite3Config {
 	int szLookaside;	/* Default lookaside buffer size */
 	int nLookaside;		/* Default lookaside buffer count */
 	int nStmtSpill;		/* Stmt-journal spill-to-disk threshold */
-	sqlite3_pcache_methods2 pcache2;	/* Low-level page-cache interface */
 	void *pHeap;		/* Heap storage space */
 	int nHeap;		/* Size of pHeap[] */
 	int mnReq, mxReq;	/* Min and max heap requests sizes */
-- 
2.11.0

^ permalink raw reply	[flat|nested] 6+ messages in thread

* [tarantool-patches] Re: [PATCH 0/4] Cleanup SQL memory and threading subsystems
  2018-03-26 15:56 [tarantool-patches] [PATCH 0/4] Cleanup SQL memory and threading subsystems Kirill Yukhin
                   ` (3 preceding siblings ...)
  2018-03-26 15:56 ` [tarantool-patches] [PATCH 4/4] sql: Remove dead defines from sqliteInt.h Kirill Yukhin
@ 2018-03-27 11:31 ` v.shpilevoy
  4 siblings, 0 replies; 6+ messages in thread
From: v.shpilevoy @ 2018-03-27 11:31 UTC (permalink / raw)
  To: tarantool-patches; +Cc: Kirill Yukhin

LGTM.

> 26 марта 2018 г., в 18:56, Kirill Yukhin <kyukhin@tarantool.org> написал(а):
> 
> This patcheset perform a cleanup of SQL frontend by removing
> dead memory allocators and their APIs and by getting rid of
> all mutex-related code.
> 
> Issue: https://github.com/tarantool/tarantool/issues/3192
> Branch: https://github.com/tarantool/tarantool/tree/kyukhin/gh-3192-remove-sqlite3
> 
> 
> Kirill Yukhin (4):
>  sql: Remove all references to sqlite3.h
>  sql: remove mutexes around the code
>  sql: remove dead memory allocation systems
>  sql: Remove dead defines from sqliteInt.h
> 
> src/box/execute.c          |    2 +-
> src/box/lua/sql.c          |    2 +-
> src/box/sql.c              |    2 -
> src/box/sql/CMakeLists.txt |    9 -
> src/box/sql/date.c         |    7 -
> src/box/sql/func.c         |    2 -
> src/box/sql/global.c       |    8 -
> src/box/sql/legacy.c       |    2 -
> src/box/sql/main.c         |  337 +--
> src/box/sql/malloc.c       |  195 +-
> src/box/sql/mem0.c         |  116 -
> src/box/sql/mem1.c         |  314 ---
> src/box/sql/mem2.c         |  602 ----
> src/box/sql/mem3.c         |  767 -----
> src/box/sql/mem5.c         |  648 -----
> src/box/sql/mutex.c        |  211 --
> src/box/sql/mutex.h        |   82 -
> src/box/sql/mutex_noop.c   |  300 --
> src/box/sql/mutex_unix.c   |  442 ---
> src/box/sql/os.c           |   23 +-
> src/box/sql/os_unix.c      |  180 +-
> src/box/sql/parse.c        |  143 +-
> src/box/sql/prepare.c      |    8 -
> src/box/sql/printf.c       |    6 -
> src/box/sql/random.c       |   11 -
> src/box/sql/sqlite3.h      | 6728 --------------------------------------------
> src/box/sql/sqliteInt.h    |  778 ++++-
> src/box/sql/status.c       |   12 +-
> src/box/sql/tokenize.c     |    2 -
> src/box/sql/vdbe.c         |    5 +-
> src/box/sql/vdbeapi.c      |   54 -
> src/box/sql/vdbeaux.c      |    2 -
> src/box/sql/vdbemem.c      |   17 -
> src/box/sql/vdbesort.c     |    6 +-
> 34 files changed, 887 insertions(+), 11136 deletions(-)
> delete mode 100644 src/box/sql/mem0.c
> delete mode 100644 src/box/sql/mem1.c
> delete mode 100644 src/box/sql/mem2.c
> delete mode 100644 src/box/sql/mem3.c
> delete mode 100644 src/box/sql/mem5.c
> delete mode 100644 src/box/sql/mutex.c
> delete mode 100644 src/box/sql/mutex.h
> delete mode 100644 src/box/sql/mutex_noop.c
> delete mode 100644 src/box/sql/mutex_unix.c
> delete mode 100644 src/box/sql/sqlite3.h
> 
> -- 
> 2.11.0
> 
> 

^ permalink raw reply	[flat|nested] 6+ messages in thread

end of thread, other threads:[~2018-03-27 11:32 UTC | newest]

Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2018-03-26 15:56 [tarantool-patches] [PATCH 0/4] Cleanup SQL memory and threading subsystems Kirill Yukhin
2018-03-26 15:56 ` [tarantool-patches] [PATCH 1/4] sql: Remove all references to sqlite3.h Kirill Yukhin
2018-03-26 15:56 ` [tarantool-patches] [PATCH 2/4] sql: remove mutexes around the code Kirill Yukhin
2018-03-26 15:56 ` [tarantool-patches] [PATCH 3/4] sql: remove dead memory allocation systems Kirill Yukhin
2018-03-26 15:56 ` [tarantool-patches] [PATCH 4/4] sql: Remove dead defines from sqliteInt.h Kirill Yukhin
2018-03-27 11:31 ` [tarantool-patches] Re: [PATCH 0/4] Cleanup SQL memory and threading subsystems v.shpilevoy

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox