SQLite

    /* sqlite3_cancel_auto_extension() has a hand-written binding. */
    /* sqlite3_close_v2() is implemented by hand to perform some
       extra work. */
    ["sqlite3_changes", "int", "sqlite3*"],
    ["sqlite3_clear_bindings","int", "sqlite3_stmt*"],
    ["sqlite3_collation_needed", "int", "sqlite3*", "*", "*"/*=>v(ppis)*/],
    ["sqlite3_column_blob","*", "sqlite3_stmt*", "int"],
    ["sqlite3_column_blob_v2", "int", "sqlite3_stmt*", "int", "**", "*", "*"],
    ["sqlite3_column_bytes","int", "sqlite3_stmt*", "int"],
    ["sqlite3_column_count", "int", "sqlite3_stmt*"],
    ["sqlite3_column_decltype", "string", "sqlite3_stmt*", "int"],
    ["sqlite3_column_double","f64", "sqlite3_stmt*", "int"],
    ["sqlite3_column_int","int", "sqlite3_stmt*", "int"],
    ["sqlite3_column_name","string", "sqlite3_stmt*", "int"],
    ["sqlite3_column_text","string", "sqlite3_stmt*", "int"],
    ["sqlite3_column_text_v2", "int", "sqlite3_stmt*", "int", "**", "*", "*"],
    ["sqlite3_column_type","int", "sqlite3_stmt*", "int"],
    ["sqlite3_column_value","sqlite3_value*", "sqlite3_stmt*", "int"],
    ["sqlite3_commit_hook", "void*", [
      "sqlite3*",
      new wasm.xWrap.FuncPtrAdapter({
        name: 'sqlite3_commit_hook',
        signature: 'i(p)',

       their first C-string arguments, so we cannot perform any value
       conversion on those. */
    ["sqlite3_uri_boolean", "int", "sqlite3_filename", "string", "int"],
    ["sqlite3_uri_key", "string", "sqlite3_filename", "int"],
    ["sqlite3_uri_parameter", "string", "sqlite3_filename", "string"],
    ["sqlite3_user_data","void*", "sqlite3_context*"],
    ["sqlite3_value_blob", "*", "sqlite3_value*"],
    ["sqlite3_value_blob_v2", "int", "sqlite3_value*", "**", "*", "*"],
    ["sqlite3_value_bytes","int", "sqlite3_value*"],
    ["sqlite3_value_double","f64", "sqlite3_value*"],
    ["sqlite3_value_dup", "sqlite3_value*", "sqlite3_value*"],
    ["sqlite3_value_free", undefined, "sqlite3_value*"],
    ["sqlite3_value_frombind", "int", "sqlite3_value*"],
    ["sqlite3_value_int","int", "sqlite3_value*"],
    ["sqlite3_value_nochange", "int", "sqlite3_value*"],
    ["sqlite3_value_numeric_type", "int", "sqlite3_value*"],
    ["sqlite3_value_pointer", "*", "sqlite3_value*", "string:static"],
    ["sqlite3_value_subtype", "int", "sqlite3_value*"],
    ["sqlite3_value_text", "string", "sqlite3_value*"],
    ["sqlite3_value_text_v2", "int", "sqlite3_value*", "**", "*", "*"],
    ["sqlite3_value_type", "int", "sqlite3_value*"],
    ["sqlite3_vfs_find", "*", "string"],
    ["sqlite3_vfs_register", "int", "sqlite3_vfs*", "int"],
    ["sqlite3_vfs_unregister", "int", "sqlite3_vfs*"]
  ]/*wasm.bindingSignatures*/;

  if( !!wasm.exports.sqlite3_progress_handler ){

               "values(1,123),(2,null),(3,'hi world'),(4,X'232A'),(5,'')"]);
      const P = wasm.pstack;
      const stack = P.pointer;
      let q;
      try {
        let sv, rc;
        q = db.prepare("select a, b from t order by a");
        let [ppOut, pnOut, pType] = P.allocPtr(3);
        const clearPtrs = ()=>{
          wasm.pokePtr(ppOut, 0).poke32(pnOut, 0).poke32(pType, 0);
        };
        const next = ()=>{
          T.assert( q.step() );
          sv = capi.sqlite3_column_value(q, 1);
          T.assert( sv );
          clearPtrs();
          rc = capi.sqlite3_value_text_v2(sv, ppOut, pnOut, pType);
          T.assert( 0===rc );
          return sv;
        };
        const cmp = function(type,expect){
          const blob = wasm.peekPtr(ppOut);
          const len = wasm.peek32(pnOut);
          //log("blob=",wasm.cstrToJs(blob));
          const str = wasm.cstrToJs(blob);
          if( !blob ){
            T.assert( null===expect )
              .assert( 0===len );
            return;
          }
          T.assert(len === expect.length,
                   "Lengths don't match: got ["+str
                   +"] expected ["+expect+"]")
            .assert( str===expect, "String mismatch: got ["
                     +str+"] expected ["+expect+"]");
        };
        const cmp2 = (type,expect)=>{
          next();
          cmp(type,expect);
          clearPtrs();
          const rc = capi.sqlite3_column_text_v2(q, 1, ppOut, pnOut, pType);
          T.assert( 0==rc, "expecting column_text_v2() rc 0 but got "+rc );
          cmp(type,expect);
        };

        cmp2(capi.SQLITE_INTEGER,'123');
        cmp2(capi.SQLITE_NULL,null);
        cmp2(capi.SQLITE_TEXT,'hi world');
        cmp2(capi.SQLITE_BLOB, '#*');
        cmp2(capi.SQLITE_TEXT, ''); // empty strings are not null

        const checkRc = (name, descr, rc)=>{
          T.assert( capi[name] === rc,
                    descr+": expecting "+name+"("+
                    capi[name]+") but got "+rc);
        };

        /** The following tests cover the same code paths
            for both text_v2 and blob_v2, so are elided from
            the blob_v2 checks in the next test group. */

        // This does not set a persistent error flag on q:
        checkRc('SQLITE_RANGE', "column_text_v2() bad index",
                capi.sqlite3_column_text_v2(q, 11, ppOut, pnOut, 0) );
        checkRc('SQLITE_OK', "column_text_v2() valid index",
                capi.sqlite3_column_text_v2(q, 1, ppOut, 0, 0));

        checkRc('SQLITE_OK', "column null pnOut",
                capi.sqlite3_column_text_v2(q, 1, ppOut, 0, 0));

        /* The MISUSE returns only apply because we build with
           SQLITE_ENABLE_API_ARMOR. Without API_ARMOR, these result in
           null pointer dereferences. */
        checkRc('SQLITE_MISUSE', "value null ppOut",
                capi.sqlite3_value_text_v2(sv, 0, pnOut, 0));
        checkRc('SQLITE_MISUSE', "value null arg0",
                capi.sqlite3_value_text_v2(0, ppOut, pnOut, 0));
        checkRc('SQLITE_MISUSE', "column null ppOut",
                capi.sqlite3_column_text_v2(q, 1, 0, pnOut, 0));
        /* But a 0 pnOut is always okay. */
        checkRc('SQLITE_OK', "value null pnOut",
                capi.sqlite3_value_text_v2(sv, ppOut, 0, 0));

      }finally{
        if( q ) q.finalize();
        db.close();
        P.restore(stack);
      }
    })

  ////////////////////////////////////////////////////////////////////
    .t("value_blob_v2() and friends...", function(sqlite3){
      const db = new sqlite3.oo1.DB();
      db.exec(["create table t(a,b); insert into t(a,b) ",
               "values(1,123),(2,null),(3,'hi'),(4,X'23002A'),(5,'')"]);
      const P = wasm.pstack;
      const stack = P.pointer;
      let q;
      try {
        let sv, rc;
        q = db.prepare("select a, b from t order by a");
        let [ppOut, pnOut, pType] = P.allocPtr(3);
        const clearPtrs = ()=>{
          wasm.pokePtr(ppOut, 0).poke32(pnOut, 0).poke32(pType, 0);
        };

        const next = ()=>{

          T.assert( q.step() );
          sv = capi.sqlite3_column_value(q, 1);
          T.assert( sv );
          clearPtrs();

          rc = capi.sqlite3_value_blob_v2(sv, ppOut, pnOut, pType);
          T.assert( 0==rc, "expecting value_blob_v2() rc 0 but got "+rc );
          return sv;
        };

        const cmp = (type,byteList)=>{
          const blob = wasm.peekPtr(ppOut);
          const len = wasm.peek32(pnOut);
          //log("blob=",wasm.cstrToJs(blob));
          T.assert(len === byteList.length, "Lengths don't match")
          T.assert( len ? !!blob : !blob,
                    "Expecting len=non-0/blob=non-null or len=0/blob=null. "+
                    "Got len="+len+" blob=@"+blob );
          T.assert( type === wasm.peek32(pType),
                    "Expecting value_blob_v2 type "+type+" but got "
                    +wasm.peek32(pType)+". Value="+wasm.cstrToJs(blob));
          for( let i = 0; i < len; ++i ){
            T.assert( byteList[i] === wasm.peek8(blob+i),
                      "mismatch at offset "+i+": "+byteList[i]
                      +"!=="+wasm.peek8(blob+i) );
          }
        };
        const cmp2 = (type,byteList)=>{
          next();
          cmp(type,byteList);
          clearPtrs();
          const rc = capi.sqlite3_column_blob_v2(q, 1, ppOut, pnOut, pType);
          T.assert( 0==rc, "expecting column_blob_v2() rc 0 but got "+rc);
          cmp(type,byteList);
        };

        cmp2(capi.SQLITE_INTEGER, [49,50,51]); // 123
        cmp2(capi.SQLITE_NULL, []); // null

        cmp2(capi.SQLITE_TEXT, [104,105]); // "hi"
        cmp2(capi.SQLITE_BLOB, [0x23, 0, 0x2a]); // X'23002A'
        cmp2(capi.SQLITE_TEXT, []) /* length-0 non-NULL blobs are NULL
                                      but this one has type TEXT */;


        /** Tests which cover the same code paths for both text_v2 and
            blob_v2 are in the previous test group. */

      }finally{
        if( q ) q.finalize();
        db.close();

** to the [prepared statement] that is being evaluated (the [sqlite3_stmt*]
** that was returned from [sqlite3_prepare_v2()] or one of its variants)
** and the second argument is the index of the column for which information
** should be returned. ^The leftmost column of the result set has the index 0.
** ^The number of columns in the result can be determined using
** [sqlite3_column_count()].
**
** ^The sqlite3_column_text_v2() and sqlite3_column_blob_v2()
** interfaces deliver most of their output via their 3rd, 4th, and 5th
** output-pointer arguments. The 3rd is an output pointer to the
** resulting memory (the same pointer which would be returned by their
** non-v2 counterparts). The 4th is an integer pointer into which, if
** it is not NULL, the length of the memory, in bytes, is written. The
** 5th argument is an integer pointer which, if not NULL, gets set to
** the [SQLITE_INTEGER | column's SQL type]. On success these
** interfaces return 0. On error they do not modify any of their
** output pointers and return SQLITE_NOMEM on allocation error and
** SQLITE_RANGE if the given column index is out of range. Results are
** undefined if either of their 1st or 3rd arguments are NULL.
**
** If the SQL statement does not currently point to a valid row, or if the
** column index is out of range, the result is undefined.
** These routines may only be called when the most recent call to
** [sqlite3_step()] has returned [SQLITE_ROW] and neither
** [sqlite3_reset()] nor [sqlite3_finalize()] have been called subsequently.
** If any of these routines are called after [sqlite3_reset()] or
** [sqlite3_finalize()] or after [sqlite3_step()] has returned
** something other than [SQLITE_ROW], the results are undefined.
** If [sqlite3_step()] or [sqlite3_reset()] or [sqlite3_finalize()]
** are called from a different thread while any of these routines
** are pending, then the results are undefined.
**
** The interfaces (_blob, _double, _int, _int64, _text, and _text16)
** each return the value of a result column in a specific data format.  If
** the result column is not initially in the requested format (for example,
** if the query returns an integer but the sqlite3_column_text() interface
** is used to extract the value) then an automatic type conversion is performed.
**
** ^The interfaces (_text_v2, _blob_v2) interally function identically
** to their non-_v2 counterparts but have different interfaces. Their
** internal behaviors are the same for purposes of the following
** documentation except where specifically noted otherwise.
**
** ^The sqlite3_column_type() routine returns the
** [SQLITE_INTEGER | datatype code] for the initial data type
** of the result column.  ^The returned value is one of [SQLITE_INTEGER],
** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL].
** The return value of sqlite3_column_type() can be used to decide which
** of the first six interface should be used to extract the column value.

** other SQLite interface is called on the same [database connection].
**
** The previous paragraph does not apply to the text_v2 and blob_v2
** interfaces, which return SQLITE_NOMEM to the client for
** out-of-memory conditions.
*/
const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
int sqlite3_column_blob_v2(sqlite3_stmt*, int iCol, const void **, int*, int*);
double sqlite3_column_double(sqlite3_stmt*, int iCol);
int sqlite3_column_int(sqlite3_stmt*, int iCol);
sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
int sqlite3_column_text_v2(sqlite3_stmt*, int iCol, const unsigned char **, int*, int*);
const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
int sqlite3_column_type(sqlite3_stmt*, int iCol);

/*

** [SQLITE_FLOAT], [SQLITE_TEXT], [SQLITE_BLOB], or [SQLITE_NULL].)^
** Other interfaces might change the datatype for an sqlite3_value object.
** For example, if the datatype is initially SQLITE_INTEGER and
** sqlite3_value_text(V) is called to extract a text value for that
** integer, then subsequent calls to sqlite3_value_type(V) might return
** SQLITE_TEXT.  Whether or not a persistent internal datatype conversion
** occurs is undefined and may change from one release of SQLite to the next.










**
** ^(The sqlite3_value_numeric_type() interface attempts to apply
** numeric affinity to the value.  This means that an attempt is
** made to convert the value to an integer or floating point.  If
** such a conversion is possible without loss of information (in other
** words, if the value is a string that looks like a number)
** then the conversion is performed.  Otherwise no conversion occurs.

**
** ^The sqlite3_value_frombind(X) interface returns non-zero if the
** value X originated from one of the [sqlite3_bind_int|sqlite3_bind()]
** interfaces.  ^If X comes from an SQL literal value, or a table column,
** or an expression, then sqlite3_value_frombind(X) returns zero.
**
** Please pay particular attention to the fact that the pointer returned
** from [sqlite3_value_blob()], [sqlite3_value_text()], or

** [sqlite3_value_text16()] can be invalidated by a subsequent call to
** [sqlite3_value_bytes()], [sqlite3_value_bytes16()], [sqlite3_value_text()],
** or [sqlite3_value_text16()].
**
** These routines must be called from the same thread as
** the SQL function that supplied the [sqlite3_value*] parameters.
**
** As long as the input parameter is correct, these routines can only
** fail if an out-of-memory error occurs during a format conversion.
** Only the following subset of interfaces are subject to out-of-memory

** other SQLite interface is called on the same [database connection].
**
** The previous paragraph does not apply to the text_v2 and blob_v2
** interfaces, which return SQLITE_NOMEM to the client for
** out-of-memory conditions.
*/
const void *sqlite3_value_blob(sqlite3_value*);
int sqlite3_value_blob_v2(sqlite3_value*, const void **, int*, int*);
double sqlite3_value_double(sqlite3_value*);
int sqlite3_value_int(sqlite3_value*);
sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
void *sqlite3_value_pointer(sqlite3_value*, const char*);
const unsigned char *sqlite3_value_text(sqlite3_value*);
int sqlite3_value_text_v2(sqlite3_value*, const unsigned char **, int*, int*);
const void *sqlite3_value_text16(sqlite3_value*);
const void *sqlite3_value_text16le(sqlite3_value*);
const void *sqlite3_value_text16be(sqlite3_value*);
int sqlite3_value_bytes(sqlite3_value*);
int sqlite3_value_bytes16(sqlite3_value*);
int sqlite3_value_type(sqlite3_value*);
int sqlite3_value_numeric_type(sqlite3_value*);

void sqlite3FileSuffix3(const char*, char*);
#else
# define sqlite3FileSuffix3(X,Y)
#endif
u8 sqlite3GetBoolean(const char *z,u8);

const void *sqlite3ValueText(sqlite3_value*, u8);
int sqlite3ValueTextV2(sqlite3_value*, u8, const void **, int*, int*);

int sqlite3ValueIsOfClass(const sqlite3_value*, void(*)(void*));
int sqlite3ValueBytes(sqlite3_value*, u8);
void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8,
                        void(*)(void*));
void sqlite3ValueSetNull(sqlite3_value*);
void sqlite3ValueFree(sqlite3_value*);

    Tcl_WrongNumArgs(interp, 1, objv, "STMT column");
    return TCL_ERROR;
  }

  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
  if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;

  rc = sqlite3_column_blob_v2(pStmt, col, &pBlob, &len, 0);
  if( rc ) return TCL_ERROR;
  Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(pBlob, len));
  return TCL_OK;
}

