Annotation of embedaddon/sqlite3/src/vdbemem.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2004 May 26
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 7: ** May you do good and not evil.
! 8: ** May you find forgiveness for yourself and forgive others.
! 9: ** May you share freely, never taking more than you give.
! 10: **
! 11: *************************************************************************
! 12: **
! 13: ** This file contains code use to manipulate "Mem" structure. A "Mem"
! 14: ** stores a single value in the VDBE. Mem is an opaque structure visible
! 15: ** only within the VDBE. Interface routines refer to a Mem using the
! 16: ** name sqlite_value
! 17: */
! 18: #include "sqliteInt.h"
! 19: #include "vdbeInt.h"
! 20:
! 21: /*
! 22: ** If pMem is an object with a valid string representation, this routine
! 23: ** ensures the internal encoding for the string representation is
! 24: ** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE.
! 25: **
! 26: ** If pMem is not a string object, or the encoding of the string
! 27: ** representation is already stored using the requested encoding, then this
! 28: ** routine is a no-op.
! 29: **
! 30: ** SQLITE_OK is returned if the conversion is successful (or not required).
! 31: ** SQLITE_NOMEM may be returned if a malloc() fails during conversion
! 32: ** between formats.
! 33: */
! 34: int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
! 35: int rc;
! 36: assert( (pMem->flags&MEM_RowSet)==0 );
! 37: assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE
! 38: || desiredEnc==SQLITE_UTF16BE );
! 39: if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
! 40: return SQLITE_OK;
! 41: }
! 42: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
! 43: #ifdef SQLITE_OMIT_UTF16
! 44: return SQLITE_ERROR;
! 45: #else
! 46:
! 47: /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
! 48: ** then the encoding of the value may not have changed.
! 49: */
! 50: rc = sqlite3VdbeMemTranslate(pMem, (u8)desiredEnc);
! 51: assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
! 52: assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
! 53: assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
! 54: return rc;
! 55: #endif
! 56: }
! 57:
! 58: /*
! 59: ** Make sure pMem->z points to a writable allocation of at least
! 60: ** n bytes.
! 61: **
! 62: ** If the memory cell currently contains string or blob data
! 63: ** and the third argument passed to this function is true, the
! 64: ** current content of the cell is preserved. Otherwise, it may
! 65: ** be discarded.
! 66: **
! 67: ** This function sets the MEM_Dyn flag and clears any xDel callback.
! 68: ** It also clears MEM_Ephem and MEM_Static. If the preserve flag is
! 69: ** not set, Mem.n is zeroed.
! 70: */
! 71: int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve){
! 72: assert( 1 >=
! 73: ((pMem->zMalloc && pMem->zMalloc==pMem->z) ? 1 : 0) +
! 74: (((pMem->flags&MEM_Dyn)&&pMem->xDel) ? 1 : 0) +
! 75: ((pMem->flags&MEM_Ephem) ? 1 : 0) +
! 76: ((pMem->flags&MEM_Static) ? 1 : 0)
! 77: );
! 78: assert( (pMem->flags&MEM_RowSet)==0 );
! 79:
! 80: if( n<32 ) n = 32;
! 81: if( sqlite3DbMallocSize(pMem->db, pMem->zMalloc)<n ){
! 82: if( preserve && pMem->z==pMem->zMalloc ){
! 83: pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
! 84: preserve = 0;
! 85: }else{
! 86: sqlite3DbFree(pMem->db, pMem->zMalloc);
! 87: pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
! 88: }
! 89: }
! 90:
! 91: if( pMem->z && preserve && pMem->zMalloc && pMem->z!=pMem->zMalloc ){
! 92: memcpy(pMem->zMalloc, pMem->z, pMem->n);
! 93: }
! 94: if( pMem->flags&MEM_Dyn && pMem->xDel ){
! 95: pMem->xDel((void *)(pMem->z));
! 96: }
! 97:
! 98: pMem->z = pMem->zMalloc;
! 99: if( pMem->z==0 ){
! 100: pMem->flags = MEM_Null;
! 101: }else{
! 102: pMem->flags &= ~(MEM_Ephem|MEM_Static);
! 103: }
! 104: pMem->xDel = 0;
! 105: return (pMem->z ? SQLITE_OK : SQLITE_NOMEM);
! 106: }
! 107:
! 108: /*
! 109: ** Make the given Mem object MEM_Dyn. In other words, make it so
! 110: ** that any TEXT or BLOB content is stored in memory obtained from
! 111: ** malloc(). In this way, we know that the memory is safe to be
! 112: ** overwritten or altered.
! 113: **
! 114: ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
! 115: */
! 116: int sqlite3VdbeMemMakeWriteable(Mem *pMem){
! 117: int f;
! 118: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
! 119: assert( (pMem->flags&MEM_RowSet)==0 );
! 120: ExpandBlob(pMem);
! 121: f = pMem->flags;
! 122: if( (f&(MEM_Str|MEM_Blob)) && pMem->z!=pMem->zMalloc ){
! 123: if( sqlite3VdbeMemGrow(pMem, pMem->n + 2, 1) ){
! 124: return SQLITE_NOMEM;
! 125: }
! 126: pMem->z[pMem->n] = 0;
! 127: pMem->z[pMem->n+1] = 0;
! 128: pMem->flags |= MEM_Term;
! 129: #ifdef SQLITE_DEBUG
! 130: pMem->pScopyFrom = 0;
! 131: #endif
! 132: }
! 133:
! 134: return SQLITE_OK;
! 135: }
! 136:
! 137: /*
! 138: ** If the given Mem* has a zero-filled tail, turn it into an ordinary
! 139: ** blob stored in dynamically allocated space.
! 140: */
! 141: #ifndef SQLITE_OMIT_INCRBLOB
! 142: int sqlite3VdbeMemExpandBlob(Mem *pMem){
! 143: if( pMem->flags & MEM_Zero ){
! 144: int nByte;
! 145: assert( pMem->flags&MEM_Blob );
! 146: assert( (pMem->flags&MEM_RowSet)==0 );
! 147: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
! 148:
! 149: /* Set nByte to the number of bytes required to store the expanded blob. */
! 150: nByte = pMem->n + pMem->u.nZero;
! 151: if( nByte<=0 ){
! 152: nByte = 1;
! 153: }
! 154: if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
! 155: return SQLITE_NOMEM;
! 156: }
! 157:
! 158: memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
! 159: pMem->n += pMem->u.nZero;
! 160: pMem->flags &= ~(MEM_Zero|MEM_Term);
! 161: }
! 162: return SQLITE_OK;
! 163: }
! 164: #endif
! 165:
! 166:
! 167: /*
! 168: ** Make sure the given Mem is \u0000 terminated.
! 169: */
! 170: int sqlite3VdbeMemNulTerminate(Mem *pMem){
! 171: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
! 172: if( (pMem->flags & MEM_Term)!=0 || (pMem->flags & MEM_Str)==0 ){
! 173: return SQLITE_OK; /* Nothing to do */
! 174: }
! 175: if( sqlite3VdbeMemGrow(pMem, pMem->n+2, 1) ){
! 176: return SQLITE_NOMEM;
! 177: }
! 178: pMem->z[pMem->n] = 0;
! 179: pMem->z[pMem->n+1] = 0;
! 180: pMem->flags |= MEM_Term;
! 181: return SQLITE_OK;
! 182: }
! 183:
! 184: /*
! 185: ** Add MEM_Str to the set of representations for the given Mem. Numbers
! 186: ** are converted using sqlite3_snprintf(). Converting a BLOB to a string
! 187: ** is a no-op.
! 188: **
! 189: ** Existing representations MEM_Int and MEM_Real are *not* invalidated.
! 190: **
! 191: ** A MEM_Null value will never be passed to this function. This function is
! 192: ** used for converting values to text for returning to the user (i.e. via
! 193: ** sqlite3_value_text()), or for ensuring that values to be used as btree
! 194: ** keys are strings. In the former case a NULL pointer is returned the
! 195: ** user and the later is an internal programming error.
! 196: */
! 197: int sqlite3VdbeMemStringify(Mem *pMem, int enc){
! 198: int rc = SQLITE_OK;
! 199: int fg = pMem->flags;
! 200: const int nByte = 32;
! 201:
! 202: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
! 203: assert( !(fg&MEM_Zero) );
! 204: assert( !(fg&(MEM_Str|MEM_Blob)) );
! 205: assert( fg&(MEM_Int|MEM_Real) );
! 206: assert( (pMem->flags&MEM_RowSet)==0 );
! 207: assert( EIGHT_BYTE_ALIGNMENT(pMem) );
! 208:
! 209:
! 210: if( sqlite3VdbeMemGrow(pMem, nByte, 0) ){
! 211: return SQLITE_NOMEM;
! 212: }
! 213:
! 214: /* For a Real or Integer, use sqlite3_mprintf() to produce the UTF-8
! 215: ** string representation of the value. Then, if the required encoding
! 216: ** is UTF-16le or UTF-16be do a translation.
! 217: **
! 218: ** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16.
! 219: */
! 220: if( fg & MEM_Int ){
! 221: sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
! 222: }else{
! 223: assert( fg & MEM_Real );
! 224: sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->r);
! 225: }
! 226: pMem->n = sqlite3Strlen30(pMem->z);
! 227: pMem->enc = SQLITE_UTF8;
! 228: pMem->flags |= MEM_Str|MEM_Term;
! 229: sqlite3VdbeChangeEncoding(pMem, enc);
! 230: return rc;
! 231: }
! 232:
! 233: /*
! 234: ** Memory cell pMem contains the context of an aggregate function.
! 235: ** This routine calls the finalize method for that function. The
! 236: ** result of the aggregate is stored back into pMem.
! 237: **
! 238: ** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK
! 239: ** otherwise.
! 240: */
! 241: int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
! 242: int rc = SQLITE_OK;
! 243: if( ALWAYS(pFunc && pFunc->xFinalize) ){
! 244: sqlite3_context ctx;
! 245: assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
! 246: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
! 247: memset(&ctx, 0, sizeof(ctx));
! 248: ctx.s.flags = MEM_Null;
! 249: ctx.s.db = pMem->db;
! 250: ctx.pMem = pMem;
! 251: ctx.pFunc = pFunc;
! 252: pFunc->xFinalize(&ctx); /* IMP: R-24505-23230 */
! 253: assert( 0==(pMem->flags&MEM_Dyn) && !pMem->xDel );
! 254: sqlite3DbFree(pMem->db, pMem->zMalloc);
! 255: memcpy(pMem, &ctx.s, sizeof(ctx.s));
! 256: rc = ctx.isError;
! 257: }
! 258: return rc;
! 259: }
! 260:
! 261: /*
! 262: ** If the memory cell contains a string value that must be freed by
! 263: ** invoking an external callback, free it now. Calling this function
! 264: ** does not free any Mem.zMalloc buffer.
! 265: */
! 266: void sqlite3VdbeMemReleaseExternal(Mem *p){
! 267: assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
! 268: if( p->flags&MEM_Agg ){
! 269: sqlite3VdbeMemFinalize(p, p->u.pDef);
! 270: assert( (p->flags & MEM_Agg)==0 );
! 271: sqlite3VdbeMemRelease(p);
! 272: }else if( p->flags&MEM_Dyn && p->xDel ){
! 273: assert( (p->flags&MEM_RowSet)==0 );
! 274: p->xDel((void *)p->z);
! 275: p->xDel = 0;
! 276: }else if( p->flags&MEM_RowSet ){
! 277: sqlite3RowSetClear(p->u.pRowSet);
! 278: }else if( p->flags&MEM_Frame ){
! 279: sqlite3VdbeMemSetNull(p);
! 280: }
! 281: }
! 282:
! 283: /*
! 284: ** Release any memory held by the Mem. This may leave the Mem in an
! 285: ** inconsistent state, for example with (Mem.z==0) and
! 286: ** (Mem.type==SQLITE_TEXT).
! 287: */
! 288: void sqlite3VdbeMemRelease(Mem *p){
! 289: VdbeMemRelease(p);
! 290: sqlite3DbFree(p->db, p->zMalloc);
! 291: p->z = 0;
! 292: p->zMalloc = 0;
! 293: p->xDel = 0;
! 294: }
! 295:
! 296: /*
! 297: ** Convert a 64-bit IEEE double into a 64-bit signed integer.
! 298: ** If the double is too large, return 0x8000000000000000.
! 299: **
! 300: ** Most systems appear to do this simply by assigning
! 301: ** variables and without the extra range tests. But
! 302: ** there are reports that windows throws an expection
! 303: ** if the floating point value is out of range. (See ticket #2880.)
! 304: ** Because we do not completely understand the problem, we will
! 305: ** take the conservative approach and always do range tests
! 306: ** before attempting the conversion.
! 307: */
! 308: static i64 doubleToInt64(double r){
! 309: #ifdef SQLITE_OMIT_FLOATING_POINT
! 310: /* When floating-point is omitted, double and int64 are the same thing */
! 311: return r;
! 312: #else
! 313: /*
! 314: ** Many compilers we encounter do not define constants for the
! 315: ** minimum and maximum 64-bit integers, or they define them
! 316: ** inconsistently. And many do not understand the "LL" notation.
! 317: ** So we define our own static constants here using nothing
! 318: ** larger than a 32-bit integer constant.
! 319: */
! 320: static const i64 maxInt = LARGEST_INT64;
! 321: static const i64 minInt = SMALLEST_INT64;
! 322:
! 323: if( r<(double)minInt ){
! 324: return minInt;
! 325: }else if( r>(double)maxInt ){
! 326: /* minInt is correct here - not maxInt. It turns out that assigning
! 327: ** a very large positive number to an integer results in a very large
! 328: ** negative integer. This makes no sense, but it is what x86 hardware
! 329: ** does so for compatibility we will do the same in software. */
! 330: return minInt;
! 331: }else{
! 332: return (i64)r;
! 333: }
! 334: #endif
! 335: }
! 336:
! 337: /*
! 338: ** Return some kind of integer value which is the best we can do
! 339: ** at representing the value that *pMem describes as an integer.
! 340: ** If pMem is an integer, then the value is exact. If pMem is
! 341: ** a floating-point then the value returned is the integer part.
! 342: ** If pMem is a string or blob, then we make an attempt to convert
! 343: ** it into a integer and return that. If pMem represents an
! 344: ** an SQL-NULL value, return 0.
! 345: **
! 346: ** If pMem represents a string value, its encoding might be changed.
! 347: */
! 348: i64 sqlite3VdbeIntValue(Mem *pMem){
! 349: int flags;
! 350: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
! 351: assert( EIGHT_BYTE_ALIGNMENT(pMem) );
! 352: flags = pMem->flags;
! 353: if( flags & MEM_Int ){
! 354: return pMem->u.i;
! 355: }else if( flags & MEM_Real ){
! 356: return doubleToInt64(pMem->r);
! 357: }else if( flags & (MEM_Str|MEM_Blob) ){
! 358: i64 value = 0;
! 359: assert( pMem->z || pMem->n==0 );
! 360: testcase( pMem->z==0 );
! 361: sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
! 362: return value;
! 363: }else{
! 364: return 0;
! 365: }
! 366: }
! 367:
! 368: /*
! 369: ** Return the best representation of pMem that we can get into a
! 370: ** double. If pMem is already a double or an integer, return its
! 371: ** value. If it is a string or blob, try to convert it to a double.
! 372: ** If it is a NULL, return 0.0.
! 373: */
! 374: double sqlite3VdbeRealValue(Mem *pMem){
! 375: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
! 376: assert( EIGHT_BYTE_ALIGNMENT(pMem) );
! 377: if( pMem->flags & MEM_Real ){
! 378: return pMem->r;
! 379: }else if( pMem->flags & MEM_Int ){
! 380: return (double)pMem->u.i;
! 381: }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
! 382: /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
! 383: double val = (double)0;
! 384: sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc);
! 385: return val;
! 386: }else{
! 387: /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
! 388: return (double)0;
! 389: }
! 390: }
! 391:
! 392: /*
! 393: ** The MEM structure is already a MEM_Real. Try to also make it a
! 394: ** MEM_Int if we can.
! 395: */
! 396: void sqlite3VdbeIntegerAffinity(Mem *pMem){
! 397: assert( pMem->flags & MEM_Real );
! 398: assert( (pMem->flags & MEM_RowSet)==0 );
! 399: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
! 400: assert( EIGHT_BYTE_ALIGNMENT(pMem) );
! 401:
! 402: pMem->u.i = doubleToInt64(pMem->r);
! 403:
! 404: /* Only mark the value as an integer if
! 405: **
! 406: ** (1) the round-trip conversion real->int->real is a no-op, and
! 407: ** (2) The integer is neither the largest nor the smallest
! 408: ** possible integer (ticket #3922)
! 409: **
! 410: ** The second and third terms in the following conditional enforces
! 411: ** the second condition under the assumption that addition overflow causes
! 412: ** values to wrap around. On x86 hardware, the third term is always
! 413: ** true and could be omitted. But we leave it in because other
! 414: ** architectures might behave differently.
! 415: */
! 416: if( pMem->r==(double)pMem->u.i && pMem->u.i>SMALLEST_INT64
! 417: && ALWAYS(pMem->u.i<LARGEST_INT64) ){
! 418: pMem->flags |= MEM_Int;
! 419: }
! 420: }
! 421:
! 422: /*
! 423: ** Convert pMem to type integer. Invalidate any prior representations.
! 424: */
! 425: int sqlite3VdbeMemIntegerify(Mem *pMem){
! 426: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
! 427: assert( (pMem->flags & MEM_RowSet)==0 );
! 428: assert( EIGHT_BYTE_ALIGNMENT(pMem) );
! 429:
! 430: pMem->u.i = sqlite3VdbeIntValue(pMem);
! 431: MemSetTypeFlag(pMem, MEM_Int);
! 432: return SQLITE_OK;
! 433: }
! 434:
! 435: /*
! 436: ** Convert pMem so that it is of type MEM_Real.
! 437: ** Invalidate any prior representations.
! 438: */
! 439: int sqlite3VdbeMemRealify(Mem *pMem){
! 440: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
! 441: assert( EIGHT_BYTE_ALIGNMENT(pMem) );
! 442:
! 443: pMem->r = sqlite3VdbeRealValue(pMem);
! 444: MemSetTypeFlag(pMem, MEM_Real);
! 445: return SQLITE_OK;
! 446: }
! 447:
! 448: /*
! 449: ** Convert pMem so that it has types MEM_Real or MEM_Int or both.
! 450: ** Invalidate any prior representations.
! 451: **
! 452: ** Every effort is made to force the conversion, even if the input
! 453: ** is a string that does not look completely like a number. Convert
! 454: ** as much of the string as we can and ignore the rest.
! 455: */
! 456: int sqlite3VdbeMemNumerify(Mem *pMem){
! 457: if( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 ){
! 458: assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
! 459: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
! 460: if( 0==sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc) ){
! 461: MemSetTypeFlag(pMem, MEM_Int);
! 462: }else{
! 463: pMem->r = sqlite3VdbeRealValue(pMem);
! 464: MemSetTypeFlag(pMem, MEM_Real);
! 465: sqlite3VdbeIntegerAffinity(pMem);
! 466: }
! 467: }
! 468: assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))!=0 );
! 469: pMem->flags &= ~(MEM_Str|MEM_Blob);
! 470: return SQLITE_OK;
! 471: }
! 472:
! 473: /*
! 474: ** Delete any previous value and set the value stored in *pMem to NULL.
! 475: */
! 476: void sqlite3VdbeMemSetNull(Mem *pMem){
! 477: if( pMem->flags & MEM_Frame ){
! 478: VdbeFrame *pFrame = pMem->u.pFrame;
! 479: pFrame->pParent = pFrame->v->pDelFrame;
! 480: pFrame->v->pDelFrame = pFrame;
! 481: }
! 482: if( pMem->flags & MEM_RowSet ){
! 483: sqlite3RowSetClear(pMem->u.pRowSet);
! 484: }
! 485: MemSetTypeFlag(pMem, MEM_Null);
! 486: pMem->type = SQLITE_NULL;
! 487: }
! 488:
! 489: /*
! 490: ** Delete any previous value and set the value to be a BLOB of length
! 491: ** n containing all zeros.
! 492: */
! 493: void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
! 494: sqlite3VdbeMemRelease(pMem);
! 495: pMem->flags = MEM_Blob|MEM_Zero;
! 496: pMem->type = SQLITE_BLOB;
! 497: pMem->n = 0;
! 498: if( n<0 ) n = 0;
! 499: pMem->u.nZero = n;
! 500: pMem->enc = SQLITE_UTF8;
! 501:
! 502: #ifdef SQLITE_OMIT_INCRBLOB
! 503: sqlite3VdbeMemGrow(pMem, n, 0);
! 504: if( pMem->z ){
! 505: pMem->n = n;
! 506: memset(pMem->z, 0, n);
! 507: }
! 508: #endif
! 509: }
! 510:
! 511: /*
! 512: ** Delete any previous value and set the value stored in *pMem to val,
! 513: ** manifest type INTEGER.
! 514: */
! 515: void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
! 516: sqlite3VdbeMemRelease(pMem);
! 517: pMem->u.i = val;
! 518: pMem->flags = MEM_Int;
! 519: pMem->type = SQLITE_INTEGER;
! 520: }
! 521:
! 522: #ifndef SQLITE_OMIT_FLOATING_POINT
! 523: /*
! 524: ** Delete any previous value and set the value stored in *pMem to val,
! 525: ** manifest type REAL.
! 526: */
! 527: void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
! 528: if( sqlite3IsNaN(val) ){
! 529: sqlite3VdbeMemSetNull(pMem);
! 530: }else{
! 531: sqlite3VdbeMemRelease(pMem);
! 532: pMem->r = val;
! 533: pMem->flags = MEM_Real;
! 534: pMem->type = SQLITE_FLOAT;
! 535: }
! 536: }
! 537: #endif
! 538:
! 539: /*
! 540: ** Delete any previous value and set the value of pMem to be an
! 541: ** empty boolean index.
! 542: */
! 543: void sqlite3VdbeMemSetRowSet(Mem *pMem){
! 544: sqlite3 *db = pMem->db;
! 545: assert( db!=0 );
! 546: assert( (pMem->flags & MEM_RowSet)==0 );
! 547: sqlite3VdbeMemRelease(pMem);
! 548: pMem->zMalloc = sqlite3DbMallocRaw(db, 64);
! 549: if( db->mallocFailed ){
! 550: pMem->flags = MEM_Null;
! 551: }else{
! 552: assert( pMem->zMalloc );
! 553: pMem->u.pRowSet = sqlite3RowSetInit(db, pMem->zMalloc,
! 554: sqlite3DbMallocSize(db, pMem->zMalloc));
! 555: assert( pMem->u.pRowSet!=0 );
! 556: pMem->flags = MEM_RowSet;
! 557: }
! 558: }
! 559:
! 560: /*
! 561: ** Return true if the Mem object contains a TEXT or BLOB that is
! 562: ** too large - whose size exceeds SQLITE_MAX_LENGTH.
! 563: */
! 564: int sqlite3VdbeMemTooBig(Mem *p){
! 565: assert( p->db!=0 );
! 566: if( p->flags & (MEM_Str|MEM_Blob) ){
! 567: int n = p->n;
! 568: if( p->flags & MEM_Zero ){
! 569: n += p->u.nZero;
! 570: }
! 571: return n>p->db->aLimit[SQLITE_LIMIT_LENGTH];
! 572: }
! 573: return 0;
! 574: }
! 575:
! 576: #ifdef SQLITE_DEBUG
! 577: /*
! 578: ** This routine prepares a memory cell for modication by breaking
! 579: ** its link to a shallow copy and by marking any current shallow
! 580: ** copies of this cell as invalid.
! 581: **
! 582: ** This is used for testing and debugging only - to make sure shallow
! 583: ** copies are not misused.
! 584: */
! 585: void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
! 586: int i;
! 587: Mem *pX;
! 588: for(i=1, pX=&pVdbe->aMem[1]; i<=pVdbe->nMem; i++, pX++){
! 589: if( pX->pScopyFrom==pMem ){
! 590: pX->flags |= MEM_Invalid;
! 591: pX->pScopyFrom = 0;
! 592: }
! 593: }
! 594: pMem->pScopyFrom = 0;
! 595: }
! 596: #endif /* SQLITE_DEBUG */
! 597:
! 598: /*
! 599: ** Size of struct Mem not including the Mem.zMalloc member.
! 600: */
! 601: #define MEMCELLSIZE (size_t)(&(((Mem *)0)->zMalloc))
! 602:
! 603: /*
! 604: ** Make an shallow copy of pFrom into pTo. Prior contents of
! 605: ** pTo are freed. The pFrom->z field is not duplicated. If
! 606: ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
! 607: ** and flags gets srcType (either MEM_Ephem or MEM_Static).
! 608: */
! 609: void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
! 610: assert( (pFrom->flags & MEM_RowSet)==0 );
! 611: VdbeMemRelease(pTo);
! 612: memcpy(pTo, pFrom, MEMCELLSIZE);
! 613: pTo->xDel = 0;
! 614: if( (pFrom->flags&MEM_Static)==0 ){
! 615: pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
! 616: assert( srcType==MEM_Ephem || srcType==MEM_Static );
! 617: pTo->flags |= srcType;
! 618: }
! 619: }
! 620:
! 621: /*
! 622: ** Make a full copy of pFrom into pTo. Prior contents of pTo are
! 623: ** freed before the copy is made.
! 624: */
! 625: int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
! 626: int rc = SQLITE_OK;
! 627:
! 628: assert( (pFrom->flags & MEM_RowSet)==0 );
! 629: VdbeMemRelease(pTo);
! 630: memcpy(pTo, pFrom, MEMCELLSIZE);
! 631: pTo->flags &= ~MEM_Dyn;
! 632:
! 633: if( pTo->flags&(MEM_Str|MEM_Blob) ){
! 634: if( 0==(pFrom->flags&MEM_Static) ){
! 635: pTo->flags |= MEM_Ephem;
! 636: rc = sqlite3VdbeMemMakeWriteable(pTo);
! 637: }
! 638: }
! 639:
! 640: return rc;
! 641: }
! 642:
! 643: /*
! 644: ** Transfer the contents of pFrom to pTo. Any existing value in pTo is
! 645: ** freed. If pFrom contains ephemeral data, a copy is made.
! 646: **
! 647: ** pFrom contains an SQL NULL when this routine returns.
! 648: */
! 649: void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
! 650: assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
! 651: assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
! 652: assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
! 653:
! 654: sqlite3VdbeMemRelease(pTo);
! 655: memcpy(pTo, pFrom, sizeof(Mem));
! 656: pFrom->flags = MEM_Null;
! 657: pFrom->xDel = 0;
! 658: pFrom->zMalloc = 0;
! 659: }
! 660:
! 661: /*
! 662: ** Change the value of a Mem to be a string or a BLOB.
! 663: **
! 664: ** The memory management strategy depends on the value of the xDel
! 665: ** parameter. If the value passed is SQLITE_TRANSIENT, then the
! 666: ** string is copied into a (possibly existing) buffer managed by the
! 667: ** Mem structure. Otherwise, any existing buffer is freed and the
! 668: ** pointer copied.
! 669: **
! 670: ** If the string is too large (if it exceeds the SQLITE_LIMIT_LENGTH
! 671: ** size limit) then no memory allocation occurs. If the string can be
! 672: ** stored without allocating memory, then it is. If a memory allocation
! 673: ** is required to store the string, then value of pMem is unchanged. In
! 674: ** either case, SQLITE_TOOBIG is returned.
! 675: */
! 676: int sqlite3VdbeMemSetStr(
! 677: Mem *pMem, /* Memory cell to set to string value */
! 678: const char *z, /* String pointer */
! 679: int n, /* Bytes in string, or negative */
! 680: u8 enc, /* Encoding of z. 0 for BLOBs */
! 681: void (*xDel)(void*) /* Destructor function */
! 682: ){
! 683: int nByte = n; /* New value for pMem->n */
! 684: int iLimit; /* Maximum allowed string or blob size */
! 685: u16 flags = 0; /* New value for pMem->flags */
! 686:
! 687: assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
! 688: assert( (pMem->flags & MEM_RowSet)==0 );
! 689:
! 690: /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
! 691: if( !z ){
! 692: sqlite3VdbeMemSetNull(pMem);
! 693: return SQLITE_OK;
! 694: }
! 695:
! 696: if( pMem->db ){
! 697: iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH];
! 698: }else{
! 699: iLimit = SQLITE_MAX_LENGTH;
! 700: }
! 701: flags = (enc==0?MEM_Blob:MEM_Str);
! 702: if( nByte<0 ){
! 703: assert( enc!=0 );
! 704: if( enc==SQLITE_UTF8 ){
! 705: for(nByte=0; nByte<=iLimit && z[nByte]; nByte++){}
! 706: }else{
! 707: for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
! 708: }
! 709: flags |= MEM_Term;
! 710: }
! 711:
! 712: /* The following block sets the new values of Mem.z and Mem.xDel. It
! 713: ** also sets a flag in local variable "flags" to indicate the memory
! 714: ** management (one of MEM_Dyn or MEM_Static).
! 715: */
! 716: if( xDel==SQLITE_TRANSIENT ){
! 717: int nAlloc = nByte;
! 718: if( flags&MEM_Term ){
! 719: nAlloc += (enc==SQLITE_UTF8?1:2);
! 720: }
! 721: if( nByte>iLimit ){
! 722: return SQLITE_TOOBIG;
! 723: }
! 724: if( sqlite3VdbeMemGrow(pMem, nAlloc, 0) ){
! 725: return SQLITE_NOMEM;
! 726: }
! 727: memcpy(pMem->z, z, nAlloc);
! 728: }else if( xDel==SQLITE_DYNAMIC ){
! 729: sqlite3VdbeMemRelease(pMem);
! 730: pMem->zMalloc = pMem->z = (char *)z;
! 731: pMem->xDel = 0;
! 732: }else{
! 733: sqlite3VdbeMemRelease(pMem);
! 734: pMem->z = (char *)z;
! 735: pMem->xDel = xDel;
! 736: flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn);
! 737: }
! 738:
! 739: pMem->n = nByte;
! 740: pMem->flags = flags;
! 741: pMem->enc = (enc==0 ? SQLITE_UTF8 : enc);
! 742: pMem->type = (enc==0 ? SQLITE_BLOB : SQLITE_TEXT);
! 743:
! 744: #ifndef SQLITE_OMIT_UTF16
! 745: if( pMem->enc!=SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
! 746: return SQLITE_NOMEM;
! 747: }
! 748: #endif
! 749:
! 750: if( nByte>iLimit ){
! 751: return SQLITE_TOOBIG;
! 752: }
! 753:
! 754: return SQLITE_OK;
! 755: }
! 756:
! 757: /*
! 758: ** Compare the values contained by the two memory cells, returning
! 759: ** negative, zero or positive if pMem1 is less than, equal to, or greater
! 760: ** than pMem2. Sorting order is NULL's first, followed by numbers (integers
! 761: ** and reals) sorted numerically, followed by text ordered by the collating
! 762: ** sequence pColl and finally blob's ordered by memcmp().
! 763: **
! 764: ** Two NULL values are considered equal by this function.
! 765: */
! 766: int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
! 767: int rc;
! 768: int f1, f2;
! 769: int combined_flags;
! 770:
! 771: f1 = pMem1->flags;
! 772: f2 = pMem2->flags;
! 773: combined_flags = f1|f2;
! 774: assert( (combined_flags & MEM_RowSet)==0 );
! 775:
! 776: /* If one value is NULL, it is less than the other. If both values
! 777: ** are NULL, return 0.
! 778: */
! 779: if( combined_flags&MEM_Null ){
! 780: return (f2&MEM_Null) - (f1&MEM_Null);
! 781: }
! 782:
! 783: /* If one value is a number and the other is not, the number is less.
! 784: ** If both are numbers, compare as reals if one is a real, or as integers
! 785: ** if both values are integers.
! 786: */
! 787: if( combined_flags&(MEM_Int|MEM_Real) ){
! 788: if( !(f1&(MEM_Int|MEM_Real)) ){
! 789: return 1;
! 790: }
! 791: if( !(f2&(MEM_Int|MEM_Real)) ){
! 792: return -1;
! 793: }
! 794: if( (f1 & f2 & MEM_Int)==0 ){
! 795: double r1, r2;
! 796: if( (f1&MEM_Real)==0 ){
! 797: r1 = (double)pMem1->u.i;
! 798: }else{
! 799: r1 = pMem1->r;
! 800: }
! 801: if( (f2&MEM_Real)==0 ){
! 802: r2 = (double)pMem2->u.i;
! 803: }else{
! 804: r2 = pMem2->r;
! 805: }
! 806: if( r1<r2 ) return -1;
! 807: if( r1>r2 ) return 1;
! 808: return 0;
! 809: }else{
! 810: assert( f1&MEM_Int );
! 811: assert( f2&MEM_Int );
! 812: if( pMem1->u.i < pMem2->u.i ) return -1;
! 813: if( pMem1->u.i > pMem2->u.i ) return 1;
! 814: return 0;
! 815: }
! 816: }
! 817:
! 818: /* If one value is a string and the other is a blob, the string is less.
! 819: ** If both are strings, compare using the collating functions.
! 820: */
! 821: if( combined_flags&MEM_Str ){
! 822: if( (f1 & MEM_Str)==0 ){
! 823: return 1;
! 824: }
! 825: if( (f2 & MEM_Str)==0 ){
! 826: return -1;
! 827: }
! 828:
! 829: assert( pMem1->enc==pMem2->enc );
! 830: assert( pMem1->enc==SQLITE_UTF8 ||
! 831: pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
! 832:
! 833: /* The collation sequence must be defined at this point, even if
! 834: ** the user deletes the collation sequence after the vdbe program is
! 835: ** compiled (this was not always the case).
! 836: */
! 837: assert( !pColl || pColl->xCmp );
! 838:
! 839: if( pColl ){
! 840: if( pMem1->enc==pColl->enc ){
! 841: /* The strings are already in the correct encoding. Call the
! 842: ** comparison function directly */
! 843: return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
! 844: }else{
! 845: const void *v1, *v2;
! 846: int n1, n2;
! 847: Mem c1;
! 848: Mem c2;
! 849: memset(&c1, 0, sizeof(c1));
! 850: memset(&c2, 0, sizeof(c2));
! 851: sqlite3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem);
! 852: sqlite3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem);
! 853: v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc);
! 854: n1 = v1==0 ? 0 : c1.n;
! 855: v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
! 856: n2 = v2==0 ? 0 : c2.n;
! 857: rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2);
! 858: sqlite3VdbeMemRelease(&c1);
! 859: sqlite3VdbeMemRelease(&c2);
! 860: return rc;
! 861: }
! 862: }
! 863: /* If a NULL pointer was passed as the collate function, fall through
! 864: ** to the blob case and use memcmp(). */
! 865: }
! 866:
! 867: /* Both values must be blobs. Compare using memcmp(). */
! 868: rc = memcmp(pMem1->z, pMem2->z, (pMem1->n>pMem2->n)?pMem2->n:pMem1->n);
! 869: if( rc==0 ){
! 870: rc = pMem1->n - pMem2->n;
! 871: }
! 872: return rc;
! 873: }
! 874:
! 875: /*
! 876: ** Move data out of a btree key or data field and into a Mem structure.
! 877: ** The data or key is taken from the entry that pCur is currently pointing
! 878: ** to. offset and amt determine what portion of the data or key to retrieve.
! 879: ** key is true to get the key or false to get data. The result is written
! 880: ** into the pMem element.
! 881: **
! 882: ** The pMem structure is assumed to be uninitialized. Any prior content
! 883: ** is overwritten without being freed.
! 884: **
! 885: ** If this routine fails for any reason (malloc returns NULL or unable
! 886: ** to read from the disk) then the pMem is left in an inconsistent state.
! 887: */
! 888: int sqlite3VdbeMemFromBtree(
! 889: BtCursor *pCur, /* Cursor pointing at record to retrieve. */
! 890: int offset, /* Offset from the start of data to return bytes from. */
! 891: int amt, /* Number of bytes to return. */
! 892: int key, /* If true, retrieve from the btree key, not data. */
! 893: Mem *pMem /* OUT: Return data in this Mem structure. */
! 894: ){
! 895: char *zData; /* Data from the btree layer */
! 896: int available = 0; /* Number of bytes available on the local btree page */
! 897: int rc = SQLITE_OK; /* Return code */
! 898:
! 899: assert( sqlite3BtreeCursorIsValid(pCur) );
! 900:
! 901: /* Note: the calls to BtreeKeyFetch() and DataFetch() below assert()
! 902: ** that both the BtShared and database handle mutexes are held. */
! 903: assert( (pMem->flags & MEM_RowSet)==0 );
! 904: if( key ){
! 905: zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
! 906: }else{
! 907: zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
! 908: }
! 909: assert( zData!=0 );
! 910:
! 911: if( offset+amt<=available && (pMem->flags&MEM_Dyn)==0 ){
! 912: sqlite3VdbeMemRelease(pMem);
! 913: pMem->z = &zData[offset];
! 914: pMem->flags = MEM_Blob|MEM_Ephem;
! 915: }else if( SQLITE_OK==(rc = sqlite3VdbeMemGrow(pMem, amt+2, 0)) ){
! 916: pMem->flags = MEM_Blob|MEM_Dyn|MEM_Term;
! 917: pMem->enc = 0;
! 918: pMem->type = SQLITE_BLOB;
! 919: if( key ){
! 920: rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
! 921: }else{
! 922: rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
! 923: }
! 924: pMem->z[amt] = 0;
! 925: pMem->z[amt+1] = 0;
! 926: if( rc!=SQLITE_OK ){
! 927: sqlite3VdbeMemRelease(pMem);
! 928: }
! 929: }
! 930: pMem->n = amt;
! 931:
! 932: return rc;
! 933: }
! 934:
! 935: /* This function is only available internally, it is not part of the
! 936: ** external API. It works in a similar way to sqlite3_value_text(),
! 937: ** except the data returned is in the encoding specified by the second
! 938: ** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
! 939: ** SQLITE_UTF8.
! 940: **
! 941: ** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
! 942: ** If that is the case, then the result must be aligned on an even byte
! 943: ** boundary.
! 944: */
! 945: const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
! 946: if( !pVal ) return 0;
! 947:
! 948: assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
! 949: assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
! 950: assert( (pVal->flags & MEM_RowSet)==0 );
! 951:
! 952: if( pVal->flags&MEM_Null ){
! 953: return 0;
! 954: }
! 955: assert( (MEM_Blob>>3) == MEM_Str );
! 956: pVal->flags |= (pVal->flags & MEM_Blob)>>3;
! 957: ExpandBlob(pVal);
! 958: if( pVal->flags&MEM_Str ){
! 959: sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
! 960: if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
! 961: assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
! 962: if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
! 963: return 0;
! 964: }
! 965: }
! 966: sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */
! 967: }else{
! 968: assert( (pVal->flags&MEM_Blob)==0 );
! 969: sqlite3VdbeMemStringify(pVal, enc);
! 970: assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
! 971: }
! 972: assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
! 973: || pVal->db->mallocFailed );
! 974: if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
! 975: return pVal->z;
! 976: }else{
! 977: return 0;
! 978: }
! 979: }
! 980:
! 981: /*
! 982: ** Create a new sqlite3_value object.
! 983: */
! 984: sqlite3_value *sqlite3ValueNew(sqlite3 *db){
! 985: Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
! 986: if( p ){
! 987: p->flags = MEM_Null;
! 988: p->type = SQLITE_NULL;
! 989: p->db = db;
! 990: }
! 991: return p;
! 992: }
! 993:
! 994: /*
! 995: ** Create a new sqlite3_value object, containing the value of pExpr.
! 996: **
! 997: ** This only works for very simple expressions that consist of one constant
! 998: ** token (i.e. "5", "5.1", "'a string'"). If the expression can
! 999: ** be converted directly into a value, then the value is allocated and
! 1000: ** a pointer written to *ppVal. The caller is responsible for deallocating
! 1001: ** the value by passing it to sqlite3ValueFree() later on. If the expression
! 1002: ** cannot be converted to a value, then *ppVal is set to NULL.
! 1003: */
! 1004: int sqlite3ValueFromExpr(
! 1005: sqlite3 *db, /* The database connection */
! 1006: Expr *pExpr, /* The expression to evaluate */
! 1007: u8 enc, /* Encoding to use */
! 1008: u8 affinity, /* Affinity to use */
! 1009: sqlite3_value **ppVal /* Write the new value here */
! 1010: ){
! 1011: int op;
! 1012: char *zVal = 0;
! 1013: sqlite3_value *pVal = 0;
! 1014: int negInt = 1;
! 1015: const char *zNeg = "";
! 1016:
! 1017: if( !pExpr ){
! 1018: *ppVal = 0;
! 1019: return SQLITE_OK;
! 1020: }
! 1021: op = pExpr->op;
! 1022:
! 1023: /* op can only be TK_REGISTER if we have compiled with SQLITE_ENABLE_STAT3.
! 1024: ** The ifdef here is to enable us to achieve 100% branch test coverage even
! 1025: ** when SQLITE_ENABLE_STAT3 is omitted.
! 1026: */
! 1027: #ifdef SQLITE_ENABLE_STAT3
! 1028: if( op==TK_REGISTER ) op = pExpr->op2;
! 1029: #else
! 1030: if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
! 1031: #endif
! 1032:
! 1033: /* Handle negative integers in a single step. This is needed in the
! 1034: ** case when the value is -9223372036854775808.
! 1035: */
! 1036: if( op==TK_UMINUS
! 1037: && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){
! 1038: pExpr = pExpr->pLeft;
! 1039: op = pExpr->op;
! 1040: negInt = -1;
! 1041: zNeg = "-";
! 1042: }
! 1043:
! 1044: if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
! 1045: pVal = sqlite3ValueNew(db);
! 1046: if( pVal==0 ) goto no_mem;
! 1047: if( ExprHasProperty(pExpr, EP_IntValue) ){
! 1048: sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
! 1049: }else{
! 1050: zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
! 1051: if( zVal==0 ) goto no_mem;
! 1052: sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
! 1053: if( op==TK_FLOAT ) pVal->type = SQLITE_FLOAT;
! 1054: }
! 1055: if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
! 1056: sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);
! 1057: }else{
! 1058: sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
! 1059: }
! 1060: if( pVal->flags & (MEM_Int|MEM_Real) ) pVal->flags &= ~MEM_Str;
! 1061: if( enc!=SQLITE_UTF8 ){
! 1062: sqlite3VdbeChangeEncoding(pVal, enc);
! 1063: }
! 1064: }else if( op==TK_UMINUS ) {
! 1065: /* This branch happens for multiple negative signs. Ex: -(-5) */
! 1066: if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){
! 1067: sqlite3VdbeMemNumerify(pVal);
! 1068: if( pVal->u.i==SMALLEST_INT64 ){
! 1069: pVal->flags &= MEM_Int;
! 1070: pVal->flags |= MEM_Real;
! 1071: pVal->r = (double)LARGEST_INT64;
! 1072: }else{
! 1073: pVal->u.i = -pVal->u.i;
! 1074: }
! 1075: pVal->r = -pVal->r;
! 1076: sqlite3ValueApplyAffinity(pVal, affinity, enc);
! 1077: }
! 1078: }else if( op==TK_NULL ){
! 1079: pVal = sqlite3ValueNew(db);
! 1080: if( pVal==0 ) goto no_mem;
! 1081: }
! 1082: #ifndef SQLITE_OMIT_BLOB_LITERAL
! 1083: else if( op==TK_BLOB ){
! 1084: int nVal;
! 1085: assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
! 1086: assert( pExpr->u.zToken[1]=='\'' );
! 1087: pVal = sqlite3ValueNew(db);
! 1088: if( !pVal ) goto no_mem;
! 1089: zVal = &pExpr->u.zToken[2];
! 1090: nVal = sqlite3Strlen30(zVal)-1;
! 1091: assert( zVal[nVal]=='\'' );
! 1092: sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
! 1093: 0, SQLITE_DYNAMIC);
! 1094: }
! 1095: #endif
! 1096:
! 1097: if( pVal ){
! 1098: sqlite3VdbeMemStoreType(pVal);
! 1099: }
! 1100: *ppVal = pVal;
! 1101: return SQLITE_OK;
! 1102:
! 1103: no_mem:
! 1104: db->mallocFailed = 1;
! 1105: sqlite3DbFree(db, zVal);
! 1106: sqlite3ValueFree(pVal);
! 1107: *ppVal = 0;
! 1108: return SQLITE_NOMEM;
! 1109: }
! 1110:
! 1111: /*
! 1112: ** Change the string value of an sqlite3_value object
! 1113: */
! 1114: void sqlite3ValueSetStr(
! 1115: sqlite3_value *v, /* Value to be set */
! 1116: int n, /* Length of string z */
! 1117: const void *z, /* Text of the new string */
! 1118: u8 enc, /* Encoding to use */
! 1119: void (*xDel)(void*) /* Destructor for the string */
! 1120: ){
! 1121: if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
! 1122: }
! 1123:
! 1124: /*
! 1125: ** Free an sqlite3_value object
! 1126: */
! 1127: void sqlite3ValueFree(sqlite3_value *v){
! 1128: if( !v ) return;
! 1129: sqlite3VdbeMemRelease((Mem *)v);
! 1130: sqlite3DbFree(((Mem*)v)->db, v);
! 1131: }
! 1132:
! 1133: /*
! 1134: ** Return the number of bytes in the sqlite3_value object assuming
! 1135: ** that it uses the encoding "enc"
! 1136: */
! 1137: int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
! 1138: Mem *p = (Mem*)pVal;
! 1139: if( (p->flags & MEM_Blob)!=0 || sqlite3ValueText(pVal, enc) ){
! 1140: if( p->flags & MEM_Zero ){
! 1141: return p->n + p->u.nZero;
! 1142: }else{
! 1143: return p->n;
! 1144: }
! 1145: }
! 1146: return 0;
! 1147: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to vdbemem.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src