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

/*** Set the most recent error code and error string for the sqlite** handle "db". The error code is set to "err_code".**** If it is not NULL, string zFormat specifies the format of the** error string in the style of the printf functions: The following** format characters are allowed:****      %s      Insert a string**      %z      A string that should be freed after use**      %d      Insert an integer**      %T      Insert a token**      %S      Insert the first element of a SrcList**** zFormat and any string tokens that follow it are assumed to be** encoded in UTF-8.**** To clear the most recent error for sqlite handle "db", sqlite3Error** should be called with err_code set to SQLITE_OK and zFormat set** to NULL.*/void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){  if( db && (db->pErr || (db->pErr = sqlite3ValueNew())) ){    db->errCode = err_code;    if( zFormat ){      char *z;      va_list ap;      va_start(ap, zFormat);      z = sqlite3VMPrintf(zFormat, ap);      va_end(ap);      sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, sqlite3FreeX);    }else{      sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);    }  }}

/*** Open a new database handle.*/EXPORT_C int sqlite3_open16(  const void *zFilename,   sqlite3 **ppDb){  char const *zFilename8;   /* zFilename encoded in UTF-8 instead of UTF-16 */  sqlite3_value *pVal;  int rc = SQLITE_NOMEM;  assert( zFilename );  assert( ppDb );  *ppDb = 0;  pVal = sqlite3ValueNew(0);  sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);  zFilename8 = (const char*)sqlite3ValueText(pVal, SQLITE_UTF8);  if( zFilename8 ){    rc = openDatabase(zFilename8, ppDb,                      SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);    if( rc==SQLITE_OK && *ppDb ){      rc = sqlite3_exec(*ppDb, "PRAGMA encoding = 'UTF-16'", 0, 0, 0);      if( rc!=SQLITE_OK ){        sqlite3_close(*ppDb);        *ppDb = 0;      }    }  }  sqlite3ValueFree(pVal);  return sqlite3ApiExit(0, rc);}

/*** 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;}

/*** 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;}

/*** Set the most recent error code and error string for the sqlite** handle "db". The error code is set to "err_code".**** If it is not NULL, string zFormat specifies the format of the** error string in the style of the printf functions: The following** format characters are allowed:****      %s      Insert a string**      %z      A string that should be freed after use**      %d      Insert an integer**      %T      Insert a token**      %S      Insert the first element of a SrcList**** zFormat and any string tokens that follow it are assumed to be** encoded in UTF-8.**** To clear the most recent error for sqlite handle "db", sqlite3Error** should be called with err_code set to SQLITE_OK and zFormat set** to NULL.*/void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){  assert( db!=0 );  db->errCode = err_code;  if( zFormat && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){    char *z;    va_list ap;    va_start(ap, zFormat);    z = sqlite3VMPrintf(db, zFormat, ap);    va_end(ap);    sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);  }else if( db->pErr ){    sqlite3ValueSetNull(db->pErr);  }}

/*** This routine is the same as the sqlite3_complete() routine described** above, except that the parameter is required to be UTF-16 encoded, not** UTF-8.*/int sqlite3_complete16(const void *zSql){  sqlite3_value *pVal;  char const *zSql8;  int rc = 0;  pVal = sqlite3ValueNew();  sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);  zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);  if( zSql8 ){    rc = sqlite3_complete(zSql8);  }  sqlite3ValueFree(pVal);  return rc;}