/*
** Usage: sqlite3_column_double STMT column

  if( objc!=3 ){
    Tcl_WrongNumArgs(interp, 1, objv, "STMT column");
    return TCL_ERROR;
  }

  if( getStmtPointer(interp, Tcl_GetString(objv[1]), &pStmt) ) return TCL_ERROR;
  if( Tcl_GetIntFromObj(interp, objv[2], &col) ) return TCL_ERROR;
  if( sqlite3_column_text_v2(pStmt, col, &zRet, &len, 0) ){
    return TCL_ERROR;
  }
  if( zRet ){
    Tcl_SetResult(interp, (char *)zRet, 0);
  }
  return TCL_OK;
}

    }
    p->flags |= MEM_Blob;
    return p->n ? p->z : 0;
  }else{
    return sqlite3_value_text(pVal);
  }
}
int sqlite3_value_blob_v2(sqlite3_value *pVal, const void **pOut,
                          int *pnOut, int *pType){
  Mem *p = (Mem*)pVal;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( pVal==0 || pOut==0 ) return SQLITE_MISUSE_BKPT;
#endif
  if( p->flags & (MEM_Blob|MEM_Str) ){
    if( ExpandBlob(p)!=SQLITE_OK ){
      assert( p->flags==MEM_Null && p->z==0 );
      return SQLITE_NOMEM_BKPT;
    }
    p->flags |= MEM_Blob;
    *pOut = p->n ? p->z : 0;
    if( pnOut ) *pnOut = p->n;
    if( pType ) *pType = sqlite3_value_type(pVal);
    return 0;
  }
  return sqlite3_value_text_v2(pVal, (const unsigned char **)pOut,
                               pnOut, pType);
}
int sqlite3_value_bytes(sqlite3_value *pVal){
  return sqlite3ValueBytes(pVal, SQLITE_UTF8);
}
int sqlite3_value_bytes16(sqlite3_value *pVal){
  return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
}

  }else{
    return 0;
  }
}
const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
  return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
}
int sqlite3_value_text_v2(sqlite3_value *pVal,
                          const unsigned char **pOut,
                          int *pnOut, int *pType){
  int n = 0;
#ifdef SQLITE_ENABLE_API_ARMOR
  if( pVal==0 || pOut==0 ) return SQLITE_MISUSE_BKPT;
#endif
  return sqlite3ValueTextV2(pVal, SQLITE_UTF8, (const void **)pOut,
                            pnOut ? pnOut : &n, pType);
}
#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);

**
** If bBlob is true, sqlite3_value_blob_v2() is used for the
** extraction, else sqlite3_value_text_v2() is used.
**
** This is expected to only be called by sqlite3_column_blob_v2(),
** sqlite3_column_text_v2(), or APIs with similar semantics.
**
** Design notes: per /chat discussion:
**
** sqlite3_column_text/blob_v2() can report SQLITE_RANGE and
** SQLITE_MISUSE, but must not perist those errors and must not take
** prior error state into account (e.g. do not propagate a
** SQLITE_RANGE error across calls). They unavoidably persist
** SQLITE_NOMEM errors via deeper APIs. This routine specifically does
** not call columnMallocFailure() to avoid calling sqlite3ApiExit().
*/
static int columnMemV2(sqlite3_stmt *pStmt, int iCol, int bBlob,
                       const void **pOut, int * pnOut, int *pType){
  int rc = 0;
  Vdbe * const pVm = (Vdbe*)pStmt;

#ifdef SQLITE_ENABLE_API_ARMOR
  if( pVm==0 || pOut==0 ) return SQLITE_MISUSE_BKPT;
#endif
  assert( pVm->db );
  sqlite3_mutex_enter(pVm->db->mutex);
  if( pVm->pResultRow!=0 && iCol<pVm->nResColumn && iCol>=0 ){
    Mem * const pMem = &pVm->pResultRow[iCol];
    rc = bBlob
      ? sqlite3_value_blob_v2(pMem, pOut, pnOut, pType)
      : sqlite3_value_text_v2(pMem, (const unsigned char **)pOut,
                              pnOut, pType);
  }else{
    rc = pVm->pResultRow==0 ? SQLITE_MISUSE_BKPT : SQLITE_RANGE;
  }
  sqlite3_mutex_leave(pVm->db->mutex);
  return rc;
}

  ** need to call malloc() to expand the result of a zeroblob()
  ** expression.
  */
  columnMallocFailure(pStmt);
  return val;
}
int sqlite3_column_blob_v2(sqlite3_stmt *pStmt, int iCol,
                           const void **pOut, int *pnOut, int *pType){
  return columnMemV2(pStmt, iCol, 1, pOut, pnOut, pType);
}
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){

}
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;
}
int sqlite3_column_text_v2(sqlite3_stmt *pStmt, int iCol,
                           const unsigned char **pOut, int *pnOut,
                           int *pType){
  return columnMemV2(pStmt, iCol, 0, (const void **)pOut, pnOut, pType);
}
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;
  }

  }
}

