vdbeapi.c

/*
** 2004 May 26
**
** The author disclaims copyright to this source code.  In place of
** a legal notice, here is a blessing:
**
**    May you do good and not evil.
**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
**
** This file contains code use to implement APIs that are part of the
** VDBE.
*/
#include "sqliteInt.h"
#include "vdbeInt.h"

#ifndef SQLITE_OMIT_DEPRECATED
/*
** Return TRUE (non-zero) of the statement supplied as an argument needs
** to be recompiled.  A statement needs to be recompiled whenever the
** execution environment changes in a way that would alter the program
** that sqlite3_prepare() generates.  For example, if new functions or
** collating sequences are registered or if an authorizer function is
** added or changed.
*/
int sqlite3_expired(sqlite3_stmt *pStmt) {
  Vdbe *p = (Vdbe *)pStmt;
  return p == 0 || p->expired;
}
#endif

/*
** Check on a Vdbe to make sure it has not been finalized.  Log
** an error and return true if it has been finalized (or is otherwise
** invalid).  Return false if it is ok.
*/
static int vdbeSafety(Vdbe *p) {
  if (p->db == 0) {
    sqlite3_log(SQLITE_MISUSE, "API called with finalized prepared statement");
    return 1;
  } else {
    return 0;
  }
}
static int vdbeSafetyNotNull(Vdbe *p) {
  if (p == 0) {
    sqlite3_log(SQLITE_MISUSE, "API called with NULL prepared statement");
    return 1;
  } else {
    return vdbeSafety(p);
  }
}

#ifndef SQLITE_OMIT_TRACE
/*
** Invoke the profile callback.  This routine is only called if we already
** know that the profile callback is defined and needs to be invoked.
*/
static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p) {
  sqlite3_int64 iNow;
  sqlite3_int64 iElapse;
  assert(p->startTime > 0);
  assert((db->mTrace & (SQLITE_TRACE_PROFILE | SQLITE_TRACE_XPROFILE)) != 0);
  assert(db->init.busy == 0);
  assert(p->zSql != 0);
  sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
  iElapse = (iNow - p->startTime) * 1000000;
#ifndef SQLITE_OMIT_DEPRECATED
  if (db->xProfile) {
    db->xProfile(db->pProfileArg, p->zSql, iElapse);
  }
#endif
  if (db->mTrace & SQLITE_TRACE_PROFILE) {
    db->trace.xV2(SQLITE_TRACE_PROFILE, db->pTraceArg, p, (void *)&iElapse);
  }
  p->startTime = 0;
}
/*
** The checkProfileCallback(DB,P) macro checks to see if a profile callback
** is needed, and it invokes the callback if it is needed.
*/
#define checkProfileCallback(DB, P)                                            \
  if (((P)->startTime) > 0) {                                                  \
    invokeProfileCallback(DB, P);                                              \
  }
#else
#define checkProfileCallback(DB, P) /*no-op*/
#endif

/*
** The following routine destroys a virtual machine that is created by
** the sqlite3_compile() routine. The integer returned is an SQLITE_
** success/failure code that describes the result of executing the virtual
** machine.
**
** This routine sets the error code and string returned by
** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
*/
int sqlite3_finalize(sqlite3_stmt *pStmt) {
  int rc;
  if (pStmt == 0) {
    /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL
    ** pointer is a harmless no-op. */
    rc = SQLITE_OK;
  } else {
    Vdbe *v = (Vdbe *)pStmt;
    sqlite3 *db = v->db;
    if (vdbeSafety(v))
      return SQLITE_MISUSE_BKPT;
    sqlite3_mutex_enter(db->mutex);
    checkProfileCallback(db, v);
    assert(v->eVdbeState >= VDBE_READY_STATE);
    rc = sqlite3VdbeReset(v);
    sqlite3VdbeDelete(v);
    rc = sqlite3ApiExit(db, rc);
    sqlite3LeaveMutexAndCloseZombie(db);
  }
  return rc;
}

/*
** Terminate the current execution of an SQL statement and reset it
** back to its starting state so that it can be reused. A success code from
** the prior execution is returned.
**
** This routine sets the error code and string returned by
** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
*/
int sqlite3_reset(sqlite3_stmt *pStmt) {
  int rc;
  if (pStmt == 0) {
    rc = SQLITE_OK;
  } 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;
}

/*
** Set all the parameters in the compiled SQL statement to NULL.
*/
int 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;
  }
  assert((p->prepFlags & SQLITE_PREPARE_SAVESQL) != 0 || p->expmask == 0);
  if (p->expmask) {
    p->expired = 1;
  }
  sqlite3_mutex_leave(mutex);
  return rc;
}

/**************************** sqlite3_value_  *******************************
** The following routines extract information from a Mem or sqlite3_value
** structure.
*/
const void *sqlite3_value_blob(sqlite3_value *pVal) {
  Mem *p = (Mem *)pVal;
  if (p->flags & (MEM_Blob | MEM_Str)) {
    if (ExpandBlob(p) != SQLITE_OK) {
      assert(p->flags == MEM_Null && p->z == 0);
      return 0;
    }
    p->flags |= MEM_Blob;
    return p->n ? p->z : 0;
  } else {
    return sqlite3_value_text(pVal);
  }
}
int sqlite3_value_bytes(sqlite3_value *pVal) {
  return sqlite3ValueBytes(pVal, SQLITE_UTF8);
}
int sqlite3_value_bytes16(sqlite3_value *pVal) {
  return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
}
double sqlite3_value_double(sqlite3_value *pVal) {
  return sqlite3VdbeRealValue((Mem *)pVal);
}
int sqlite3_value_int(sqlite3_value *pVal) {
  return (int)sqlite3VdbeIntValue((Mem *)pVal);
}
sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal) {
  return sqlite3VdbeIntValue((Mem *)pVal);
}
unsigned int sqlite3_value_subtype(sqlite3_value *pVal) {
  Mem *pMem = (Mem *)pVal;
  return ((pMem->flags & MEM_Subtype) ? pMem->eSubtype : 0);
}
void *sqlite3_value_pointer(sqlite3_value *pVal, const char *zPType) {
  Mem *p = (Mem *)pVal;
  if ((p->flags & (MEM_TypeMask | MEM_Term | MEM_Subtype)) ==
          (MEM_Null | MEM_Term | MEM_Subtype) &&
      zPType != 0 && p->eSubtype == 'p' && strcmp(p->u.zPType, zPType) == 0) {
    return (void *)p->z;
  } else {
    return 0;
  }
}
const unsigned char *sqlite3_value_text(sqlite3_value *pVal) {
  return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
}
#ifndef SQLITE_OMIT_UTF16
const void *sqlite3_value_text16(sqlite3_value *pVal) {
  return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
}
const void *sqlite3_value_text16be(sqlite3_value *pVal) {
  return sqlite3ValueText(pVal, SQLITE_UTF16BE);
}
const void *sqlite3_value_text16le(sqlite3_value *pVal) {
  return sqlite3ValueText(pVal, SQLITE_UTF16LE);
}
#endif /* SQLITE_OMIT_UTF16 */
/* EVIDENCE-OF: R-12793-43283 Every value in SQLite has one of five
** fundamental datatypes: 64-bit signed integer 64-bit IEEE floating
** point number string BLOB NULL
*/
int sqlite3_value_type(sqlite3_value *pVal) {
  static const u8 aType[] = {
      SQLITE_BLOB,    /* 0x00 (not possible) */
      SQLITE_NULL,    /* 0x01 NULL */
      SQLITE_TEXT,    /* 0x02 TEXT */
      SQLITE_NULL,    /* 0x03 (not possible) */
      SQLITE_INTEGER, /* 0x04 INTEGER */
      SQLITE_NULL,    /* 0x05 (not possible) */
      SQLITE_INTEGER, /* 0x06 INTEGER + TEXT */
      SQLITE_NULL,    /* 0x07 (not possible) */
      SQLITE_FLOAT,   /* 0x08 FLOAT */
      SQLITE_NULL,    /* 0x09 (not possible) */
      SQLITE_FLOAT,   /* 0x0a FLOAT + TEXT */
      SQLITE_NULL,    /* 0x0b (not possible) */
      SQLITE_INTEGER, /* 0x0c (not possible) */
      SQLITE_NULL,    /* 0x0d (not possible) */
      SQLITE_INTEGER, /* 0x0e (not possible) */
      SQLITE_NULL,    /* 0x0f (not possible) */
      SQLITE_BLOB,    /* 0x10 BLOB */
      SQLITE_NULL,    /* 0x11 (not possible) */
      SQLITE_TEXT,    /* 0x12 (not possible) */
      SQLITE_NULL,    /* 0x13 (not possible) */
      SQLITE_INTEGER, /* 0x14 INTEGER + BLOB */
      SQLITE_NULL,    /* 0x15 (not possible) */
      SQLITE_INTEGER, /* 0x16 (not possible) */
      SQLITE_NULL,    /* 0x17 (not possible) */
      SQLITE_FLOAT,   /* 0x18 FLOAT + BLOB */
      SQLITE_NULL,    /* 0x19 (not possible) */
      SQLITE_FLOAT,   /* 0x1a (not possible) */
      SQLITE_NULL,    /* 0x1b (not possible) */
      SQLITE_INTEGER, /* 0x1c (not possible) */
      SQLITE_NULL,    /* 0x1d (not possible) */
      SQLITE_INTEGER, /* 0x1e (not possible) */
      SQLITE_NULL,    /* 0x1f (not possible) */
      SQLITE_FLOAT,   /* 0x20 INTREAL */
      SQLITE_NULL,    /* 0x21 (not possible) */
      SQLITE_TEXT,    /* 0x22 INTREAL + TEXT */
      SQLITE_NULL,    /* 0x23 (not possible) */
      SQLITE_FLOAT,   /* 0x24 (not possible) */
      SQLITE_NULL,    /* 0x25 (not possible) */
      SQLITE_FLOAT,   /* 0x26 (not possible) */
      SQLITE_NULL,    /* 0x27 (not possible) */
      SQLITE_FLOAT,   /* 0x28 (not possible) */
      SQLITE_NULL,    /* 0x29 (not possible) */
      SQLITE_FLOAT,   /* 0x2a (not possible) */
      SQLITE_NULL,    /* 0x2b (not possible) */
      SQLITE_FLOAT,   /* 0x2c (not possible) */
      SQLITE_NULL,    /* 0x2d (not possible) */
      SQLITE_FLOAT,   /* 0x2e (not possible) */
      SQLITE_NULL,    /* 0x2f (not possible) */
      SQLITE_BLOB,    /* 0x30 (not possible) */
      SQLITE_NULL,    /* 0x31 (not possible) */
      SQLITE_TEXT,    /* 0x32 (not possible) */
      SQLITE_NULL,    /* 0x33 (not possible) */
      SQLITE_FLOAT,   /* 0x34 (not possible) */
      SQLITE_NULL,    /* 0x35 (not possible) */
      SQLITE_FLOAT,   /* 0x36 (not possible) */
      SQLITE_NULL,    /* 0x37 (not possible) */
      SQLITE_FLOAT,   /* 0x38 (not possible) */
      SQLITE_NULL,    /* 0x39 (not possible) */
      SQLITE_FLOAT,   /* 0x3a (not possible) */
      SQLITE_NULL,    /* 0x3b (not possible) */
      SQLITE_FLOAT,   /* 0x3c (not possible) */
      SQLITE_NULL,    /* 0x3d (not possible) */
      SQLITE_FLOAT,   /* 0x3e (not possible) */
      SQLITE_NULL,    /* 0x3f (not possible) */
  };
#ifdef SQLITE_DEBUG
  {
    int eType = SQLITE_BLOB;
    if (pVal->flags & MEM_Null) {
      eType = SQLITE_NULL;
    } else if (pVal->flags & (MEM_Real | MEM_IntReal)) {
      eType = SQLITE_FLOAT;
    } else if (pVal->flags & MEM_Int) {
      eType = SQLITE_INTEGER;
    } else if (pVal->flags & MEM_Str) {
      eType = SQLITE_TEXT;
    }
    assert(eType == aType[pVal->flags & MEM_AffMask]);
  }
#endif
  return aType[pVal->flags & MEM_AffMask];
}
int sqlite3_value_encoding(sqlite3_value *pVal) { return pVal->enc; }

