#include <stdio.h>

#include <assert.h>

#include "sqlite3.h"

#include <ctype.h>

#include <stdarg.h>

#if defined(_WIN32) || defined(WIN32)

# include <io.h>

#define isatty(h) _isatty(h)

#ifndef access

# define access(f,m) _access((f),(m))

  return zResult;

}

};

/*

*/

  sqlite3 *db;           /* The database */

  int echoOn;            /* True to echo input commands */

  int autoEQP;           /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */

  int mode;              /* An output mode setting */

  int writableSchema;    /* True if PRAGMA writable_schema=ON */

  int showHeader;        /* True to show column names in List or Column mode */

  char *zDestTable;      /* Name of destination table when MODE_Insert */

  char separator[20];    /* Separator character for MODE_List */

  int colWidth[100];     /* Requested width of each column when in column mode*/

  int actualWidth[100];  /* Actual width of each column */

  char nullvalue[20];    /* The text to print when a NULL comes back from

                         ** the database */

  char outfile[FILENAME_MAX]; /* Filename for *out */

  const char *zDbFilename;    /* name of the database file */

  char *zFreeOnClose;         /* Filename to free when closing */

};

/*

** These are the allowed modes.

*/

#define MODE_Line     0  /* One column per line.  Blank line between records */

** A callback for the sqlite3_log() interface.

*/

static void shellLog(void *pArg, int iErrCode, const char *zMsg){

  if( p->pLog==0 ) return;

  fprintf(p->pLog, "(%d) %s\n", iErrCode, zMsg);

  fflush(p->pLog);

/*

** Output a single term of CSV.  Actually, p->separator is used for

** the separator, which may or may not be a comma.  p->nullvalue is

*/

  FILE *out = p->out;

  if( z==0 ){

    fprintf(out,"%s",p->nullvalue);

*/

static int shell_callback(void *pArg, int nArg, char **azArg, char **azCol, int *aiType){

  int i;

  switch( p->mode ){

    case MODE_Line: {

      break;

    }

    case MODE_Csv: {

      if( p->cnt++==0 && p->showHeader ){

        for(i=0; i<nArg; i++){

          output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);

        }

      }

      }

      break;

    }

    case MODE_Insert: {

}

/*

** the name of the table given.  Escape any quote characters in the

** table name.

*/

  int i, n;

  int needQuote;

  char *z;

** won't consume the semicolon terminator.

*/

static int run_table_dump_query(

  const char *zSelect,     /* SELECT statement to extract content */

  const char *zFirstRow    /* Print before first row, if not NULL */

){

*/

static int display_stats(

  sqlite3 *db,                /* Database to query */

  int bReset                  /* True to reset the stats */

){

  int iCur;

    iHiwtr = iCur = -1;

    sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);

    fprintf(pArg->out, "Number of Outstanding Allocations:   %d (max %d)\n", iCur, iHiwtr);

    iHiwtr = iCur = -1;

    sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);

    fprintf(pArg->out, "Number of Pcache Overflow Bytes:     %d (max %d) bytes\n", iCur, iHiwtr);

    iHiwtr = iCur = -1;

    sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);

    fprintf(pArg->out, "Number of Scratch Overflow Bytes:    %d (max %d) bytes\n", iCur, iHiwtr);

  }

  if( pArg && pArg->out && db ){

    iHiwtr = iCur = -1;

    sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);

    fprintf(pArg->out, "Pager Heap Usage:                    %d bytes\n", iCur);    iHiwtr = iCur = -1;

/*

** If compiled statement pSql appears to be an EXPLAIN statement, allocate

** spaces each opcode should be indented before it is output. 

**

** The indenting rules are:

**       then indent all opcodes between the earlier instruction

**       and "Goto" by 2 spaces.

*/

  const char *zSql;               /* The text of the SQL statement */

  const char *z;                  /* Used to check if this is an EXPLAIN */

  int *abYield = 0;               /* True if op is an OP_Yield */