/*
** This works like valueToText() but returns its result using
** different semantics. On success, return 0, set *pOut to a
** zero-terminated version of that string, and set *pnOut (which must
** not be NULL to the string-length of that memory. If pType is not
** NULL, it will be set to the sqlite3_value_type() of pVal.
**
** On error, return non-0 and do not modify pOut, pnOut, or pType.
**
** Maintenance note: this is almost a copy/paste clone of
** valueToText(), but the two should probably not be consolidated. The
** initial version of this API did so in [730c6a623e29b59b] and the
** CPU cycles doubled.
*/
static SQLITE_NOINLINE int valueToTextV2(sqlite3_value* pVal, u8 enc,
                                         const void **pOut, int *pnOut,
                                         int *pType){
  assert( pVal!=0 );
  assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
  assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
  assert( !sqlite3VdbeMemIsRowSet(pVal) );
  assert( (pVal->flags & (MEM_Null))==0 );
  assert( pOut!=0 );
  assert( pnOut!=0 );

  }
  assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
              || pVal->db->mallocFailed );
  if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
    assert( sqlite3VdbeMemValidStrRep(pVal) );
    *pOut = pVal->z;
    *pnOut = pVal->n;
    if( pType ) *pType = sqlite3_value_type(pVal);
    return 0;
  }
  return (pVal->db && pVal->db->mallocFailed)
    ? SQLITE_NOMEM_BKPT
    : SQLITE_ERROR;
}

}