/* Return true if a parameter to xUpdate represents an unchanged column */
int sqlite3_value_nochange(sqlite3_value *pVal) {
  return (pVal->flags & (MEM_Null | MEM_Zero)) == (MEM_Null | MEM_Zero);
}

/* Return true if a parameter value originated from an sqlite3_bind() */
int sqlite3_value_frombind(sqlite3_value *pVal) {
  return (pVal->flags & MEM_FromBind) != 0;
}

/* Make a copy of an sqlite3_value object
 */
sqlite3_value *sqlite3_value_dup(const sqlite3_value *pOrig) {
  sqlite3_value *pNew;
  if (pOrig == 0)
    return 0;
  pNew = sqlite3_malloc(sizeof(*pNew));
  if (pNew == 0)
    return 0;
  memset(pNew, 0, sizeof(*pNew));
  memcpy(pNew, pOrig, MEMCELLSIZE);
  pNew->flags &= ~MEM_Dyn;
  pNew->db = 0;
  if (pNew->flags & (MEM_Str | MEM_Blob)) {
    pNew->flags &= ~(MEM_Static | MEM_Dyn);
    pNew->flags |= MEM_Ephem;
    if (sqlite3VdbeMemMakeWriteable(pNew) != SQLITE_OK) {
      sqlite3ValueFree(pNew);
      pNew = 0;
    }
  } else if (pNew->flags & MEM_Null) {
    /* Do not duplicate pointer values */
    pNew->flags &= ~(MEM_Term | MEM_Subtype);
  }
  return pNew;
}

/* Destroy an sqlite3_value object previously obtained from
** sqlite3_value_dup().
*/
void sqlite3_value_free(sqlite3_value *pOld) { sqlite3ValueFree(pOld); }

/**************************** sqlite3_result_  *******************************
** The following routines are used by user-defined functions to specify
** the function result.
**
** The setStrOrError() function calls sqlite3VdbeMemSetStr() to store the
** result as a string or blob.  Appropriate errors are set if the string/blob
** is too big or if an OOM occurs.
**
** The invokeValueDestructor(P,X) routine invokes destructor function X()
** on value P is not going to be used and need to be destroyed.
*/
static void setResultStrOrError(sqlite3_context *pCtx, /* Function context */
                                const char *z,         /* String pointer */
                                int n,  /* Bytes in string, or negative */
                                u8 enc, /* Encoding of z.  0 for BLOBs */
                                void (*xDel)(void *) /* Destructor function */
) {
  Mem *pOut = pCtx->pOut;
  int rc = sqlite3VdbeMemSetStr(pOut, z, n, enc, xDel);
  if (rc) {
    if (rc == SQLITE_TOOBIG) {
      sqlite3_result_error_toobig(pCtx);
    } else {
      /* The only errors possible from sqlite3VdbeMemSetStr are
      ** SQLITE_TOOBIG and SQLITE_NOMEM */
      assert(rc == SQLITE_NOMEM);
      sqlite3_result_error_nomem(pCtx);
    }
    return;
  }
  sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
  if (sqlite3VdbeMemTooBig(pOut)) {
    sqlite3_result_error_toobig(pCtx);
  }
}
static int invokeValueDestructor(
    const void *p,        /* Value to destroy */
    void (*xDel)(void *), /* The destructor */
    sqlite3_context *pCtx /* Set a SQLITE_TOOBIG error if no NULL */
) {
  assert(xDel != SQLITE_DYNAMIC);
  if (xDel == 0) {
    /* noop */
  } else if (xDel == SQLITE_TRANSIENT) {
    /* noop */
  } else {
    xDel((void *)p);
  }
  sqlite3_result_error_toobig(pCtx);
  return SQLITE_TOOBIG;
}
void sqlite3_result_blob(sqlite3_context *pCtx, const void *z, int n,
                         void (*xDel)(void *)) {
  assert(n >= 0);
  assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
  setResultStrOrError(pCtx, z, n, 0, xDel);
}
void 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);
  } else {
    setResultStrOrError(pCtx, z, (int)n, 0, xDel);
  }
}
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;
  sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
}
#ifndef SQLITE_OMIT_UTF16
void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n) {
  assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
  pCtx->isError = SQLITE_ERROR;
  sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
}
#endif
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);
}
void sqlite3_result_pointer(sqlite3_context *pCtx, void *pPtr,
                            const char *zPType, void (*xDestructor)(void *)) {
  Mem *pOut = pCtx->pOut;
  assert(sqlite3_mutex_held(pOut->db->mutex));
  sqlite3VdbeMemRelease(pOut);
  pOut->flags = MEM_Null;
  sqlite3VdbeMemSetPointer(pOut, pPtr, zPType, xDestructor);
}
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;
}
void 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, SQLITE_UTF8, xDel);
}
void sqlite3_result_text64(sqlite3_context *pCtx, const char *z,
                           sqlite3_uint64 n, void (*xDel)(void *),
                           unsigned char enc) {
  assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
  assert(xDel != SQLITE_DYNAMIC);
  if (enc == SQLITE_UTF16)
    enc = SQLITE_UTF16NATIVE;
  if (n > 0x7fffffff) {
    (void)invokeValueDestructor(z, xDel, pCtx);
  } else {
    setResultStrOrError(pCtx, z, (int)n, enc, xDel);
  }
}
#ifndef SQLITE_OMIT_UTF16
void sqlite3_result_text16(sqlite3_context *pCtx, const void *z, int n,
                           void (*xDel)(void *)) {
  assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
  setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel);
}
void sqlite3_result_text16be(sqlite3_context *pCtx, const void *z, int n,
                             void (*xDel)(void *)) {
  assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
  setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel);
}
void sqlite3_result_text16le(sqlite3_context *pCtx, const void *z, int n,
                             void (*xDel)(void *)) {
  assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
  setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);
}
#endif /* SQLITE_OMIT_UTF16 */
void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue) {
  Mem *pOut = pCtx->pOut;
  assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
  sqlite3VdbeMemCopy(pOut, pValue);
  sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
  if (sqlite3VdbeMemTooBig(pOut)) {
    sqlite3_result_error_toobig(pCtx);
  }
}
void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n) {
  sqlite3_result_zeroblob64(pCtx, n > 0 ? n : 0);
}
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]) {
    sqlite3_result_error_toobig(pCtx);
    return SQLITE_TOOBIG;
  }