/*

** Free the array allocated by explain_data_prepare().

*/

  sqlite3_free(p->aiIndent);

  p->aiIndent = 0;

  p->nIndent = 0;

** and callback data argument.

*/

static int shell_exec(

  int (*xCallback)(void*,int,char**,char**,int*),   /* Callback function */

){

  sqlite3_stmt *pStmt = NULL;     /* Statement to execute. */

  int rc = SQLITE_OK;             /* Return Code */

        sqlite3_free(zEQP);

      }

      /* If the shell is currently in ".explain" mode, gather the extra

      ** data required to add indents to the output.*/

      if( pArg && pArg->mode==MODE_Explain ){

  const char *zType;

  const char *zSql;

  const char *zPrepStmt = 0;

  UNUSED_PARAMETER(azCol);

  if( nArg!=3 ) return 1;

** "ORDER BY rowid DESC" to the end.

*/

static int run_schema_dump_query(

  const char *zQuery

){

  int rc;

  "                         If TABLE specified, only dump tables matching\n"

  "                         LIKE pattern TABLE.\n"

  ".echo on|off           Turn command echo on or off\n"

  ".exit                  Exit this program\n"

  ".explain ?on|off?      Turn output mode suitable for EXPLAIN on or off.\n"

  "                         With no args, it turns EXPLAIN on.\n"

  ".headers on|off        Turn display of headers on or off\n"

  ".help                  Show this message\n"

  ".import FILE TABLE     Import data from FILE into TABLE\n"

  ".schema ?TABLE?        Show the CREATE statements\n"

  "                         If TABLE specified, only show tables matching\n"

  "                         LIKE pattern TABLE.\n"

  ".shell CMD ARGS...     Run CMD ARGS... in a system shell\n"

  ".show                  Show the current values for various settings\n"

  ".stats on|off          Turn stats on or off\n"

;

/* Forward reference */

/*

** Make sure the database is open.  If it is not, then open it.  If

** the database fails to open, print an error message and exit.

*/

  if( p->db==0 ){

    sqlite3_initialize();

    sqlite3_open(p->zDbFilename, &p->db);

#ifndef SQLITE_OMIT_LOAD_EXTENSION

    sqlite3_enable_load_extension(p->db, 1);

#endif

  }

}

*/

static void sql_trace_callback(void *pArg, const char *z){

  FILE *f = (FILE*)pArg;

}

/*

** work for WITHOUT ROWID tables.

*/

static void tryToCloneData(

  sqlite3 *newDb,

  const char *zTable

){

** sqlite_master table, try again moving backwards.

*/

static void tryToCloneSchema(

  sqlite3 *newDb,

  const char *zWhere,

){

  sqlite3_stmt *pQuery = 0;

  char *zQuery = 0;

** as possible out of the main database (which might be corrupt) and write it

** into zNewDb.

*/

  int rc;

  sqlite3 *newDb = 0;

  if( access(zNewDb,0)==0 ){

/*

** Change the output file back to stdout

*/

  if( p->outfile[0]=='|' ){

    pclose(p->out);

  }else{

**

** Return 1 on error, 2 to exit, and 0 otherwise.

*/

  int i = 1;

  int nArg = 0;

  int n, c;

  }else

  if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){

    char *zErrMsg = 0;

    open_db(p, 0);

    memcpy(&data, p, sizeof(data));

  if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){

    int val = nArg>=2 ? booleanValue(azArg[1]) : 1;

    if(val == 1) {

      }

      /* We could put this code under the !p->explainValid

      ** condition so that it does not execute if we are already in

      p->colWidth[5] = 13;                 /* P4 */

      p->colWidth[6] = 2;                  /* P5 */

      p->colWidth[7] = 13;                  /* Comment */

    }

  }else

                          "filling the rest with NULL\n",

                          sCsv.zFile, startLine, nCol, i+1);

          i++;

        }

      }

      if( sCsv.cTerm==sCsv.cSeparator ){

  }else

  if( c=='i' && strncmp(azArg[0], "indices", n)==0 ){

    char *zErrMsg = 0;

    open_db(p, 0);

    memcpy(&data, p, sizeof(data));

    }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){

      p->mode = MODE_Csv;

      sqlite3_snprintf(sizeof(p->separator), p->separator, ",");

    }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){

      p->mode = MODE_List;

      sqlite3_snprintf(sizeof(p->separator), p->separator, "\t");

  }else

  if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){

    char *zErrMsg = 0;

    open_db(p, 0);

    memcpy(&data, p, sizeof(data));

         "  (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"

         "     FROM sqlite_master UNION ALL"

         "   SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "

         "ORDER BY rowid",

         callback, &data, &zErrMsg

      );

    }

  }else