/* This works similarly to sqlite3ValueText() but returns its result
** with different semantics.
**
** On success, returns 0, sets *pOut to the underlying value (or NULL
** in the case of NULL), and sets *pnOut to the memory's usable
** length. If *pType is not NULL, it is set to the
** sqlite3_value_type() of pVal. On error, neither *pOut nor *pnOut
** nor *pType are modified.
**
** Results are undefined if pVal, pOut, or pnOut are NULL. pType may
** be NULL.
*/
int sqlite3ValueTextV2(sqlite3_value* pVal, u8 enc, const void **pOut,
                       int *pnOut, int *pType){
  /*if( !pVal ) return SQLITE_MISUSE_BKPT;*/
  assert( pVal!=0 );
  assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
  assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
  assert( !sqlite3VdbeMemIsRowSet(pVal) );
  assert( pOut!=0 );
  assert( pnOut!=0 );
  if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
    assert( sqlite3VdbeMemValidStrRep(pVal) );
    *pOut = pVal->z;
    *pnOut = pVal->n;
    if( pType ) *pType = sqlite3_value_type( pVal );
    return 0;
  }
  if( pVal->flags&MEM_Null ){
    *pOut = 0;
    *pnOut = 0;
    if( pType ) *pType = sqlite3_value_type( pVal );
    return 0;
  }
  return valueToTextV2(pVal, enc, pOut, pnOut, pType);
}

/* Return true if sqlit3_value object pVal is a string or blob value
** that uses the destructor specified in the second argument.
**
** TODO:  Maybe someday promote this interface into a published API so
** that third-party extensions can get access to it?