#ifndef SQLITE_OMIT_INCRBLOB
  sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
  return SQLITE_OK;
#else
  return sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
#endif
}
void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode) {
  pCtx->isError = errCode ? errCode : -1;
#ifdef SQLITE_DEBUG
  if (pCtx->pVdbe)
    pCtx->pVdbe->rcApp = errCode;
#endif
  if (pCtx->pOut->flags & MEM_Null) {
    setResultStrOrError(pCtx, sqlite3ErrStr(errCode), -1, SQLITE_UTF8,
                        SQLITE_STATIC);
  }
}

/* Force an SQLITE_TOOBIG error. */
void sqlite3_result_error_toobig(sqlite3_context *pCtx) {
  assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
  pCtx->isError = SQLITE_TOOBIG;
  sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1, SQLITE_UTF8,
                       SQLITE_STATIC);
}

/* An SQLITE_NOMEM error. */
void sqlite3_result_error_nomem(sqlite3_context *pCtx) {
  assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
  sqlite3VdbeMemSetNull(pCtx->pOut);
  pCtx->isError = SQLITE_NOMEM_BKPT;
  sqlite3OomFault(pCtx->pOut->db);
}

#ifndef SQLITE_UNTESTABLE
/* Force the INT64 value currently stored as the result to be
** a MEM_IntReal value.  See the SQLITE_TESTCTRL_RESULT_INTREAL
** test-control.
*/
void sqlite3ResultIntReal(sqlite3_context *pCtx) {
  assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
  if (pCtx->pOut->flags & MEM_Int) {
    pCtx->pOut->flags &= ~MEM_Int;
    pCtx->pOut->flags |= MEM_IntReal;
  }
}
#endif

/*
** This function is called after a transaction has been committed. It
** invokes callbacks registered with sqlite3_wal_hook() as required.
*/
static int doWalCallbacks(sqlite3 *db) {
  int rc = SQLITE_OK;
#ifndef SQLITE_OMIT_WAL
  int i;
  for (i = 0; i < db->nDb; i++) {
    Btree *pBt = db->aDb[i].pBt;
    if (pBt) {
      int nEntry;
      sqlite3BtreeEnter(pBt);
      nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt));
      sqlite3BtreeLeave(pBt);
      if (nEntry > 0 && db->xWalCallback && rc == SQLITE_OK) {
        rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zDbSName, nEntry);
      }
    }
  }
#endif
  return rc;
}

/*
** Execute the statement pStmt, either until a row of data is ready, the
** statement is completely executed or an error occurs.
**
** This routine implements the bulk of the logic behind the sqlite_step()
** API.  The only thing omitted is the automatic recompile if a
** schema change has occurred.  That detail is handled by the
** outer sqlite3_step() wrapper procedure.
*/
static int sqlite3Step(Vdbe *p) {
  sqlite3 *db;
  int rc;

  assert(p);
  db = p->db;
  if (p->eVdbeState != VDBE_RUN_STATE) {
  restart_step:
    if (p->eVdbeState == VDBE_READY_STATE) {
      if (p->expired) {
        p->rc = SQLITE_SCHEMA;
        rc = SQLITE_ERROR;
        if ((p->prepFlags & SQLITE_PREPARE_SAVESQL) != 0) {
          /* If this statement was prepared using saved SQL and an
          ** error has occurred, then return the error code in p->rc to the
          ** caller. Set the error code in the database handle to the same
          ** value.
          */
          rc = sqlite3VdbeTransferError(p);
        }
        goto end_of_step;
      }

      /* If there are no other statements currently running, then
      ** reset the interrupt flag.  This prevents a call to sqlite3_interrupt
      ** from interrupting a statement that has not yet started.
      */
      if (db->nVdbeActive == 0) {
        AtomicStore(&db->u1.isInterrupted, 0);
      }

      assert(db->nVdbeWrite > 0 || db->autoCommit == 0 ||
             (db->nDeferredCons == 0 && db->nDeferredImmCons == 0));

#ifndef SQLITE_OMIT_TRACE
      if ((db->mTrace & (SQLITE_TRACE_PROFILE | SQLITE_TRACE_XPROFILE)) != 0 &&
          !db->init.busy && p->zSql) {
        sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
      } else {
        assert(p->startTime == 0);
      }
#endif

      db->nVdbeActive++;
      if (p->readOnly == 0)
        db->nVdbeWrite++;
      if (p->bIsReader)
        db->nVdbeRead++;
      p->pc = 0;
      p->eVdbeState = VDBE_RUN_STATE;
    } else

        if (ALWAYS(p->eVdbeState == VDBE_HALT_STATE)) {
      /* We used to require that sqlite3_reset() be called before retrying
      ** sqlite3_step() after any error or after SQLITE_DONE.  But beginning
      ** with version 3.7.0, we changed this so that sqlite3_reset() would
      ** be called automatically instead of throwing the SQLITE_MISUSE error.
      ** This "automatic-reset" change is not technically an incompatibility,
      ** This "automatic-reset" change is not technically an incompatibility,
      ** This "automatic-reset" change is not technically an incompatibility,
      ** since any application that receives an SQLITE_MISUSE is broken by
      ** definition.
      **
      ** Nevertheless, some published applications that were originally written
      ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE
      ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE
      ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE
      ** returns, and those were broken by the automatic-reset change.  As a
      ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the
      ** legacy behavior of returning SQLITE_MISUSE for cases where the
      ** legacy behavior of returning SQLITE_MISUSE for cases where the
      ** legacy behavior of returning SQLITE_MISUSE for cases where the
      ** previous sqlite3_step() returned something other than a SQLITE_LOCKED
      ** or SQLITE_BUSY error.
      */
#ifdef SQLITE_OMIT_AUTORESET
      if ((rc = p->rc & 0xff) == SQLITE_BUSY || rc == SQLITE_LOCKED) {
        sqlite3_reset((sqlite3_stmt *)p);
      } else {
        return SQLITE_MISUSE_BKPT;
      }
#else
      sqlite3_reset((sqlite3_stmt *)p);
#endif
      assert(p->eVdbeState == VDBE_READY_STATE);
      goto restart_step;
    }
  }

#ifdef SQLITE_DEBUG
  p->rcApp = SQLITE_OK;
#endif
#ifndef SQLITE_OMIT_EXPLAIN
  if (p->explain) {
    rc = sqlite3VdbeList(p);
  } else
#endif /* SQLITE_OMIT_EXPLAIN */
  {
    db->nVdbeExec++;
    rc = sqlite3VdbeExec(p);
    db->nVdbeExec--;
  }

  if (rc == SQLITE_ROW) {
    assert(p->rc == SQLITE_OK);
    assert(db->mallocFailed == 0);
    db->errCode = SQLITE_ROW;
    return SQLITE_ROW;
  } else {
#ifndef SQLITE_OMIT_TRACE
    /* If the statement completed successfully, invoke the profile callback */
    checkProfileCallback(db, p);
#endif

    if (rc == SQLITE_DONE && db->autoCommit) {
      assert(p->rc == SQLITE_OK);
      p->rc = doWalCallbacks(db);
      if (p->rc != SQLITE_OK) {
        rc = SQLITE_ERROR;
      }
    } else if (rc != SQLITE_DONE &&
               (p->prepFlags & SQLITE_PREPARE_SAVESQL) != 0) {
      /* If this statement was prepared using saved SQL and an
      ** error has occurred, then return the error code in p->rc to the
      ** caller. Set the error code in the database handle to the same value.
      */
      rc = sqlite3VdbeTransferError(p);
    }
  }

  db->errCode = rc;
  if (SQLITE_NOMEM == sqlite3ApiExit(p->db, p->rc)) {
    p->rc = SQLITE_NOMEM_BKPT;
    if ((p->prepFlags & SQLITE_PREPARE_SAVESQL) != 0)
      rc = p->rc;
  }
end_of_step:
  /* There are only a limited number of result codes allowed from the
  ** statements prepared using the legacy sqlite3_prepare() interface */
  assert((p->prepFlags & SQLITE_PREPARE_SAVESQL) != 0 || rc == SQLITE_ROW ||
         rc == SQLITE_DONE || rc == SQLITE_ERROR ||
         (rc & 0xff) == SQLITE_BUSY || rc == SQLITE_MISUSE);
  return (rc & db->errMask);
}