#ifdef SQLITE_DEBUG

  /* Undocumented commands for internal testing.  Subject to change

  ** without notice. */

#endif

  if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){

      rc = 1;

    }

  }else

  if( c=='s'

   && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)

  ){

    char *zCmd;

    if( nArg<2 ){

      fprintf(stderr, "Usage: .system COMMAND\n");

      rc = 1;

      zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",

                             zCmd, azArg[i]);

    }

    sqlite3_free(zCmd);

  }else

  if( c=='s' && strncmp(azArg[0], "show", n)==0 ){

    }

    fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off");

    fprintf(p->out,"%9.9s: %s\n","eqp", p->autoEQP ? "on" : "off");

    fprintf(p->out,"%9.9s: %s\n","headers", p->showHeader ? "on" : "off");

    fprintf(p->out,"%9.9s: %s\n","mode", modeDescr[p->mode]);

    fprintf(p->out,"%9.9s: ", "nullvalue");

            strlen30(p->outfile) ? p->outfile : "stdout");

    fprintf(p->out,"%9.9s: ", "separator");

      output_c_string(p->out, p->separator);

      fprintf(p->out, "\n");

    fprintf(p->out,"%9.9s: %s\n","stats", p->statsOn ? "on" : "off");

    fprintf(p->out,"%9.9s: ","width");

#endif

  }else

  if( c=='v' && strncmp(azArg[0], "version", n)==0 ){

    fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/,

        sqlite3_libversion(), sqlite3_sourceid());

**

** Return the number of errors.

*/

  char *zLine = 0;          /* A single input line */

  char *zSql = 0;           /* Accumulated SQL text */

  int nLine;                /* Length of current line */

  if( nSql ){

    if( !_all_whitespace(zSql) ){

      fprintf(stderr, "Error: incomplete SQL: %s\n", zSql);

    }

    free(zSql);

  }

** Returns the number of errors.

*/

static int process_sqliterc(

  const char *sqliterc_override   /* Name of config file. NULL to use default */

){

  char *home_dir = NULL;

  "   -interactive         force interactive I/O\n"

  "   -line                set output mode to 'line'\n"

  "   -list                set output mode to 'list'\n"

  "   -mmap N              default mmap size set to N\n"

#ifdef SQLITE_ENABLE_MULTIPLEX

  "   -multiplex           enable the multiplexor VFS\n"

#endif

  "   -nullvalue TEXT      set text string for NULL values. Default ''\n"

  "   -separator SEP       set output field separator. Default: '|'\n"

  "   -stats               print memory stats before each finalize\n"

  "   -version             show SQLite version\n"

/*

** Initialize the state information in data

*/

  memset(data, 0, sizeof(*data));

  data->mode = MODE_List;

  memcpy(data->separator,"|", 2);

  data->showHeader = 0;

  sqlite3_config(SQLITE_CONFIG_URI, 1);

  sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);

  sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");

  sqlite3_snprintf(sizeof(continuePrompt), continuePrompt,"   ...> ");

}