/*** Invoke the 'collation needed' callback to request a collation sequence** in the database text encoding of name zName, length nName.** If the collation sequence*/static void callCollNeeded(sqlite3 *db, const char *zName, int nName){  assert( !db->xCollNeeded || !db->xCollNeeded16 );  if( nName<0 ) nName = strlen(zName);  if( db->xCollNeeded ){    char *zExternal = sqliteStrNDup(zName, nName);    if( !zExternal ) return;    db->xCollNeeded(db->pCollNeededArg, db, (int)db->enc, zExternal);    sqliteFree(zExternal);  }#ifndef SQLITE_OMIT_UTF16  if( db->xCollNeeded16 ){    char const *zExternal;    sqlite3_value *pTmp = sqlite3GetTransientValue(db);    sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);    zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE);    if( !zExternal ) return;    db->xCollNeeded16(db->pCollNeededArg, db, (int)db->enc, zExternal);  }#endif}

/*** This routine is the same as the sqlite3_complete() routine described** above, except that the parameter is required to be UTF-16 encoded, not** UTF-8.*/int sqlite3_complete16(const void *zSql){  sqlite3_value *pVal;  char const *zSql8;  int rc = SQLITE_NOMEM;#ifndef SQLITE_OMIT_AUTOINIT  rc = sqlite3_initialize();  if( rc ) return rc;#endif  pVal = sqlite3ValueNew(0);  sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);  zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);  if( zSql8 ){    rc = sqlite3_complete(zSql8);  }else{    rc = SQLITE_NOMEM;  }  sqlite3ValueFree(pVal);  return sqlite3ApiExit(0, rc);}

/*** Invoke the 'collation needed' callback to request a collation sequence** in the encoding enc of name zName, length nName.*/static void callCollNeeded(sqlite3 *db, int enc, const char *zName){  assert( !db->xCollNeeded || !db->xCollNeeded16 );  if( db->xCollNeeded ){    char *zExternal = sqlite3DbStrDup(db, zName);    if( !zExternal ) return;    db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal);    sqlite3DbFree(db, zExternal);  }#ifndef SQLITE_OMIT_UTF16  if( db->xCollNeeded16 ){    char const *zExternal;    sqlite3_value *pTmp = sqlite3ValueNew(db);    sqlite3ValueSetStr(pTmp, -1, zName, SQLITE_UTF8, SQLITE_STATIC);    zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE);    if( zExternal ){      db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal);    }    sqlite3ValueFree(pTmp);  }#endif}

/*** Compile the UTF-16 encoded SQL statement zSql into a statement handle.*/int sqlite3_prepare16(  sqlite3 *db,              /* Database handle. */   const void *zSql,         /* UTF-8 encoded SQL statement. */  int nBytes,               /* Length of zSql in bytes. */  sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */  const void **pzTail       /* OUT: End of parsed string */){  /* This function currently works by first transforming the UTF-16  ** encoded string to UTF-8, then invoking sqlite3_prepare(). The  ** tricky bit is figuring out the pointer to return in *pzTail.  */  char const *zSql8 = 0;  char const *zTail8 = 0;  int rc;  sqlite3_value *pTmp;  if( sqlite3SafetyCheck(db) ){    return SQLITE_MISUSE;  }  pTmp = sqlite3GetTransientValue(db);  sqlite3ValueSetStr(pTmp, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);  zSql8 = sqlite3ValueText(pTmp, SQLITE_UTF8);  if( !zSql8 ){    sqlite3Error(db, SQLITE_NOMEM, 0);    return SQLITE_NOMEM;  }  rc = sqlite3_prepare(db, zSql8, -1, ppStmt, &zTail8);  if( zTail8 && pzTail ){    /* If sqlite3_prepare returns a tail pointer, we calculate the    ** equivalent pointer into the UTF-16 string by counting the unicode    ** characters between zSql8 and zTail8, and then returning a pointer    ** the same number of characters into the UTF-16 string.    */    int chars_parsed = sqlite3utf8CharLen(zSql8, zTail8-zSql8);    *pzTail = (u8 *)zSql + sqlite3utf16ByteLen(zSql, chars_parsed);  }   return rc;}

/*** 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;}

/*** Free an sqlite3_value object*/void sqlite3ValueFree(sqlite3_value *v){  if( !v ) return;  sqlite3ValueSetStr(v, 0, 0, SQLITE_UTF8, SQLITE_STATIC);  sqlite3_free(v);}

/*** 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);//.........这里部分代码省略.........