/*
** This is the top-level implementation of sqlite3_step().  Call
** sqlite3Step() to do most of the work.  If a schema error occurs,
** call sqlite3Reprepare() and try again.
*/
int sqlite3_step(sqlite3_stmt *pStmt) {
  int rc = SQLITE_OK;      /* Result from sqlite3Step() */
  Vdbe *v = (Vdbe *)pStmt; /* the prepared statement */
  int cnt = 0;             /* Counter to prevent infinite loop of reprepares */
  sqlite3 *db;             /* The database connection */

  if (vdbeSafetyNotNull(v)) {
    return SQLITE_MISUSE_BKPT;
  }
  db = v->db;
  sqlite3_mutex_enter(db->mutex);
  while ((rc = sqlite3Step(v)) == SQLITE_SCHEMA &&
         cnt++ < SQLITE_MAX_SCHEMA_RETRY) {
    int savedPc = v->pc;
    rc = sqlite3Reprepare(v);
    if (rc != SQLITE_OK) {
      /* This case occurs after failing to recompile an sql statement.
      ** The error message from the SQL compiler has already been loaded
      ** into the database handle. This block copies the error message
      ** from the database handle into the statement and sets the statement
      ** program counter to 0 to ensure that when the statement is
      ** finalized or reset the parser error message is available via
      ** sqlite3_errmsg() and sqlite3_errcode().
      */
      const char *zErr = (const char *)sqlite3_value_text(db->pErr);
      sqlite3DbFree(db, v->zErrMsg);
      if (!db->mallocFailed) {
        v->zErrMsg = sqlite3DbStrDup(db, zErr);
        v->rc = rc = sqlite3ApiExit(db, rc);
      } else {
        v->zErrMsg = 0;
        v->rc = rc = SQLITE_NOMEM_BKPT;
      }
      break;
    }
    sqlite3_reset(pStmt);
    if (savedPc >= 0) {
      /* Setting minWriteFileFormat to 254 is a signal to the OP_Init and
      ** OP_Trace opcodes to *not* perform SQLITE_TRACE_STMT because it has
      ** already been done once on a prior invocation that failed due to
      ** SQLITE_SCHEMA.   tag-20220401a  */
      v->minWriteFileFormat = 254;
    }
    assert(v->expired == 0);
  }
  sqlite3_mutex_leave(db->mutex);
  return rc;
}

/*
** Extract the user data from a sqlite3_context structure and return a
** pointer to it.
*/
void *sqlite3_user_data(sqlite3_context *p) {
  assert(p && p->pFunc);
  return p->pFunc->pUserData;
}

/*
** Extract the user data from a sqlite3_context structure and return a
** pointer to it.
**
** IMPLEMENTATION-OF: R-46798-50301 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.
*/
sqlite3 *sqlite3_context_db_handle(sqlite3_context *p) {
  assert(p && p->pOut);
  return p->pOut->db;
}

/*
** If this routine is invoked from within an xColumn method of a virtual
** table, then it returns true if and only if the the call is during an
** UPDATE operation and the value of the column will not be modified
** by the UPDATE.
**
** If this routine is called from any context other than within the
** xColumn method of a virtual table, then the return value is meaningless
** and arbitrary.
**
** Virtual table implements might use this routine to optimize their
** performance by substituting a NULL result, or some other light-weight
** value, as a signal to the xUpdate routine that the column is unchanged.
*/
int sqlite3_vtab_nochange(sqlite3_context *p) {
  assert(p);
  return sqlite3_value_nochange(p->pOut);
}

/*
** Implementation of sqlite3_vtab_in_first() (if bNext==0) and
** sqlite3_vtab_in_next() (if bNext!=0).
*/
static int valueFromValueList(
    sqlite3_value *pVal,   /* Pointer to the ValueList object */
    sqlite3_value **ppOut, /* Store the next value from the list here */
    int bNext              /* 1 for _next(). 0 for _first() */
) {
  int rc;
  ValueList *pRhs;

  *ppOut = 0;
  if (pVal == 0)
    return SQLITE_MISUSE;
  pRhs = (ValueList *)sqlite3_value_pointer(pVal, "ValueList");
  if (pRhs == 0)
    return SQLITE_MISUSE;
  if (bNext) {
    rc = sqlite3BtreeNext(pRhs->pCsr, 0);
  } else {
    int dummy = 0;
    rc = sqlite3BtreeFirst(pRhs->pCsr, &dummy);
    assert(rc == SQLITE_OK || sqlite3BtreeEof(pRhs->pCsr));
    if (sqlite3BtreeEof(pRhs->pCsr))
      rc = SQLITE_DONE;
  }
  if (rc == SQLITE_OK) {
    u32 sz;   /* Size of current row in bytes */
    Mem sMem; /* Raw content of current row */
    memset(&sMem, 0, sizeof(sMem));
    sz = sqlite3BtreePayloadSize(pRhs->pCsr);
    rc = sqlite3VdbeMemFromBtreeZeroOffset(pRhs->pCsr, (int)sz, &sMem);
    if (rc == SQLITE_OK) {
      u8 *zBuf = (u8 *)sMem.z;
      u32 iSerial;
      sqlite3_value *pOut = pRhs->pOut;
      int iOff = 1 + getVarint32(&zBuf[1], iSerial);
      sqlite3VdbeSerialGet(&zBuf[iOff], iSerial, pOut);
      pOut->enc = ENC(pOut->db);
      if ((pOut->flags & MEM_Ephem) != 0 && sqlite3VdbeMemMakeWriteable(pOut)) {
        rc = SQLITE_NOMEM;
      } else {
        *ppOut = pOut;
      }
    }
    sqlite3VdbeMemRelease(&sMem);
  }
  return rc;
}

/*
** Set the iterator value pVal to point to the first value in the set.
** Set (*ppOut) to point to this value before returning.
*/
int sqlite3_vtab_in_first(sqlite3_value *pVal, sqlite3_value **ppOut) {
  return valueFromValueList(pVal, ppOut, 0);
}

/*
** Set the iterator value pVal to point to the next value in the set.
** Set (*ppOut) to point to this value before returning.
*/
int sqlite3_vtab_in_next(sqlite3_value *pVal, sqlite3_value **ppOut) {
  return valueFromValueList(pVal, ppOut, 1);
}

/*
** Return the current time for a statement.  If the current time
** is requested more than once within the same run of a single prepared
** statement, the exact same time is returned for each invocation regardless
** of the amount of time that elapses between invocations.  In other words,
** the time returned is always the time of the first call.
*/
sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context *p) {
  int rc;
#ifndef SQLITE_ENABLE_STAT4
  sqlite3_int64 *piTime = &p->pVdbe->iCurrentTime;
  assert(p->pVdbe != 0);
#else
  sqlite3_int64 iTime = 0;
  sqlite3_int64 *piTime = p->pVdbe != 0 ? &p->pVdbe->iCurrentTime : &iTime;
#endif
  if (*piTime == 0) {
    rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime);
    if (rc)
      *piTime = 0;
  }
  return *piTime;
}

/*
** Create a new aggregate context for p and return a pointer to
** its pMem->z element.
*/
static SQLITE_NOINLINE void *createAggContext(sqlite3_context *p, int nByte) {
  Mem *pMem = p->pMem;
  assert((pMem->flags & MEM_Agg) == 0);
  if (nByte <= 0) {
    sqlite3VdbeMemSetNull(pMem);
    pMem->z = 0;
  } else {
    sqlite3VdbeMemClearAndResize(pMem, nByte);
    pMem->flags = MEM_Agg;
    pMem->u.pDef = p->pFunc;
    if (pMem->z) {
      memset(pMem->z, 0, nByte);
    }
  }
  return (void *)pMem->z;
}

/*
** Allocate or return the aggregate context for a user function.  A new
** context is allocated on the first call.  Subsequent calls return the
** same context that was returned on prior calls.
*/
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);
  } else {
    return (void *)p->pMem->z;
  }
}

/*
** Return the auxiliary data pointer, if any, for the iArg'th argument to
** the user-function defined by pCtx.
**
** The left-most argument is 0.
**
** Undocumented behavior:  If iArg is negative then access a cache of
** auxiliary data pointers that is available to all functions within a
** single prepared statement.  The iArg values must match.
*/
void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg) {
  AuxData *pAuxData;

  assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
#if SQLITE_ENABLE_STAT4
  if (pCtx->pVdbe == 0)
    return 0;
#else
  assert(pCtx->pVdbe != 0);
#endif
  for (pAuxData = pCtx->pVdbe->pAuxData; pAuxData;
       pAuxData = pAuxData->pNextAux) {
    if (pAuxData->iAuxArg == iArg &&
        (pAuxData->iAuxOp == pCtx->iOp || iArg < 0)) {
      return pAuxData->pAux;
    }
  }
  return 0;
}

/*
** Set the auxiliary data pointer and delete function, for the iArg'th
** argument to the user-function defined by pCtx. Any previous value is
** deleted by calling the delete function specified when it was set.
**
** The left-most argument is 0.
**
** Undocumented behavior:  If iArg is negative then make the data available
** to all functions within the current prepared statement using iArg as an
** access code.
*/
void sqlite3_set_auxdata(sqlite3_context *pCtx, int iArg, void *pAux,
                         void (*xDelete)(void *)) {
  AuxData *pAuxData;
  Vdbe *pVdbe = pCtx->pVdbe;

  assert(sqlite3_mutex_held(pCtx->pOut->db->mutex));
#ifdef SQLITE_ENABLE_STAT4
  if (pVdbe == 0)
    goto failed;
#else
  assert(pVdbe != 0);
#endif

  for (pAuxData = pVdbe->pAuxData; pAuxData; pAuxData = pAuxData->pNextAux) {
    if (pAuxData->iAuxArg == iArg &&
        (pAuxData->iAuxOp == pCtx->iOp || iArg < 0)) {
      break;
    }
  }
  if (pAuxData == 0) {
    pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData));
    if (!pAuxData)
      goto failed;
    pAuxData->iAuxOp = pCtx->iOp;
    pAuxData->iAuxArg = iArg;
    pAuxData->pNextAux = pVdbe->pAuxData;
    pVdbe->pAuxData = pAuxData;
    if (pCtx->isError == 0)
      pCtx->isError = -1;
  } else if (pAuxData->xDeleteAux) {
    pAuxData->xDeleteAux(pAuxData->pAux);
  }

  pAuxData->pAux = pAux;
  pAuxData->xDeleteAux = xDelete;
  return;