/*

int sqlite3_shell(int argc, char **argv){

  char *zErrMsg = 0;

  const char *zInitFile = 0;

  char *zFirstCmd = 0;

  int i;

    if( z[1]=='-' ) z++;

    if( strcmp(z,"-separator")==0

     || strcmp(z,"-nullvalue")==0

     || strcmp(z,"-cmd")==0

    ){

      (void)cmdline_option_value(argc, argv, ++i);

      if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;

      sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);

#endif

#ifdef SQLITE_ENABLE_VFSTRACE

    }else if( strcmp(z,"-vfstrace")==0 ){

      extern int vfstrace_register(

    }else if( strcmp(z,"-separator")==0 ){

      sqlite3_snprintf(sizeof(data.separator), data.separator,

                       "%s",cmdline_option_value(argc,argv,++i));

    }else if( strcmp(z,"-nullvalue")==0 ){

      sqlite3_snprintf(sizeof(data.nullvalue), data.nullvalue,

                       "%s",cmdline_option_value(argc,argv,++i));

      stdin_is_interactive = 0;

    }else if( strcmp(z,"-heap")==0 ){

      i++;

    }else if( strcmp(z,"-mmap")==0 ){

      i++;

    }else if( strcmp(z,"-vfs")==0 ){

/******************************************************************************

** This file is an amalgamation of many separate C source files from SQLite

** single large file, the entire code can be compiled as a single translation

** unit.  This allows many compilers to do optimizations that would not be

** possible if the files were compiled separately.  Performance improvements

# define _LARGEFILE_SOURCE 1

#endif

/*

** For MinGW, check to see if we can include the header file containing its

** version information, among other things.  Normally, this internal MinGW

** [sqlite3_libversion_number()], [sqlite3_sourceid()],

** [sqlite_version()] and [sqlite_source_id()].

*/

/*

** CAPI3REF: Run-Time Library Version Numbers

**

** ^The sqlite3_close() and sqlite3_close_v2() routines are destructors

** for the [sqlite3] object.

** the [sqlite3] object is successfully destroyed and all associated

** resources are deallocated.

**

** statements or unfinished sqlite3_backup objects then sqlite3_close()

** will leave the database connection open and return [SQLITE_BUSY].

** ^If sqlite3_close_v2() is called with unfinalized prepared statements

** an unusable "zombie" which will automatically be deallocated when the

** last prepared statement is finalized or the last sqlite3_backup is

** finished.  The sqlite3_close_v2() interface is intended for use with

** 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], and/or

** of resources is deferred until all [prepared statements], [BLOB handles],

** and [sqlite3_backup] objects are also destroyed.

**

/*

** CAPI3REF: Result Codes

**

** 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.

**

*/

#define SQLITE_OK           0   /* Successful result */

/* beginning-of-error-codes */

/*

** CAPI3REF: Extended Result Codes

**

** 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 and later) include

** support for additional result codes that provide more detailed information

** on a per database connection basis using the

*/

#define SQLITE_IOERR_READ              (SQLITE_IOERR | (1<<8))

#define SQLITE_IOERR_SHORT_READ        (SQLITE_IOERR | (2<<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))

/*

** CAPI3REF: Flags For File Open Operations

** 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.

** 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

/*

** CAPI3REF: Standard File Control Opcodes

**

** These integer constants are opcodes for the xFileControl method

** of the [sqlite3_io_methods] object and for the [sqlite3_file_control()]

/*

** CAPI3REF: Register A Callback To Handle SQLITE_BUSY Errors

**

**

** 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

** busy callback returns 0, then no additional attempts are made to

** ^If the callback returns non-zero, then another attempt

**

** 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]

** 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

**

** ^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()]

**

** The busy callback should not take any actions which modify the

** result in undefined behavior.

** 

** A busy handler must not close the database connection

** 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

**

** ^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

** was defined  (using [sqlite3_busy_handler()]) prior to calling

** this routine, that other busy handler is cleared.)^

*/

