自学教程：C++ sqlite3VdbeMemSetStr函数代码示例

/*** Bind a text or BLOB value.*/static int bindText(  sqlite3_stmt *pStmt,   int i,   const void *zData,   int nData,   void (*xDel)(void*),  int encoding){  Vdbe *p = (Vdbe *)pStmt;  Mem *pVar;  int rc;  rc = vdbeUnbind(p, i);  if( rc || zData==0 ){    return rc;  }  pVar = &p->aVar[i-1];  rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);  if( rc==SQLITE_OK && encoding!=0 ){    rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));  }  sqlite3Error(((Vdbe *)pStmt)->db, rc, 0);  return sqlite3ApiExit(((Vdbe *)pStmt)->db, rc);}

void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){  pCtx->isError = errCode;  if( pCtx->s.flags & MEM_Null ){    sqlite3VdbeMemSetStr(&pCtx->s, sqlite3ErrStr(errCode), -1,                          SQLITE_UTF8, SQLITE_STATIC);  }}

/*** 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 */  int 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, i);  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));      }      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;}

/* 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;  pCtx->fErrorOrAux = 1;  sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1,                        SQLITE_UTF8, SQLITE_STATIC);}

/*** Create a new sqlite3_value object, containing the value of pExpr.**** This only works for very simple expressions that consist of one constant** token (i.e. "5", "5.1", "'a string'"). If the expression can** be converted directly into a value, then the value is allocated and** a pointer written to *ppVal. The caller is responsible for deallocating** the value by passing it to sqlite3ValueFree() later on. If the expression** cannot be converted to a value, then *ppVal is set to NULL.*/int sqlite3ValueFromExpr(  sqlite3 *db,              /* The database connection */  Expr *pExpr,              /* The expression to evaluate */  u8 enc,                   /* Encoding to use */  u8 affinity,              /* Affinity to use */  sqlite3_value **ppVal     /* Write the new value here */){  int op;  char *zVal = 0;  sqlite3_value *pVal = 0;  if( !pExpr ){    *ppVal = 0;    return SQLITE_OK;  }  op = pExpr->op;  if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){    zVal = sqlite3DbStrNDup(db, (char*)pExpr->token.z, pExpr->token.n);    pVal = sqlite3ValueNew(db);    if( !zVal || !pVal ) goto no_mem;    sqlite3Dequote(zVal);    sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);    if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){      sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, enc);    }else{      sqlite3ValueApplyAffinity(pVal, affinity, enc);    }  }else if( op==TK_UMINUS ) {    if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){      pVal->u.i = -1 * pVal->u.i;      pVal->r = -1.0 * pVal->r;    }  }#ifndef SQLITE_OMIT_BLOB_LITERAL  else if( op==TK_BLOB ){    int nVal;    assert( pExpr->token.n>=3 );    assert( pExpr->token.z[0]=='x' || pExpr->token.z[0]=='X' );    assert( pExpr->token.z[1]=='/'' );    assert( pExpr->token.z[pExpr->token.n-1]=='/'' );    pVal = sqlite3ValueNew(db);    if( !pVal ) goto no_mem;    nVal = pExpr->token.n - 3;    zVal = (char*)pExpr->token.z + 2;    sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,                         0, SQLITE_DYNAMIC);  }#endif  *ppVal = pVal;  return SQLITE_OK;no_mem:  db->mallocFailed = 1;  sqlite3DbFree(db, zVal);  sqlite3ValueFree(pVal);  *ppVal = 0;  return SQLITE_NOMEM;}

void sqlite3_result_text16le(  sqlite3_context *pCtx,   const void *z,   int n,   void (*xDel)(void *)){  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16LE, xDel);}

void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){  pCtx->isError = errCode;  pCtx->fErrorOrAux = 1;  if( pCtx->pOut->flags & MEM_Null ){    sqlite3VdbeMemSetStr(pCtx->pOut, sqlite3ErrStr(errCode), -1,                          SQLITE_UTF8, SQLITE_STATIC);  }}