failed:
  if (xDelete) {
    xDelete(pAux);
  }
}

#ifndef SQLITE_OMIT_DEPRECATED
/*
** Return the number of times the Step function of an aggregate has been
** called.
**
** This function is deprecated.  Do not use it for new code.  It is
** provide only to avoid breaking legacy code.  New aggregate function
** implementations should keep their own counts within their aggregate
** context.
*/
int sqlite3_aggregate_count(sqlite3_context *p) {
  assert(p && p->pMem && p->pFunc && p->pFunc->xFinalize);
  return p->pMem->n;
}
#endif

/*
** Return the number of columns in the result set for the statement pStmt.
*/
int sqlite3_column_count(sqlite3_stmt *pStmt) {
  Vdbe *pVm = (Vdbe *)pStmt;
  return pVm ? pVm->nResColumn : 0;
}

/*
** Return the number of values available from the current row of the
** currently executing statement pStmt.
*/
int sqlite3_data_count(sqlite3_stmt *pStmt) {
  Vdbe *pVm = (Vdbe *)pStmt;
  if (pVm == 0 || pVm->pResultSet == 0)
    return 0;
  return pVm->nResColumn;
}

/*
** Return a pointer to static memory containing an SQL NULL value.
*/
static const Mem *columnNullValue(void) {
  /* Even though the Mem structure contains an element
  ** of type i64, on certain architectures (x86) with certain compiler
  ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
  ** instead of an 8-byte one. This all works fine, except that when
  ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s
  ** that a Mem structure is located on an 8-byte boundary. To prevent
  ** these assert()s from failing, when building with SQLITE_DEBUG defined
  ** using gcc, we force nullMem to be 8-byte aligned using the magical
  ** __attribute__((aligned(8))) macro.  */
  static const Mem nullMem
#if defined(SQLITE_DEBUG) && defined(__GNUC__)
      __attribute__((aligned(8))) __attribute__((aligned(8)))
      __attribute__((aligned(8))) __attribute__((aligned(8)))
      __attribute__((aligned(8))) __attribute__((aligned(8)))
      __attribute__((aligned(8)))
#endif
      = {
          /* .u          = */ {0},
          /* .z          = */ (char *)0,
          /* .n          = */ (int)0,
          /* .flags      = */ (u16)MEM_Null,
          /* .enc        = */ (u8)0,
          /* .eSubtype   = */ (u8)0,
          /* .db         = */ (sqlite3 *)0,
          /* .szMalloc   = */ (int)0,
          /* .uTemp      = */ (u32)0,
          /* .zMalloc    = */ (char *)0,
          /* .xDel       = */ (void (*)(void *))0,
#ifdef SQLITE_DEBUG
          /* .pScopyFrom = */ (Mem *)0,
          /* .mScopyFlags= */ 0,
#endif
      };
  return &nullMem;
}

/*
** Check to see if column iCol of the given statement is valid.  If
** it is, return a pointer to the Mem for the value of that column.
** If iCol is not valid, return a pointer to a Mem which has a value
** of NULL.
*/
static Mem *columnMem(sqlite3_stmt *pStmt, int i) {
  Vdbe *pVm;
  Mem *pOut;

  pVm = (Vdbe *)pStmt;
  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 {
    sqlite3Error(pVm->db, SQLITE_RANGE);
    pOut = (Mem *)columnNullValue();
  }
  return pOut;
}

/*
** This function is called after invoking an sqlite3_value_XXX function on a
** column value (i.e. a value returned by evaluating an SQL expression in the
** select list of a SELECT statement) that may cause a malloc() failure. If
** malloc() has failed, the threads mallocFailed flag is cleared and the result
** code of statement pStmt set to SQLITE_NOMEM.
**
** Specifically, this is called from within:
**
**     sqlite3_column_int()
**     sqlite3_column_int64()
**     sqlite3_column_text()
**     sqlite3_column_text16()
**     sqlite3_column_real()
**     sqlite3_column_bytes()
**     sqlite3_column_bytes16()
**     sqiite3_column_blob()
*/
static void columnMallocFailure(sqlite3_stmt *pStmt) {
  /* If malloc() failed during an encoding conversion within an
  ** sqlite3_column_XXX API, then set the return code of the statement to
  ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
  ** and _finalize() will return NOMEM.
  */
  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);
  }
}

/**************************** sqlite3_column_  *******************************
** The following routines are used to access elements of the current row
** in the result set.
*/
#ifndef __sqlite_unmodified_upstream
void sqlite3_column_blob_(sqlite3_stmt *pStmt, int i)
    __attribute__((export_name("sqlite3_column_blob"))) {
  const char *blob = sqlite3_column_blob(pStmt, i);
  int blob_len = sqlite3_column_bytes(pStmt, i);

  // blob is managed by SQLite itself
  set_result_ptr((void *)blob);
  set_result_size(blob_len);
}
#endif

const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i) {
  const void *val;
  val = sqlite3_value_blob(columnMem(pStmt, i));
  /* Even though there is no encoding conversion, value_blob() might
  ** need to call malloc() to expand the result of a zeroblob()
  ** expression.
  */
  columnMallocFailure(pStmt);
  return val;
}
int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i) {
  int val = sqlite3_value_bytes(columnMem(pStmt, i));
  columnMallocFailure(pStmt);
  return val;
}
int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i) {
  int val = sqlite3_value_bytes16(columnMem(pStmt, i));
  columnMallocFailure(pStmt);
  return val;
}
double sqlite3_column_double(sqlite3_stmt *pStmt, int i) {
  double val = sqlite3_value_double(columnMem(pStmt, i));
  columnMallocFailure(pStmt);
  return val;
}
int sqlite3_column_int(sqlite3_stmt *pStmt, int i) {
  int val = sqlite3_value_int(columnMem(pStmt, i));
  columnMallocFailure(pStmt);
  return val;
}
sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i) {
  sqlite_int64 val = sqlite3_value_int64(columnMem(pStmt, i));
  columnMallocFailure(pStmt);
  return val;
}

#ifndef __sqlite_unmodified_upstream
void sqlite3_column_text_(sqlite3_stmt *pStmt, int i)
    __attribute__((export_name("sqlite3_column_text"))) {
  const unsigned char *text = sqlite3_column_text(pStmt, i);
  const unsigned int text_len = sqlite3_column_bytes(pStmt, i);

  // test is managed by SQLite itself
  set_result_ptr((void *)text);
  set_result_size(text_len);
}
#endif

const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i) {
  const unsigned char *val = sqlite3_value_text(columnMem(pStmt, i));
  columnMallocFailure(pStmt);
  return val;
}
sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i) {
  Mem *pOut = columnMem(pStmt, i);
  if (pOut->flags & MEM_Static) {
    pOut->flags &= ~MEM_Static;
    pOut->flags |= MEM_Ephem;
  }
  columnMallocFailure(pStmt);
  return (sqlite3_value *)pOut;
}
#ifndef SQLITE_OMIT_UTF16
const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i) {
  const void *val = sqlite3_value_text16(columnMem(pStmt, i));
  columnMallocFailure(pStmt);
  return val;
}
#endif /* SQLITE_OMIT_UTF16 */
int sqlite3_column_type(sqlite3_stmt *pStmt, int i) {
  int iType = sqlite3_value_type(columnMem(pStmt, i));
  columnMallocFailure(pStmt);
  return iType;
}

/*
** Convert the N-th element of pStmt->pColName[] into a string using
** xFunc() then return that string.  If N is out of range, return 0.
**
** There are up to 5 names for each column.  useType determines which
** name is returned.  Here are the names:
**
**    0      The column name as it should be displayed for output
**    1      The datatype name for the column
**    2      The name of the database that the column derives from
**    3      The name of the table that the column derives from
**    4      The name of the table column that the result column derives from
**
** If the result is not a simple column reference (if it is an expression
** or a constant) then useTypes 2, 3, and 4 return NULL.
*/
static const void *
columnName(sqlite3_stmt *pStmt, /* The statement */
           int N,               /* Which column to get the name for */
           int useUtf16,        /* True to return the name as UTF16 */
           int useType          /* What type of name */
) {
  const void *ret;
  Vdbe *p;
  int n;
  sqlite3 *db;
#ifdef SQLITE_ENABLE_API_ARMOR
  if (pStmt == 0) {
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  ret = 0;
  p = (Vdbe *)pStmt;
  db = p->db;
  assert(db != 0);
  n = sqlite3_column_count(pStmt);
  if (N < n && N >= 0) {
    N += useType * n;
    sqlite3_mutex_enter(db->mutex);
    assert(db->mallocFailed == 0);
#ifndef SQLITE_OMIT_UTF16
    if (useUtf16) {
      ret = sqlite3_value_text16((sqlite3_value *)&p->aColName[N]);
    } else
#endif
    {
      ret = sqlite3_value_text((sqlite3_value *)&p->aColName[N]);
    }
    /* A malloc may have failed inside of the _text() call. If this
    ** is the case, clear the mallocFailed flag and return NULL.
    */
    if (db->mallocFailed) {
      sqlite3OomClear(db);
      ret = 0;
    }
    sqlite3_mutex_leave(db->mutex);
  }
  return ret;
}

/*
** Return the name of the Nth column of the result set returned by SQL
** statement pStmt.
*/
#ifndef __sqlite_unmodified_upstream
void sqlite3_column_name_(sqlite3_stmt *pStmt, int N)
    __attribute__((export_name("sqlite3_column_name"))) {
  const char *result = sqlite3_column_name(pStmt, N);

  // result is managed by SQLite itself
  set_result_ptr((void *)result);
  set_result_size(strlen(result));
}
#endif

const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N) {
  return columnName(pStmt, N, 0, COLNAME_NAME);
}
#ifndef SQLITE_OMIT_UTF16
const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N) {
  return columnName(pStmt, N, 1, COLNAME_NAME);
}
#endif