SQLITE_API int sqlite3_busy_timeout(sqlite3*, int ms);

** sqlite3_malloc() is zero or negative then sqlite3_malloc() returns

** a NULL pointer.

**

** ^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

** might result if sqlite3_free() is called with a non-NULL pointer that

** was not obtained from sqlite3_malloc() or sqlite3_realloc().

**

** is a NULL pointer then its behavior is identical to calling

** negative then the behavior is exactly the same as calling

** ^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

** 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.

** [sqlite3_free()] or [sqlite3_realloc()].

*/

SQLITE_API void *sqlite3_malloc(int);

SQLITE_API void *sqlite3_realloc(void*, int);

SQLITE_API void sqlite3_free(void*);

/*

** CAPI3REF: Memory Allocator Statistics

** [sqlite3_set_authorizer | authorizer documentation] for additional

** information.

**

*/

#define SQLITE_DENY   1   /* Abort the SQL statement with an error */

#define SQLITE_IGNORE 2   /* Don't allow access, but don't generate an error */

** an English language description of the error following a failure of any

** of the sqlite3_open() routines.

**

**

** Whether or not an error occurs when it is opened, resources

** associated with the [database connection] handle should be released by

** 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].

**

** <ul>

**   <li> <b>vfs</b>: ^The "vfs" parameter may be used to specify the name of

**     a URI filename, its value overrides any behavior requested by setting

**     SQLITE_OPEN_PRIVATECACHE or SQLITE_OPEN_SHAREDCACHE flag.

**

**     [powersafe overwrite] property does or does not apply to the

**

**  <li> <b>nolock</b>: ^The nolock parameter is a boolean query parameter

**     which if set disables file locking in rollback journal modes.  This

**