void sqlite3_result_text(  sqlite3_context *pCtx,   const char *z,   int n,  void (*xDel)(void *)){  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, xDel);}

/*** Set the name of the idx'th column to be returned by the SQL statement.** zName must be a pointer to a nul terminated string.**** This call must be made after a call to sqlite3VdbeSetNumCols().**** If N==P3_STATIC  it means that zName is a pointer to a constant static** string and we can just copy the pointer. If it is P3_DYNAMIC, then ** the string is freed using sqliteFree() when the vdbe is finished with** it. Otherwise, N bytes of zName are copied.*/int sqlite3VdbeSetColName(Vdbe *p, int idx, const char *zName, int N){  int rc;  Mem *pColName;  assert( idx<(2*p->nResColumn) );  if( sqlite3_malloc_failed ) return SQLITE_NOMEM;  assert( p->aColName!=0 );  pColName = &(p->aColName[idx]);  if( N==P3_DYNAMIC || N==P3_STATIC ){    rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, SQLITE_STATIC);  }else{    rc = sqlite3VdbeMemSetStr(pColName, zName, N, SQLITE_UTF8,SQLITE_TRANSIENT);  }  if( rc==SQLITE_OK && N==P3_DYNAMIC ){    pColName->flags = (pColName->flags&(~MEM_Static))|MEM_Dyn;    pColName->xDel = 0;  }  return rc;}

void sqlite3_result_text16le(  sqlite3_context *pCtx,   const void *z,   int n,   void (*xDel)(void *)){  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16LE, xDel);}

/*** Change the string value of an sqlite3_value object*/void sqlite3ValueSetStr(    sqlite3_value *v,    int n,    const void *z,    u8 enc,    void (*xDel)(void*)) {    if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);}

/**************************** sqlite3_result_  ********************************* The following routines are used by user-defined functions to specify** the function result.*/void sqlite3_result_blob(  sqlite3_context *pCtx,   const void *z,   int n,   void (*xDel)(void *)){  assert( n>=0 );  sqlite3VdbeMemSetStr(&pCtx->s, z, n, 0, xDel);}

/*** Convert a UTF-16 string in the native encoding into a UTF-8 string.** Memory to hold the UTF-8 string is obtained from malloc and must be** freed by the calling function.**** NULL is returned if there is an allocation error.*/char *sqlite3utf16to8(const void *z, int nByte){  Mem m;  memset(&m, 0, sizeof(m));  sqlite3VdbeMemSetStr(&m, z, nByte, SQLITE_UTF16NATIVE, SQLITE_STATIC);  sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8);  assert( (m.flags & MEM_Term)!=0 || sqlite3MallocFailed() );  assert( (m.flags & MEM_Str)!=0 || sqlite3MallocFailed() );  return (m.flags & MEM_Dyn)!=0 ? m.z : sqliteStrDup(m.z);}

/*** Change the string value of an sqlite3_value object*/void sqlite3ValueSetStr(  sqlite3_value *v,     /* Value to be set */  int n,                /* Length of string z */  const void *z,        /* Text of the new string */  u8 enc,               /* Encoding to use */  void (*xDel)(void*)   /* Destructor for the string */){  if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);}

