contrib/sqlite3/sqlite3.c

14043 **       pVal    where to write the integers value.
14055   int *pVal;
14063     pVal = va_arg(ap, int*);
14075     *pVal = val;
59745 SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
59746   if( !pVal ) return 0;
59748   assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
59750   assert( (pVal->flags & MEM_RowSet)==0 );
59752   if( pVal->flags&MEM_Null ){
59756   pVal->flags |= (pVal->flags & MEM_Blob)>>3;
59757   ExpandBlob(pVal);
59758   if( pVal->flags&MEM_Str ){
59759     sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
59760     if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
59761       assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
59762       if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
59766     sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */
59768     assert( (pVal->flags&MEM_Blob)==0 );
59769     sqlite3VdbeMemStringify(pVal, enc);
59770     assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
59772   assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
59773               || pVal->db->mallocFailed );
59774   if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
59775     return pVal->z;
59813   sqlite3_value *pVal = 0;
59845     pVal = sqlite3ValueNew(db);
59846     if( pVal==0 ) goto no_mem;
59848       sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
59852       sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
59853       if( op==TK_FLOAT ) pVal->type = SQLITE_FLOAT;
59856       sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);
59858       sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
59860     if( pVal->flags & (MEM_Int|MEM_Real) ) pVal->flags &= ~MEM_Str;
59862       sqlite3VdbeChangeEncoding(pVal, enc);
59866     if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){
59867       sqlite3VdbeMemNumerify(pVal);
59868       if( pVal->u.i==SMALLEST_INT64 ){
59869         pVal->flags &= MEM_Int;
59870         pVal->flags |= MEM_Real;
59871         pVal->r = (double)LARGEST_INT64;
59873         pVal->u.i = -pVal->u.i;
59875       pVal->r = -pVal->r;
59876       sqlite3ValueApplyAffinity(pVal, affinity, enc);
59879     pVal = sqlite3ValueNew(db);
59880     if( pVal==0 ) goto no_mem;
59887     pVal = sqlite3ValueNew(db);
59888     if( !pVal ) goto no_mem;
59892     sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
59897   if( pVal ){
59898     sqlite3VdbeMemStoreType(pVal);
59900   *ppVal = pVal;
59906   sqlite3ValueFree(pVal);
59937 SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
59938   Mem *p = (Mem*)pVal;
59939   if( (p->flags & MEM_Blob)!=0 || sqlite3ValueText(pVal, enc) ){
63334 SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){
63335   Mem *p = (Mem*)pVal;
63342     return sqlite3_value_text(pVal);
63345 SQLITE_API int sqlite3_value_bytes(sqlite3_value *pVal){
63346   return sqlite3ValueBytes(pVal, SQLITE_UTF8);
63348 SQLITE_API int sqlite3_value_bytes16(sqlite3_value *pVal){
63349   return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
63351 SQLITE_API double sqlite3_value_double(sqlite3_value *pVal){
63352   return sqlite3VdbeRealValue((Mem*)pVal);
63354 SQLITE_API int sqlite3_value_int(sqlite3_value *pVal){
63355   return (int)sqlite3VdbeIntValue((Mem*)pVal);
63357 SQLITE_API sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
63358   return sqlite3VdbeIntValue((Mem*)pVal);
63360 SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
63361   return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
63364 SQLITE_API const void *sqlite3_value_text16(sqlite3_value* pVal){
63365   return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
63367 SQLITE_API const void *sqlite3_value_text16be(sqlite3_value *pVal){
63368   return sqlite3ValueText(pVal, SQLITE_UTF16BE);
63370 SQLITE_API const void *sqlite3_value_text16le(sqlite3_value *pVal){
63371   return sqlite3ValueText(pVal, SQLITE_UTF16LE);
63374 SQLITE_API int sqlite3_value_type(sqlite3_value* pVal){
63375   return pVal->type;
65111 SQLITE_API int sqlite3_value_numeric_type(sqlite3_value *pVal){
65112   Mem *pMem = (Mem*)pVal;
65125   sqlite3_value *pVal,
65129   applyAffinity((Mem *)pVal, affinity, enc);
72320   void *pVal;
72728   void *pVal2 = p2 ? p2->pVal : 0;
72732     vdbeSorterCompare(pCsr, 0, p1->pVal, p1->nVal, pVal2, p2->nVal, &res);
72743       pVal2 = p2->pVal;
72919       fileWriterWrite(&writer, p->pVal, p->nVal);
72935   Mem *pVal                       /* Memory cell containing record */
72942   pSorter->nInMemory += sqlite3VarintLen(pVal->n) + pVal->n;
72944   pNew = (SorterRecord *)sqlite3DbMallocRaw(db, pVal->n + sizeof(SorterRecord));
72948     pNew->pVal = (void *)&pNew[1];
72949     memcpy(pNew->pVal, pVal->z, pVal->n);
72950     pNew->nVal = pVal->n;
73166     pKey = pSorter->pRecord->pVal;
73190 ** Compare the key in memory cell pVal with the key that the sorter cursor
73196 ** key in pVal is smaller than, equal to or larger than the current sorter
73201   Mem *pVal,                      /* Value to compare to current sorter key */
73205   void *pKey; int nKey;           /* Sorter key to compare pVal with */
73208   vdbeSorterCompare(pCsr, 1, pVal->z, pVal->n, pKey, nKey, pRes);
80105     sqlite3_value *pVal;
80106     if( sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_NONE, &pVal) ){
80110     if( !pVal ){
80114     sqlite3ValueFree(pVal);
105153   sqlite3_value *pVal = 0;
105182     pVal = sqlite3VdbeGetValue(pReprepare, iCol, SQLITE_AFF_NONE);
105183     if( pVal && sqlite3_value_type(pVal)==SQLITE_TEXT ){
105184       z = (char *)sqlite3_value_text(pVal);
105223   sqlite3ValueFree(pVal);
106830 **    aStat[0]      Est. number of rows less than pVal
106831 **    aStat[1]      Est. number of rows equal to pVal
106838   sqlite3_value *pVal,        /* Value to consider */
106851   if( pVal==0 ) return SQLITE_ERROR;
106854   eType = sqlite3_value_type(pVal);
106857     v = sqlite3_value_int64(pVal);
106876     r = sqlite3_value_double(pVal);
106905         z = (const u8 *)sqlite3_value_blob(pVal);
106913         z = (const u8 *)sqlite3ValueText(pVal, pColl->enc);
106919       n = sqlite3ValueBytes(pVal, pColl->enc);
106952   ** or equal to pVal.  Or if i==pIdx->nSample, then all samples are less
106953   ** than pVal.  If aSample[i]==pVal, then isEq==1.
114671   sqlite3_value *pVal;
114679   pVal = sqlite3ValueNew(0);
114680   sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
114681   zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
114687   sqlite3ValueFree(pVal);
117430   sqlite3_value *pVal;
117440   pVal = sqlite3ValueNew(0);
117441   sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
117442   zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
117453   sqlite3ValueFree(pVal);
119710 ** to *pVal.
119712 static void fts3GetDeltaVarint(char **pp, sqlite3_int64 *pVal){
119715   *pVal += iVal;
119722 ** and sets *pVal by the varint value.
119730   sqlite3_int64 *pVal
119743   *pVal = iVal;
121493 ** If bDescIdx is false, the value read is added to *pVal before returning.
121494 ** If it is true, the value read is subtracted from *pVal before this
121501   sqlite3_int64 *pVal             /* IN/OUT: Integer value */
121509       *pVal -= iVal;
121511       *pVal += iVal;
122531   sqlite3_value *pVal,            /* argv[0] passed to function */
122535   if( sqlite3_value_type(pVal)!=SQLITE_BLOB
122536    || sqlite3_value_bytes(pVal)!=sizeof(Fts3Cursor *)
122543   memcpy(&pRet, sqlite3_value_blob(pVal), sizeof(Fts3Cursor *));
133656 ** Argument pVal contains the result of <expr>. Currently the only
133659 static int fts3SpecialInsert(Fts3Table *p, sqlite3_value *pVal){
133661   const char *zVal = (const char *)sqlite3_value_text(pVal);
133662   int nVal = sqlite3_value_bytes(pVal);