** [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(<dt>SQLITE_LIMIT_TRIGGER_DEPTH</dt>

** <dd>The maximum depth of recursion for triggers.</dd>)^

** </dl>

*/

#define SQLITE_LIMIT_LENGTH                    0

#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH       8

#define SQLITE_LIMIT_VARIABLE_NUMBER           9

#define SQLITE_LIMIT_TRIGGER_DEPTH            10

/*

** CAPI3REF: Compiling An SQL Statement

** 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()

** 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.

**

** string after SQLite has finished with it.  ^The destructor is called

** ^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.

** SQLite makes its own private copy of the data immediately, before

** the sqlite3_bind_*() routine returns.

**

** ^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.

**

** ^The sqlite3_bind_* routines return [SQLITE_OK] on success or an

** [error code] if anything goes wrong.

** ^[SQLITE_RANGE] is returned if the parameter

** index is out of range.  ^[SQLITE_NOMEM] is returned if malloc() fails.

**

** [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_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_text16(sqlite3_stmt*, int, const void*, int, 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);

** object results in undefined behavior.

**

** ^These routines work just like the corresponding [column access functions]

** pointer instead of a [sqlite3_stmt*] pointer and an integer column number.

**

** ^The sqlite3_value_text16() interface extracts a UTF-16 string

** 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.

** ^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

** 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_double(sqlite3_context*, double);

SQLITE_API void sqlite3_result_error(sqlite3_context*, const char*, int);

SQLITE_API void sqlite3_result_error16(sqlite3_context*, const void*, 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_text16(sqlite3_context*, const void*, int, void(*)(void*));

SQLITE_API void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));

SQLITE_API void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));

** is a NULL pointer, then SQLite performs a search for an appropriate

** temporary file directory.

**

** 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

** 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.

**

** <b>Note to Windows Runtime users:</b>  The temporary directory must be set

** prior to calling [sqlite3_open] or [sqlite3_open_v2].  Otherwise, various

** <li>  SQLITE_MUTEX_RECURSIVE

** <li>  SQLITE_MUTEX_STATIC_MASTER

** <li>  SQLITE_MUTEX_STATIC_MEM

** <li>  SQLITE_MUTEX_STATIC_PRNG

** <li>  SQLITE_MUTEX_STATIC_LRU

** </ul>)^

**

** ^The first two constants (SQLITE_MUTEX_FAST and SQLITE_MUTEX_RECURSIVE)

#define SQLITE_MUTEX_STATIC_LRU       6  /* lru page list */

#define SQLITE_MUTEX_STATIC_LRU2      7  /* NOT USED */

#define SQLITE_MUTEX_STATIC_PMEM      7  /* sqlite3PageMalloc() */

/*

** CAPI3REF: Retrieve the mutex for a database connection

#define SQLITE_TESTCTRL_ISKEYWORD               16

#define SQLITE_TESTCTRL_SCRATCHMALLOC           17

#define SQLITE_TESTCTRL_LOCALTIME_FAULT         18

#define SQLITE_TESTCTRL_NEVER_CORRUPT           20

#define SQLITE_TESTCTRL_VDBE_COVERAGE           21

#define SQLITE_TESTCTRL_BYTEORDER               22

/*

** CAPI3REF: SQLite Runtime Status

** the current value is always zero.)^

**

** [[SQLITE_DBSTATUS_CACHE_USED]] ^(<dt>SQLITE_DBSTATUS_CACHE_USED</dt>

** 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_SCHEMA_USED]] ^(<dt>SQLITE_DBSTATUS_SCHEMA_USED</dt>

** 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

** ^The highwater mark associated with SQLITE_DBSTATUS_SCHEMA_USED is always 0.

**

** [[SQLITE_DBSTATUS_STMT_USED]] ^(<dt>SQLITE_DBSTATUS_STMT_USED</dt>

** 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.

** ^The [wal_autocheckpoint pragma] can be used to invoke this interface

** from SQL.

**

** ^Every new [database connection] defaults to having the auto-checkpoint

** enabled with a threshold of 1000 or [SQLITE_DEFAULT_WAL_AUTOCHECKPOINT]

** pages.  The use of this interface

** empty string, then a checkpoint is run on all databases of

** connection D.  ^If the database connection D is not in

** [WAL | write-ahead log mode] then this interface is a harmless no-op.

**

** ^The [wal_checkpoint pragma] can be used to invoke this interface

** from SQL.  ^The [sqlite3_wal_autocheckpoint()] interface and the

**   Checkpoint as many frames as possible without waiting for any database 

**   readers or writers to finish. Sync the db file if all frames in the log

**   are checkpointed. This mode is the same as calling 

**

** <dt>SQLITE_CHECKPOINT_FULL<dd>

**   database writer and all readers are reading from the most recent database

**   snapshot. It then checkpoints all frames in the log file and syncs the

**   database file. This call blocks database writers while it is running,

**

** <dt>SQLITE_CHECKPOINT_RESTART<dd>

**   This mode works the same way as SQLITE_CHECKPOINT_FULL, except after 

**   until all readers are reading from the database file only. This ensures 

**   that the next client to write to the database file restarts the log file 

**   from the beginning. This call blocks database writers while it is running,

/*

** CAPI3REF: Conflict resolution modes

**

** These constants are returned by [sqlite3_vtab_on_conflict()] to

** inform a [virtual table] implementation what the [ON CONFLICT] mode

#pragma warn -spa /* Suspicious pointer arithmetic */

#endif

/*

** Include standard header files as necessary

*/

#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

#endif

/*

** to fit in 32-bits.  This macro is used inside of various testcase()

** macros to verify that we have tested SQLite for large-file support.

*/

struct HashElem {

  HashElem *next, *prev;       /* Next and previous elements in the table */

  void *data;                  /* Data associated with this element */

};

/*

** Access routines.  To delete, insert a NULL pointer.

*/

SQLITE_PRIVATE void sqlite3HashInit(Hash*);

SQLITE_PRIVATE void sqlite3HashClear(Hash*);

/*

#endif

/*