/*** Create a new sqlite3_value object, containing the value of pExpr.**** This only works for very simple expressions that consist of one constant** token (i.e. "5", "5.1", "NULL", "'a string'"). If the expression can** be converted directly into a value, then the value is allocated and** a pointer written to *ppVal. The caller is responsible for deallocating** the value by passing it to sqlite3ValueFree() later on. If the expression** cannot be converted to a value, then *ppVal is set to NULL.*/int sqlite3ValueFromExpr(  Expr *pExpr,   u8 enc,   u8 affinity,  sqlite3_value **ppVal){  int op;  char *zVal = 0;  sqlite3_value *pVal = 0;  if( !pExpr ){    *ppVal = 0;    return SQLITE_OK;  }  op = pExpr->op;  if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){    zVal = sqliteStrNDup(pExpr->token.z, pExpr->token.n);    pVal = sqlite3ValueNew();    if( !zVal || !pVal ) goto no_mem;    sqlite3Dequote(zVal);    sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, sqlite3FreeX);    if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){      sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, enc);    }else{      sqlite3ValueApplyAffinity(pVal, affinity, enc);    }  }else if( op==TK_UMINUS ) {    if( SQLITE_OK==sqlite3ValueFromExpr(pExpr->pLeft, enc, affinity, &pVal) ){      pVal->i = -1 * pVal->i;      pVal->r = -1.0 * pVal->r;    }  }#ifndef SQLITE_OMIT_BLOB_LITERAL  else if( op==TK_BLOB ){    int nVal;    pVal = sqlite3ValueNew();    zVal = sqliteStrNDup(pExpr->token.z+1, pExpr->token.n-1);    if( !zVal || !pVal ) goto no_mem;    sqlite3Dequote(zVal);    nVal = strlen(zVal)/2;    sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(zVal), nVal, 0, sqlite3FreeX);    sqliteFree(zVal);  }#endif  *ppVal = pVal;  return SQLITE_OK;no_mem:  sqliteFree(zVal);  sqlite3ValueFree(pVal);  *ppVal = 0;  return SQLITE_NOMEM;}

/**************************** 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 but if the string or blob is too large, it** then sets the error code to SQLITE_TOOBIG**** 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 */){  if( sqlite3VdbeMemSetStr(pCtx->pOut, z, n, enc, xDel)==SQLITE_TOOBIG ){    sqlite3_result_error_toobig(pCtx);  }}

void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){  pCtx->isError = errCode;  pCtx->fErrorOrAux = 1;#ifdef SQLITE_DEBUG  if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;#endif  if( pCtx->pOut->flags & MEM_Null ){    sqlite3VdbeMemSetStr(pCtx->pOut, sqlite3ErrStr(errCode), -1,                          SQLITE_UTF8, SQLITE_STATIC);  }}

char *sqlite3Utf8to16(sqlite3 *db, u8 enc, char *z, int n, int *pnOut){  Mem m;  memset(&m, 0, sizeof(m));  m.db = db;  sqlite3VdbeMemSetStr(&m, z, n, SQLITE_UTF8, SQLITE_STATIC);  if( sqlite3VdbeMemTranslate(&m, enc) ){    assert( db->mallocFailed );    return 0;  }  assert( m.z==m.zMalloc );  *pnOut = m.n;  return m.z;}

/*** Convert a UTF-16 string in the native encoding into a UTF-8 string.** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must** be freed by the calling function.**** NULL is returned if there is an allocation error.*/char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte){  Mem m;  memset(&m, 0, sizeof(m));  m.db = db;  sqlite3VdbeMemSetStr(&m, z, nByte, SQLITE_UTF16NATIVE, SQLITE_STATIC);  sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8);  if( db->mallocFailed ){    sqlite3VdbeMemRelease(&m);    m.z = 0;  }  assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );  assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );  return (m.flags & MEM_Dyn)!=0 ? m.z : sqlite3DbStrDup(db, m.z);}

/*** This routine checks for a byte-order mark at the beginning of the ** UTF-16 string stored in *pMem. If one is present, it is removed and** the encoding of the Mem adjusted. This routine does not do any** byte-swapping, it just sets Mem.enc appropriately.**** The allocation (static, dynamic etc.) and encoding of the Mem may be** changed by this function.*/int sqlite3VdbeMemHandleBom(Mem *pMem){  int rc = SQLITE_OK;  u8 bom = 0;  if( pMem->n<0 || pMem->n>1 ){    u8 b1 = *(u8 *)pMem->z;    u8 b2 = *(((u8 *)pMem->z) + 1);    if( b1==0xFE && b2==0xFF ){      bom = SQLITE_UTF16BE;    }    if( b1==0xFF && b2==0xFE ){      bom = SQLITE_UTF16LE;    }  }    if( bom ){    /* This function is called as soon as a string is stored in a Mem*,    ** from within sqlite3VdbeMemSetStr(). At that point it is not possible    ** for the string to be stored in Mem.zShort, or for it to be stored    ** in dynamic memory with no destructor.    */    assert( !(pMem->flags&MEM_Short) );    assert( !(pMem->flags&MEM_Dyn) || pMem->xDel );    if( pMem->flags & MEM_Dyn ){      void (*xDel)(void*) = pMem->xDel;      char *z = pMem->z;      pMem->z = 0;      pMem->xDel = 0;      rc = sqlite3VdbeMemSetStr(pMem, &z[2], pMem->n-2, bom, SQLITE_TRANSIENT);      xDel(z);    }else{      rc = sqlite3VdbeMemSetStr(pMem, &pMem->z[2], pMem->n-2, bom,           SQLITE_TRANSIENT);    }  }  return rc;}