/*
** Constraint:  If you have ENABLE_COLUMN_METADATA then you must
** not define OMIT_DECLTYPE.
*/
#if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA)
#error "Must not define both SQLITE_OMIT_DECLTYPE \
         and SQLITE_ENABLE_COLUMN_METADATA"
#endif

#ifndef SQLITE_OMIT_DECLTYPE
/*
** Return the column declaration type (if applicable) of the 'i'th column
** of the result set of SQL statement pStmt.
*/
const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N) {
  return columnName(pStmt, N, 0, COLNAME_DECLTYPE);
}
#ifndef SQLITE_OMIT_UTF16
const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N) {
  return columnName(pStmt, N, 1, COLNAME_DECLTYPE);
}
#endif /* SQLITE_OMIT_UTF16 */
#endif /* SQLITE_OMIT_DECLTYPE */

#ifdef SQLITE_ENABLE_COLUMN_METADATA
/*
** Return the name of the database from which a result column derives.
** NULL is returned if the result column is an expression or constant or
** anything else which is not an unambiguous reference to a database column.
*/
const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N) {
  return columnName(pStmt, N, 0, COLNAME_DATABASE);
}
#ifndef SQLITE_OMIT_UTF16
const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N) {
  return columnName(pStmt, N, 1, COLNAME_DATABASE);
}
#endif /* SQLITE_OMIT_UTF16 */

/*
** Return the name of the table from which a result column derives.
** NULL is returned if the result column is an expression or constant or
** anything else which is not an unambiguous reference to a database column.
*/
const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N) {
  return columnName(pStmt, N, 0, COLNAME_TABLE);
}
#ifndef SQLITE_OMIT_UTF16
const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N) {
  return columnName(pStmt, N, 1, COLNAME_TABLE);
}
#endif /* SQLITE_OMIT_UTF16 */

/*
** Return the name of the table column from which a result column derives.
** NULL is returned if the result column is an expression or constant or
** anything else which is not an unambiguous reference to a database column.
*/
const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N) {
  return columnName(pStmt, N, 0, COLNAME_COLUMN);
}
#ifndef SQLITE_OMIT_UTF16
const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N) {
  return columnName(pStmt, N, 1, COLNAME_COLUMN);
}
#endif /* SQLITE_OMIT_UTF16 */
#endif /* SQLITE_ENABLE_COLUMN_METADATA */

/******************************* sqlite3_bind_  ***************************
**
** Routines used to attach values to wildcards in a compiled SQL statement.
*/
/*
** Unbind the value bound to variable i in virtual machine p. This is the
** 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.
*/
static int vdbeUnbind(Vdbe *p, unsigned int i) {
  Mem *pVar;
  if (vdbeSafetyNotNull(p)) {
    return SQLITE_MISUSE_BKPT;
  }
  sqlite3_mutex_enter(p->db->mutex);
  if (p->eVdbeState != VDBE_READY_STATE) {
    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 >= (unsigned int)p->nVar) {
    sqlite3Error(p->db, SQLITE_RANGE);
    sqlite3_mutex_leave(p->db->mutex);
    return SQLITE_RANGE;
  }
  pVar = &p->aVar[i];
  sqlite3VdbeMemRelease(pVar);
  pVar->flags = MEM_Null;
  p->db->errCode = SQLITE_OK;

  /* If the bit corresponding to this variable in Vdbe.expmask is set, then
  ** binding a new value to this variable invalidates the current query plan.
  **
  ** IMPLEMENTATION-OF: R-57496-20354 If the specific value bound to a 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 bindings of that parameter.
  */
  assert((p->prepFlags & SQLITE_PREPARE_SAVESQL) != 0 || p->expmask == 0);
  if (p->expmask != 0 &&
      (p->expmask & (i >= 31 ? 0x80000000 : (u32)1 << i)) != 0) {
    p->expired = 1;
  }
  return SQLITE_OK;
}

/*
** Bind a text or BLOB value.
*/
static int bindText(sqlite3_stmt *pStmt, /* The statement to bind against */
                    int i,               /* Index of the parameter to bind */
                    const void *zData,   /* Pointer to the data to be bound */
                    i64 nData, /* Number of bytes of data to be bound */
                    void (*xDel)(void *), /* Destructor for the data */
                    u8 encoding           /* Encoding for the data */
) {
  Vdbe *p = (Vdbe *)pStmt;
  Mem *pVar;
  int rc;

  rc = vdbeUnbind(p, (u32)(i - 1));
  if (rc == SQLITE_OK) {
    if (zData != 0) {
      pVar = &p->aVar[i - 1];
      rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
      if (rc == SQLITE_OK && encoding != 0) {
        rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
      }
      if (rc) {
        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);
  }
  return rc;
}

/*
** Bind a blob value to an SQL statement variable.
*/
#ifndef __sqlite_unmodified_upstream
int sqlite3_bind_blob_(sqlite3_stmt *pStmt, int i, const void *zData, int nData,
                      void (*xDel)(void *))
    __attribute__((export_name("sqlite3_bind_blob"))) {
#ifdef SQLITE_ENABLE_API_ARMOR
  if (nData < 0)
    return SQLITE_MISUSE_BKPT;
#endif

  // xDel is a custom deallocator and due to our IT architecture it can't be provided from other modules.
  // However the memory zData uses has to be cleaned up eventually.
  // So, it is cleared as intended in IT, and xDel is set to SQLITE_TRANSIENT to make sqlite copy the data.
  add_object_to_release((void*)zData);
  return bindText(pStmt, i, zData, nData, SQLITE_TRANSIENT, 0);
}
#endif

int sqlite3_bind_blob(sqlite3_stmt *pStmt, int i, const void *zData, int nData,
                      void (*xDel)(void *)) {
#ifdef SQLITE_ENABLE_API_ARMOR
  if (nData < 0) return SQLITE_MISUSE_BKPT;
#endif

  return bindText(pStmt, i, zData, nData, xDel, 0);
}
int sqlite3_bind_blob64(sqlite3_stmt *pStmt, int i, const void *zData,
                        sqlite3_uint64 nData, void (*xDel)(void *)) {
  assert(xDel != SQLITE_DYNAMIC);
  return bindText(pStmt, i, zData, nData, xDel, 0);
}
int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue) {
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, (u32)(i - 1));
  if (rc == SQLITE_OK) {
    sqlite3VdbeMemSetDouble(&p->aVar[i - 1], rValue);
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}
int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue) {
  return sqlite3_bind_int64(p, i, (i64)iValue);
}
int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue) {
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, (u32)(i - 1));
  if (rc == SQLITE_OK) {
    sqlite3VdbeMemSetInt64(&p->aVar[i - 1], iValue);
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}
int sqlite3_bind_null(sqlite3_stmt *pStmt, int i) {
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, (u32)(i - 1));
  if (rc == SQLITE_OK) {
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}
int sqlite3_bind_pointer(sqlite3_stmt *pStmt, int i, void *pPtr,
                         const char *zPTtype, void (*xDestructor)(void *)) {
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, (u32)(i - 1));
  if (rc == SQLITE_OK) {
    sqlite3VdbeMemSetPointer(&p->aVar[i - 1], pPtr, zPTtype, xDestructor);
    sqlite3_mutex_leave(p->db->mutex);
  } else if (xDestructor) {
    xDestructor(pPtr);
  }
  return rc;
}

int sqlite3_bind_text(sqlite3_stmt *pStmt, int i, const char *zData, int nData,
                      void (*xDel)(void *)) {
  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
}

#ifndef __sqlite_unmodified_upstream
int sqlite3_bind_text_(sqlite3_stmt *pStmt, int i, const char *zData, int nData,
                      void (*xDel)(void *))
    __attribute__((export_name("sqlite3_bind_text"))) {
  // xDel is a custom deallocator and due to our IT architecture it can't be provided from other modules.
  // However the memory zData uses has to be cleaned up eventually.
  // So, it is cleared as intended in IT, and xDel is set to SQLITE_TRANSIENT to make sqlite copy the data.
  add_object_to_release((void*)zData);
  return bindText(pStmt, i, zData, nData, SQLITE_TRANSIENT, SQLITE_UTF8);
}
#endif