/*** Convert a UTF-16 string in the native encoding into a UTF-8 string.** Memory to hold the UTF-8 string is obtained from sqlite3_malloc and must** be freed by the calling function.**** NULL is returned if there is an allocation error.*/char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){  Mem m;  memset(&m, 0, sizeof(m));  m.db = db;  sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC);  sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8);  if( db->mallocFailed ){    sqlite3VdbeMemRelease(&m);    m.z = 0;  }  assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );  assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );  assert( m.z || db->mallocFailed );  return m.z;}

/*** Create a new sqlite3_value object, containing the value of pExpr.**** This only works for very simple expressions that consist of one constant** token (i.e. "5", "5.1", "'a string'"). If the expression can** be converted directly into a value, then the value is allocated and** a pointer written to *ppVal. The caller is responsible for deallocating** the value by passing it to sqlite3ValueFree() later on. If the expression** cannot be converted to a value, then *ppVal is set to NULL.*/int sqlite3ValueFromExpr(  sqlite3 *db,              /* The database connection */  Expr *pExpr,              /* The expression to evaluate */  u8 enc,                   /* Encoding to use */  u8 affinity,              /* Affinity to use */  sqlite3_value **ppVal     /* Write the new value here */){  int op;  char *zVal = 0;  sqlite3_value *pVal = 0;  if( !pExpr ){    *ppVal = 0;    return SQLITE_OK;  }  op = pExpr->op;  if( op==TK_REGISTER ){    op = pExpr->op2;  }  if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){    pVal = sqlite3ValueNew(db);    if( pVal==0 ) goto no_mem;    if( ExprHasProperty(pExpr, EP_IntValue) ){      sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue);    }else{      zVal = sqlite3DbStrDup(db, pExpr->u.zToken);      if( zVal==0 ) goto no_mem;      sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);      if( op==TK_FLOAT ) pVal->type = SQLITE_FLOAT;    }    if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){      sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);    }else{      sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);    }    if( enc!=SQLITE_UTF8 ){      sqlite3VdbeChangeEncoding(pVal, enc);    }  }else if( op==TK_UMINUS ) {    if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){      pVal->u.i = -1 * pVal->u.i;      /* (double)-1 In case of SQLITE_OMIT_FLOATING_POINT... */      pVal->r = (double)-1 * pVal->r;    }  }#ifndef SQLITE_OMIT_BLOB_LITERAL  else if( op==TK_BLOB ){    int nVal;    assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );    assert( pExpr->u.zToken[1]=='/'' );    pVal = sqlite3ValueNew(db);    if( !pVal ) goto no_mem;    zVal = &pExpr->u.zToken[2];    nVal = sqlite3Strlen30(zVal)-1;    assert( zVal[nVal]=='/'' );    sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,                         0, SQLITE_DYNAMIC);  }#endif  *ppVal = pVal;  return SQLITE_OK;no_mem:  db->mallocFailed = 1;  sqlite3DbFree(db, zVal);  sqlite3ValueFree(pVal);  *ppVal = 0;  return SQLITE_NOMEM;}

void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){  assert( sqlite3_mutex_held(pCtx->s.db->mutex) );  pCtx->isError = SQLITE_ERROR;  pCtx->fErrorOrAux = 1;  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);}

void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );  pCtx->isError = SQLITE_ERROR;  pCtx->fErrorOrAux = 1;  sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);}

/*** Create a new sqlite3_value object, containing the value of pExpr.**** This only works for very simple expressions that consist of one constant** token (i.e. "5", "5.1", "'a string'"). If the expression can** be converted directly into a value, then the value is allocated and** a pointer written to *ppVal. The caller is responsible for deallocating** the value by passing it to sqlite3ValueFree() later on. If the expression** cannot be converted to a value, then *ppVal is set to NULL.*/int sqlite3ValueFromExpr(  sqlite3 *db,              /* The database connection */  Expr *pExpr,              /* The expression to evaluate */  u8 enc,                   /* Encoding to use */  u8 affinity,              /* Affinity to use */  sqlite3_value **ppVal     /* Write the new value here */){  int op;  char *zVal = 0;  sqlite3_value *pVal = 0;  int negInt = 1;  const char *zNeg = "";  if( !pExpr ){    *ppVal = 0;    return SQLITE_OK;  }  op = pExpr->op;  /* op can only be TK_REGISTER if we have compiled with SQLITE_ENABLE_STAT3.  ** The ifdef here is to enable us to achieve 100% branch test coverage even  ** when SQLITE_ENABLE_STAT3 is omitted.  */#ifdef SQLITE_ENABLE_STAT3  if( op==TK_REGISTER ) op = pExpr->op2;#else  if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;#endif  /* Handle negative integers in a single step.  This is needed in the  ** case when the value is -9223372036854775808.  */  if( op==TK_UMINUS   && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){    pExpr = pExpr->pLeft;    op = pExpr->op;    negInt = -1;    zNeg = "-";  }  if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){    pVal = sqlite3ValueNew(db);    if( pVal==0 ) goto no_mem;    if( ExprHasProperty(pExpr, EP_IntValue) ){      sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);    }else{      zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);      if( zVal==0 ) goto no_mem;      sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);      if( op==TK_FLOAT ) pVal->type = SQLITE_FLOAT;    }    if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){      sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);    }else{      sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);    }    if( pVal->flags & (MEM_Int|MEM_Real) ) pVal->flags &= ~MEM_Str;    if( enc!=SQLITE_UTF8 ){      sqlite3VdbeChangeEncoding(pVal, enc);    }  }else if( op==TK_UMINUS ) {    /* This branch happens for multiple negative signs.  Ex: -(-5) */    if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){      sqlite3VdbeMemNumerify(pVal);      if( pVal->u.i==SMALLEST_INT64 ){        pVal->flags &= MEM_Int;        pVal->flags |= MEM_Real;        pVal->r = (double)LARGEST_INT64;      }else{        pVal->u.i = -pVal->u.i;      }      pVal->r = -pVal->r;      sqlite3ValueApplyAffinity(pVal, affinity, enc);    }  }else if( op==TK_NULL ){    pVal = sqlite3ValueNew(db);    if( pVal==0 ) goto no_mem;  }#ifndef SQLITE_OMIT_BLOB_LITERAL  else if( op==TK_BLOB ){    int nVal;    assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );    assert( pExpr->u.zToken[1]=='/'' );    pVal = sqlite3ValueNew(db);    if( !pVal ) goto no_mem;    zVal = &pExpr->u.zToken[2];    nVal = sqlite3Strlen30(zVal)-1;    assert( zVal[nVal]=='/'' );    sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,                         0, SQLITE_DYNAMIC);//.........这里部分代码省略.........

void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){  pCtx->isError = 1;  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);}

void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){  pCtx->isError = 1;  sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);}