int sqlite3_bind_text64(sqlite3_stmt *pStmt, int i, const char *zData,
                        sqlite3_uint64 nData, void (*xDel)(void *),
                        unsigned char enc) {
  assert(xDel != SQLITE_DYNAMIC);
  if (enc == SQLITE_UTF16)
    enc = SQLITE_UTF16NATIVE;
  return bindText(pStmt, i, zData, nData, xDel, enc);
}
#ifndef SQLITE_OMIT_UTF16
int sqlite3_bind_text16(sqlite3_stmt *pStmt, int i, const void *zData,
                        int nData, void (*xDel)(void *)) {
  return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
}
#endif /* SQLITE_OMIT_UTF16 */
int sqlite3_bind_value(sqlite3_stmt *pStmt, int i,
                       const sqlite3_value *pValue) {
  int rc;
  switch (sqlite3_value_type((sqlite3_value *)pValue)) {
  case SQLITE_INTEGER: {
    rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
    break;
  }
  case SQLITE_FLOAT: {
    assert(pValue->flags & (MEM_Real | MEM_IntReal));
    rc = sqlite3_bind_double(pStmt, i,
                             (pValue->flags & MEM_Real) ? pValue->u.r
                                                        : (double)pValue->u.i);
    break;
  }
  case SQLITE_BLOB: {
    if (pValue->flags & MEM_Zero) {
      rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
    } else {
      rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n, SQLITE_TRANSIENT);
    }
    break;
  }
  case SQLITE_TEXT: {
    rc =
        bindText(pStmt, i, pValue->z, pValue->n, SQLITE_TRANSIENT, pValue->enc);
    break;
  }
  default: {
    rc = sqlite3_bind_null(pStmt, i);
    break;
  }
  }
  return rc;
}
int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n) {
  int rc;
  Vdbe *p = (Vdbe *)pStmt;
  rc = vdbeUnbind(p, (u32)(i - 1));
  if (rc == SQLITE_OK) {
#ifndef SQLITE_OMIT_INCRBLOB
    sqlite3VdbeMemSetZeroBlob(&p->aVar[i - 1], n);
#else
    rc = sqlite3VdbeMemSetZeroBlob(&p->aVar[i - 1], n);
#endif
    sqlite3_mutex_leave(p->db->mutex);
  }
  return rc;
}
int 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 {
    assert((n & 0x7FFFFFFF) == n);
    rc = sqlite3_bind_zeroblob(pStmt, i, n);
  }
  rc = sqlite3ApiExit(p->db, rc);
  sqlite3_mutex_leave(p->db->mutex);
  return rc;
}

/*
** Return the number of wildcards that can be potentially bound to.
** This routine is added to support DBD::SQLite.
*/
int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt) {
  Vdbe *p = (Vdbe *)pStmt;
  return p ? p->nVar : 0;
}

/*
** Return the name of a wildcard parameter.  Return NULL if the index
** is out of range or if the wildcard is unnamed.
**
** The result is always UTF-8.
*/
const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i) {
  Vdbe *p = (Vdbe *)pStmt;
  if (p == 0)
    return 0;
  return sqlite3VListNumToName(p->pVList, i);
}

/*
** Given a wildcard parameter name, return the index of the variable
** with that name.  If there is no variable with the given name,
** return 0.
*/
int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName) {
  if (p == 0 || zName == 0)
    return 0;
  return sqlite3VListNameToNum(p->pVList, zName, nName);
}
int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName) {
  return sqlite3VdbeParameterIndex((Vdbe *)pStmt, zName,
                                   sqlite3Strlen30(zName));
}

/*
** Transfer all bindings from the first statement over to the second.
*/
int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt) {
  Vdbe *pFrom = (Vdbe *)pFromStmt;
  Vdbe *pTo = (Vdbe *)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;
}

#ifndef SQLITE_OMIT_DEPRECATED
/*
** Deprecated external interface.  Internal/core SQLite code
** should call sqlite3TransferBindings.
**
** It is misuse to call this routine with statements from different
** database connections.  But as this is a deprecated interface, we
** will not bother to check for that condition.
**
** If the two statements contain a different number of bindings, then
** an SQLITE_ERROR is returned.  Nothing else can go wrong, so otherwise
** SQLITE_OK is returned.
*/
int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt) {
  Vdbe *pFrom = (Vdbe *)pFromStmt;
  Vdbe *pTo = (Vdbe *)pToStmt;
  if (pFrom->nVar != pTo->nVar) {
    return SQLITE_ERROR;
  }
  assert((pTo->prepFlags & SQLITE_PREPARE_SAVESQL) != 0 || pTo->expmask == 0);
  if (pTo->expmask) {
    pTo->expired = 1;
  }
  assert((pFrom->prepFlags & SQLITE_PREPARE_SAVESQL) != 0 ||
         pFrom->expmask == 0);
  if (pFrom->expmask) {
    pFrom->expired = 1;
  }
  return sqlite3TransferBindings(pFromStmt, pToStmt);
}
#endif

/*
** Return the sqlite3* database handle to which the prepared statement given
** in the argument belongs.  This is the same database handle that was
** the first argument to the sqlite3_prepare() that was used to create
** the statement in the first place.
*/
sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt) {
  return pStmt ? ((Vdbe *)pStmt)->db : 0;
}

/*
** Return true if the prepared statement is guaranteed to not modify the
** database.
*/
int sqlite3_stmt_readonly(sqlite3_stmt *pStmt) {
  return pStmt ? ((Vdbe *)pStmt)->readOnly : 1;
}

/*
** Return 1 if the statement is an EXPLAIN and return 2 if the
** statement is an EXPLAIN QUERY PLAN
*/
int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt) {
  return pStmt ? ((Vdbe *)pStmt)->explain : 0;
}

/*
** Return true if the prepared statement is in need of being reset.
*/
int sqlite3_stmt_busy(sqlite3_stmt *pStmt) {
  Vdbe *v = (Vdbe *)pStmt;
  return v != 0 && v->eVdbeState == VDBE_RUN_STATE;
}

/*
** Return a pointer to the next prepared statement after pStmt associated
** with database connection pDb.  If pStmt is NULL, return the first
** prepared statement for the database connection.  Return NULL if there
** are no more.
*/
sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt) {
  sqlite3_stmt *pNext;
#ifdef SQLITE_ENABLE_API_ARMOR
  if (!sqlite3SafetyCheckOk(pDb)) {
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  sqlite3_mutex_enter(pDb->mutex);
  if (pStmt == 0) {
    pNext = (sqlite3_stmt *)pDb->pVdbe;
  } else {
    pNext = (sqlite3_stmt *)((Vdbe *)pStmt)->pVNext;
  }
  sqlite3_mutex_leave(pDb->mutex);
  return pNext;
}

/*
** Return the value of a status counter for a prepared statement
*/
int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag) {
  Vdbe *pVdbe = (Vdbe *)pStmt;
  u32 v;
#ifdef SQLITE_ENABLE_API_ARMOR
  if (!pStmt || (op != SQLITE_STMTSTATUS_MEMUSED &&
                 (op < 0 || op >= ArraySize(pVdbe->aCounter)))) {
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif
  if (op == SQLITE_STMTSTATUS_MEMUSED) {
    sqlite3 *db = pVdbe->db;
    sqlite3_mutex_enter(db->mutex);
    v = 0;
    db->pnBytesFreed = (int *)&v;
    assert(db->lookaside.pEnd == db->lookaside.pTrueEnd);
    db->lookaside.pEnd = db->lookaside.pStart;
    sqlite3VdbeDelete(pVdbe);
    db->pnBytesFreed = 0;
    db->lookaside.pEnd = db->lookaside.pTrueEnd;
    sqlite3_mutex_leave(db->mutex);
  } else {
    v = pVdbe->aCounter[op];
    if (resetFlag)
      pVdbe->aCounter[op] = 0;
  }
  return (int)v;
}

/*
** Return the SQL associated with a prepared statement
*/
const char *sqlite3_sql(sqlite3_stmt *pStmt) {
  Vdbe *p = (Vdbe *)pStmt;
  return p ? p->zSql : 0;
}

/*
** Return the SQL associated with a prepared statement with
** bound parameters expanded.  Space to hold the returned string is
** obtained from sqlite3_malloc().  The caller is responsible for
** freeing the returned string by passing it to sqlite3_free().
**
** The SQLITE_TRACE_SIZE_LIMIT puts an upper bound on the size of
** expanded bound parameters.
*/
char *sqlite3_expanded_sql(sqlite3_stmt *pStmt) {
#ifdef SQLITE_OMIT_TRACE
  return 0;
#else
  char *z = 0;
  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
}

#ifdef SQLITE_ENABLE_NORMALIZE
/*
** Return the normalized SQL associated with a prepared statement.
*/
const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt) {
  Vdbe *p = (Vdbe *)pStmt;
  if (p == 0)
    return 0;
  if (p->zNormSql == 0 && ALWAYS(p->zSql != 0)) {
    sqlite3_mutex_enter(p->db->mutex);
    p->zNormSql = sqlite3Normalize(p, p->zSql);
    sqlite3_mutex_leave(p->db->mutex);
  }
  return p->zNormSql;
}
#endif /* SQLITE_ENABLE_NORMALIZE */

#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
/*
** Allocate and populate an UnpackedRecord structure based on the serialized
** record in nKey/pKey. Return a pointer to the new UnpackedRecord structure
** if successful, or a NULL pointer if an OOM error is encountered.
*/
static UnpackedRecord *vdbeUnpackRecord(KeyInfo *pKeyInfo, int nKey,
                                        const void *pKey) {
  UnpackedRecord *pRet; /* Return value */

  pRet = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
  if (pRet) {
    memset(pRet->aMem, 0, sizeof(Mem) * (pKeyInfo->nKeyField + 1));
    sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, pRet);
  }
  return pRet;
}