/*** This function returns a pointer to a nul-terminated string in memory** obtained from sqlite3DbMalloc(). If sqlite3.vdbeExecCnt is 1, then the** string contains a copy of zRawSql but with host parameters expanded to ** their current bindings. Or, if sqlite3.vdbeExecCnt is greater than 1, ** then the returned string holds a copy of zRawSql with "-- " prepended** to each line of text.**** The calling function is responsible for making sure the memory returned** is eventually freed.**** ALGORITHM:  Scan the input string looking for host parameters in any of** these forms:  ?, ?N, $A, @A, :A.  Take care to avoid text within** string literals, quoted identifier names, and comments.  For text forms,** the host parameter index is found by scanning the perpared** statement for the corresponding OP_Variable opcode.  Once the host** parameter index is known, locate the value in p->aVar[].  Then render** the value as a literal in place of the host parameter name.*/char *sqlite3VdbeExpandSql(  Vdbe *p,                 /* The prepared statement being evaluated */  const char *zRawSql      /* Raw text of the SQL statement */){  sqlite3 *db;             /* The database connection */  int idx = 0;             /* Index of a host parameter */  int nextIndex = 1;       /* Index of next ? host parameter */  int n;                   /* Length of a token prefix */  int nToken;              /* Length of the parameter token */  int i;                   /* Loop counter */  Mem *pVar;               /* Value of a host parameter */  StrAccum out;            /* Accumulate the output here */  char zBase[100];         /* Initial working space */  db = p->db;  sqlite3StrAccumInit(&out, zBase, sizeof(zBase),                       db->aLimit[SQLITE_LIMIT_LENGTH]);  out.db = db;  if( db->vdbeExecCnt>1 ){    while( *zRawSql ){      const char *zStart = zRawSql;      while( *(zRawSql++)!='/n' && *zRawSql );      sqlite3StrAccumAppend(&out, "-- ", 3);      sqlite3StrAccumAppend(&out, zStart, (int)(zRawSql-zStart));    }  }else{    while( zRawSql[0] ){      n = findNextHostParameter(zRawSql, &nToken);      assert( n>0 );      sqlite3StrAccumAppend(&out, zRawSql, n);      zRawSql += n;      assert( zRawSql[0] || nToken==0 );      if( nToken==0 ) break;      if( zRawSql[0]=='?' ){        if( nToken>1 ){          assert( sqlite3Isdigit(zRawSql[1]) );          sqlite3GetInt32(&zRawSql[1], &idx);        }else{          idx = nextIndex;        }      }else{        assert( zRawSql[0]==':' || zRawSql[0]=='$' || zRawSql[0]=='@' );        testcase( zRawSql[0]==':' );        testcase( zRawSql[0]=='$' );        testcase( zRawSql[0]=='@' );        idx = sqlite3VdbeParameterIndex(p, zRawSql, nToken);        assert( idx>0 );      }      zRawSql += nToken;      nextIndex = idx + 1;      assert( idx>0 && idx<=p->nVar );      pVar = &p->aVar[idx-1];      if( pVar->flags & MEM_Null ){        sqlite3StrAccumAppend(&out, "NULL", 4);      }else if( pVar->flags & MEM_Int ){        sqlite3XPrintf(&out, "%lld", pVar->u.i);      }else if( pVar->flags & MEM_Real ){        sqlite3XPrintf(&out, "%!.15g", pVar->r);      }else if( pVar->flags & MEM_Str ){#ifndef SQLITE_OMIT_UTF16        u8 enc = ENC(db);        if( enc!=SQLITE_UTF8 ){          Mem utf8;          memset(&utf8, 0, sizeof(utf8));          utf8.db = db;          sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC);          sqlite3VdbeChangeEncoding(&utf8, SQLITE_UTF8);          sqlite3XPrintf(&out, "'%.*q'", utf8.n, utf8.z);          sqlite3VdbeMemRelease(&utf8);        }else#endif        {          sqlite3XPrintf(&out, "'%.*q'", pVar->n, pVar->z);        }      }else if( pVar->flags & MEM_Zero ){        sqlite3XPrintf(&out, "zeroblob(%d)", pVar->u.nZero);      }else{        assert( pVar->flags & MEM_Blob );        sqlite3StrAccumAppend(&out, "x'", 2);        for(i=0; i<pVar->n; i++){          sqlite3XPrintf(&out, "%02x", pVar->z[i]&0xff);//.........这里部分代码省略.........