/*
** This function is called from within a pre-update callback to retrieve
** a field of the row currently being updated or deleted.
*/
int sqlite3_preupdate_old(sqlite3 *db, int iIdx, sqlite3_value **ppValue) {
  PreUpdate *p = db->pPreUpdate;
  Mem *pMem;
  int rc = SQLITE_OK;

  /* Test that this call is being made from within an SQLITE_DELETE or
  ** SQLITE_UPDATE pre-update callback, and that iIdx is within range. */
  if (!p || p->op == SQLITE_INSERT) {
    rc = SQLITE_MISUSE_BKPT;
    goto preupdate_old_out;
  }
  if (p->pPk) {
    iIdx = sqlite3TableColumnToIndex(p->pPk, iIdx);
  }
  if (iIdx >= p->pCsr->nField || iIdx < 0) {
    rc = SQLITE_RANGE;
    goto preupdate_old_out;
  }

  /* If the old.* record has not yet been loaded into memory, do so now. */
  if (p->pUnpacked == 0) {
    u32 nRec;
    u8 *aRec;

    assert(p->pCsr->eCurType == CURTYPE_BTREE);
    nRec = sqlite3BtreePayloadSize(p->pCsr->uc.pCursor);
    aRec = sqlite3DbMallocRaw(db, nRec);
    if (!aRec)
      goto preupdate_old_out;
    rc = sqlite3BtreePayload(p->pCsr->uc.pCursor, 0, nRec, aRec);
    if (rc == SQLITE_OK) {
      p->pUnpacked = vdbeUnpackRecord(&p->keyinfo, nRec, aRec);
      if (!p->pUnpacked)
        rc = SQLITE_NOMEM;
    }
    if (rc != SQLITE_OK) {
      sqlite3DbFree(db, aRec);
      goto preupdate_old_out;
    }
    p->aRecord = aRec;
  }

  pMem = *ppValue = &p->pUnpacked->aMem[iIdx];
  if (iIdx == p->pTab->iPKey) {
    sqlite3VdbeMemSetInt64(pMem, p->iKey1);
  } else if (iIdx >= p->pUnpacked->nField) {
    *ppValue = (sqlite3_value *)columnNullValue();
  } else if (p->pTab->aCol[iIdx].affinity == SQLITE_AFF_REAL) {
    if (pMem->flags & (MEM_Int | MEM_IntReal)) {
      testcase(pMem->flags & MEM_Int);
      testcase(pMem->flags & MEM_IntReal);
      sqlite3VdbeMemRealify(pMem);
    }
  }

preupdate_old_out:
  sqlite3Error(db, rc);
  return sqlite3ApiExit(db, rc);
}
#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */

#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
/*
** This function is called from within a pre-update callback to retrieve
** the number of columns in the row being updated, deleted or inserted.
*/
int sqlite3_preupdate_count(sqlite3 *db) {
  PreUpdate *p = db->pPreUpdate;
  return (p ? p->keyinfo.nKeyField : 0);
}
#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */

#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
/*
** This function is designed to be called from within a pre-update callback
** only. It returns zero if the change that caused the callback was made
** immediately by a user SQL statement. Or, if the change was made by a
** trigger program, it returns the number of trigger programs currently
** on the stack (1 for a top-level trigger, 2 for a trigger fired by a
** top-level trigger etc.).
**
** For the purposes of the previous paragraph, a foreign key CASCADE, SET NULL
** or SET DEFAULT action is considered a trigger.
*/
int sqlite3_preupdate_depth(sqlite3 *db) {
  PreUpdate *p = db->pPreUpdate;
  return (p ? p->v->nFrame : 0);
}
#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */

#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
/*
** This function is designed to be called from within a pre-update callback
** only.
*/
int sqlite3_preupdate_blobwrite(sqlite3 *db) {
  PreUpdate *p = db->pPreUpdate;
  return (p ? p->iBlobWrite : -1);
}
#endif

#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
/*
** This function is called from within a pre-update callback to retrieve
** a field of the row currently being updated or inserted.
*/
int sqlite3_preupdate_new(sqlite3 *db, int iIdx, sqlite3_value **ppValue) {
  PreUpdate *p = db->pPreUpdate;
  int rc = SQLITE_OK;
  Mem *pMem;

  if (!p || p->op == SQLITE_DELETE) {
    rc = SQLITE_MISUSE_BKPT;
    goto preupdate_new_out;
  }
  if (p->pPk && p->op != SQLITE_UPDATE) {
    iIdx = sqlite3TableColumnToIndex(p->pPk, iIdx);
  }
  if (iIdx >= p->pCsr->nField || iIdx < 0) {
    rc = SQLITE_RANGE;
    goto preupdate_new_out;
  }

  if (p->op == SQLITE_INSERT) {
    /* For an INSERT, memory cell p->iNewReg contains the serialized record
    ** that is being inserted. Deserialize it. */
    UnpackedRecord *pUnpack = p->pNewUnpacked;
    if (!pUnpack) {
      Mem *pData = &p->v->aMem[p->iNewReg];
      rc = ExpandBlob(pData);
      if (rc != SQLITE_OK)
        goto preupdate_new_out;
      pUnpack = vdbeUnpackRecord(&p->keyinfo, pData->n, pData->z);
      if (!pUnpack) {
        rc = SQLITE_NOMEM;
        goto preupdate_new_out;
      }
      p->pNewUnpacked = pUnpack;
    }
    pMem = &pUnpack->aMem[iIdx];
    if (iIdx == p->pTab->iPKey) {
      sqlite3VdbeMemSetInt64(pMem, p->iKey2);
    } else if (iIdx >= pUnpack->nField) {
      pMem = (sqlite3_value *)columnNullValue();
    }
  } else {
    /* For an UPDATE, memory cell (p->iNewReg+1+iIdx) contains the required
    ** value. Make a copy of the cell contents and return a pointer to it.
    ** It is not safe to return a pointer to the memory cell itself as the
    ** caller may modify the value text encoding.
    */
    assert(p->op == SQLITE_UPDATE);
    if (!p->aNew) {
      p->aNew = (Mem *)sqlite3DbMallocZero(db, sizeof(Mem) * p->pCsr->nField);
      if (!p->aNew) {
        rc = SQLITE_NOMEM;
        goto preupdate_new_out;
      }
    }
    assert(iIdx >= 0 && iIdx < p->pCsr->nField);
    pMem = &p->aNew[iIdx];
    if (pMem->flags == 0) {
      if (iIdx == p->pTab->iPKey) {
        sqlite3VdbeMemSetInt64(pMem, p->iKey2);
      } else {
        rc = sqlite3VdbeMemCopy(pMem, &p->v->aMem[p->iNewReg + 1 + iIdx]);
        if (rc != SQLITE_OK)
          goto preupdate_new_out;
      }
    }
  }
  *ppValue = pMem;

preupdate_new_out:
  sqlite3Error(db, rc);
  return sqlite3ApiExit(db, rc);
}
#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */

#ifdef SQLITE_ENABLE_STMT_SCANSTATUS
/*
** Return status data for a single loop within query pStmt.
*/
int sqlite3_stmt_scanstatus(
    sqlite3_stmt *pStmt, /* Prepared statement being queried */
    int idx,             /* Index of loop to report on */
    int iScanStatusOp,   /* Which metric to return */
    void *pOut           /* OUT: Write the answer here */
) {
  Vdbe *p = (Vdbe *)pStmt;
  ScanStatus *pScan;
  if (idx < 0 || idx >= p->nScan)
    return 1;
  pScan = &p->aScan[idx];
  switch (iScanStatusOp) {
  case SQLITE_SCANSTAT_NLOOP: {
    *(sqlite3_int64 *)pOut = p->anExec[pScan->addrLoop];
    break;
  }
  case SQLITE_SCANSTAT_NVISIT: {
    *(sqlite3_int64 *)pOut = p->anExec[pScan->addrVisit];
    break;
  }
  case SQLITE_SCANSTAT_EST: {
    double r = 1.0;
    LogEst x = pScan->nEst;
    while (x < 100) {
      x += 10;
      r *= 0.5;
    }
    *(double *)pOut = r * sqlite3LogEstToInt(x);
    break;
  }
  case SQLITE_SCANSTAT_NAME: {
    *(const char **)pOut = pScan->zName;
    break;
  }
  case SQLITE_SCANSTAT_EXPLAIN: {
    if (pScan->addrExplain) {
      *(const char **)pOut = p->aOp[pScan->addrExplain].p4.z;
    } else {
      *(const char **)pOut = 0;
    }
    break;
  }
  case SQLITE_SCANSTAT_SELECTID: {
    if (pScan->addrExplain) {
      *(int *)pOut = p->aOp[pScan->addrExplain].p1;
    } else {
      *(int *)pOut = -1;
    }
    break;
  }
  default: {
    return 1;
  }
  }
  return 0;
}

/*
** Zero all counters associated with the sqlite3_stmt_scanstatus() data.
*/
void sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt) {
  Vdbe *p = (Vdbe *)pStmt;
  memset(p->anExec, 0, p->nOp * sizeof(i64));
}
#endif /* SQLITE_ENABLE_STMT_SCANSTATUS */