000001 /*
000002 ** 2004 May 26
000003 **
000004 ** The author disclaims copyright to this source code. In place of
000005 ** a legal notice, here is a blessing:
000006 **
000007 ** May you do good and not evil.
000008 ** May you find forgiveness for yourself and forgive others.
000009 ** May you share freely, never taking more than you give.
000010 **
000011 *************************************************************************
000012 **
000013 ** This file contains code use to manipulate "Mem" structure. A "Mem"
000014 ** stores a single value in the VDBE. Mem is an opaque structure visible
000015 ** only within the VDBE. Interface routines refer to a Mem using the
000016 ** name sqlite_value
000017 */
000018 #include "sqliteInt.h"
000019 #include "vdbeInt.h"
000020
000021 /* True if X is a power of two. 0 is considered a power of two here.
000022 ** In other words, return true if X has at most one bit set.
000023 */
000024 #define ISPOWEROF2(X) (((X)&((X)-1))==0)
000025
000026 #ifdef SQLITE_DEBUG
000027 /*
000028 ** Check invariants on a Mem object.
000029 **
000030 ** This routine is intended for use inside of assert() statements, like
000031 ** this: assert( sqlite3VdbeCheckMemInvariants(pMem) );
000032 */
000033 int sqlite3VdbeCheckMemInvariants(Mem *p){
000034 /* If MEM_Dyn is set then Mem.xDel!=0.
000035 ** Mem.xDel might not be initialized if MEM_Dyn is clear.
000036 */
000037 assert( (p->flags & MEM_Dyn)==0 || p->xDel!=0 );
000038
000039 /* MEM_Dyn may only be set if Mem.szMalloc==0. In this way we
000040 ** ensure that if Mem.szMalloc>0 then it is safe to do
000041 ** Mem.z = Mem.zMalloc without having to check Mem.flags&MEM_Dyn.
000042 ** That saves a few cycles in inner loops. */
000043 assert( (p->flags & MEM_Dyn)==0 || p->szMalloc==0 );
000044
000045 /* Cannot have more than one of MEM_Int, MEM_Real, or MEM_IntReal */
000046 assert( ISPOWEROF2(p->flags & (MEM_Int|MEM_Real|MEM_IntReal)) );
000047
000048 if( p->flags & MEM_Null ){
000049 /* Cannot be both MEM_Null and some other type */
000050 assert( (p->flags & (MEM_Int|MEM_Real|MEM_Str|MEM_Blob|MEM_Agg))==0 );
000051
000052 /* If MEM_Null is set, then either the value is a pure NULL (the usual
000053 ** case) or it is a pointer set using sqlite3_bind_pointer() or
000054 ** sqlite3_result_pointer(). If a pointer, then MEM_Term must also be
000055 ** set.
000056 */
000057 if( (p->flags & (MEM_Term|MEM_Subtype))==(MEM_Term|MEM_Subtype) ){
000058 /* This is a pointer type. There may be a flag to indicate what to
000059 ** do with the pointer. */
000060 assert( ((p->flags&MEM_Dyn)!=0 ? 1 : 0) +
000061 ((p->flags&MEM_Ephem)!=0 ? 1 : 0) +
000062 ((p->flags&MEM_Static)!=0 ? 1 : 0) <= 1 );
000063
000064 /* No other bits set */
000065 assert( (p->flags & ~(MEM_Null|MEM_Term|MEM_Subtype|MEM_FromBind
000066 |MEM_Dyn|MEM_Ephem|MEM_Static))==0 );
000067 }else{
000068 /* A pure NULL might have other flags, such as MEM_Static, MEM_Dyn,
000069 ** MEM_Ephem, MEM_Cleared, or MEM_Subtype */
000070 }
000071 }else{
000072 /* The MEM_Cleared bit is only allowed on NULLs */
000073 assert( (p->flags & MEM_Cleared)==0 );
000074 }
000075
000076 /* The szMalloc field holds the correct memory allocation size */
000077 assert( p->szMalloc==0
000078 || p->szMalloc==sqlite3DbMallocSize(p->db,p->zMalloc) );
000079
000080 /* If p holds a string or blob, the Mem.z must point to exactly
000081 ** one of the following:
000082 **
000083 ** (1) Memory in Mem.zMalloc and managed by the Mem object
000084 ** (2) Memory to be freed using Mem.xDel
000085 ** (3) An ephemeral string or blob
000086 ** (4) A static string or blob
000087 */
000088 if( (p->flags & (MEM_Str|MEM_Blob)) && p->n>0 ){
000089 assert(
000090 ((p->szMalloc>0 && p->z==p->zMalloc)? 1 : 0) +
000091 ((p->flags&MEM_Dyn)!=0 ? 1 : 0) +
000092 ((p->flags&MEM_Ephem)!=0 ? 1 : 0) +
000093 ((p->flags&MEM_Static)!=0 ? 1 : 0) == 1
000094 );
000095 }
000096 return 1;
000097 }
000098 #endif
000099
000100 /*
000101 ** Render a Mem object which is one of MEM_Int, MEM_Real, or MEM_IntReal
000102 ** into a buffer.
000103 */
000104 static void vdbeMemRenderNum(int sz, char *zBuf, Mem *p){
000105 StrAccum acc;
000106 assert( p->flags & (MEM_Int|MEM_Real|MEM_IntReal) );
000107 sqlite3StrAccumInit(&acc, 0, zBuf, sz, 0);
000108 if( p->flags & MEM_Int ){
000109 sqlite3_str_appendf(&acc, "%lld", p->u.i);
000110 }else if( p->flags & MEM_IntReal ){
000111 sqlite3_str_appendf(&acc, "%!.15g", (double)p->u.i);
000112 }else{
000113 sqlite3_str_appendf(&acc, "%!.15g", p->u.r);
000114 }
000115 assert( acc.zText==zBuf && acc.mxAlloc<=0 );
000116 zBuf[acc.nChar] = 0; /* Fast version of sqlite3StrAccumFinish(&acc) */
000117 }
000118
000119 #ifdef SQLITE_DEBUG
000120 /*
000121 ** Validity checks on pMem. pMem holds a string.
000122 **
000123 ** (1) Check that string value of pMem agrees with its integer or real value.
000124 ** (2) Check that the string is correctly zero terminated
000125 **
000126 ** A single int or real value always converts to the same strings. But
000127 ** many different strings can be converted into the same int or real.
000128 ** If a table contains a numeric value and an index is based on the
000129 ** corresponding string value, then it is important that the string be
000130 ** derived from the numeric value, not the other way around, to ensure
000131 ** that the index and table are consistent. See ticket
000132 ** https://www.sqlite.org/src/info/343634942dd54ab (2018-01-31) for
000133 ** an example.
000134 **
000135 ** This routine looks at pMem to verify that if it has both a numeric
000136 ** representation and a string representation then the string rep has
000137 ** been derived from the numeric and not the other way around. It returns
000138 ** true if everything is ok and false if there is a problem.
000139 **
000140 ** This routine is for use inside of assert() statements only.
000141 */
000142 int sqlite3VdbeMemValidStrRep(Mem *p){
000143 char zBuf[100];
000144 char *z;
000145 int i, j, incr;
000146 if( (p->flags & MEM_Str)==0 ) return 1;
000147 if( p->flags & MEM_Term ){
000148 /* Insure that the string is properly zero-terminated. Pay particular
000149 ** attention to the case where p->n is odd */
000150 if( p->szMalloc>0 && p->z==p->zMalloc ){
000151 assert( p->enc==SQLITE_UTF8 || p->szMalloc >= ((p->n+1)&~1)+2 );
000152 assert( p->enc!=SQLITE_UTF8 || p->szMalloc >= p->n+1 );
000153 }
000154 assert( p->z[p->n]==0 );
000155 assert( p->enc==SQLITE_UTF8 || p->z[(p->n+1)&~1]==0 );
000156 assert( p->enc==SQLITE_UTF8 || p->z[((p->n+1)&~1)+1]==0 );
000157 }
000158 if( (p->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 ) return 1;
000159 vdbeMemRenderNum(sizeof(zBuf), zBuf, p);
000160 z = p->z;
000161 i = j = 0;
000162 incr = 1;
000163 if( p->enc!=SQLITE_UTF8 ){
000164 incr = 2;
000165 if( p->enc==SQLITE_UTF16BE ) z++;
000166 }
000167 while( zBuf[j] ){
000168 if( zBuf[j++]!=z[i] ) return 0;
000169 i += incr;
000170 }
000171 return 1;
000172 }
000173 #endif /* SQLITE_DEBUG */
000174
000175 /*
000176 ** If pMem is an object with a valid string representation, this routine
000177 ** ensures the internal encoding for the string representation is
000178 ** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE.
000179 **
000180 ** If pMem is not a string object, or the encoding of the string
000181 ** representation is already stored using the requested encoding, then this
000182 ** routine is a no-op.
000183 **
000184 ** SQLITE_OK is returned if the conversion is successful (or not required).
000185 ** SQLITE_NOMEM may be returned if a malloc() fails during conversion
000186 ** between formats.
000187 */
000188 int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
000189 #ifndef SQLITE_OMIT_UTF16
000190 int rc;
000191 #endif
000192 assert( !sqlite3VdbeMemIsRowSet(pMem) );
000193 assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE
000194 || desiredEnc==SQLITE_UTF16BE );
000195 if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
000196 return SQLITE_OK;
000197 }
000198 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
000199 #ifdef SQLITE_OMIT_UTF16
000200 return SQLITE_ERROR;
000201 #else
000202
000203 /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
000204 ** then the encoding of the value may not have changed.
000205 */
000206 rc = sqlite3VdbeMemTranslate(pMem, (u8)desiredEnc);
000207 assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
000208 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
000209 assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
000210 return rc;
000211 #endif
000212 }
000213
000214 /*
000215 ** Make sure pMem->z points to a writable allocation of at least n bytes.
000216 **
000217 ** If the bPreserve argument is true, then copy of the content of
000218 ** pMem->z into the new allocation. pMem must be either a string or
000219 ** blob if bPreserve is true. If bPreserve is false, any prior content
000220 ** in pMem->z is discarded.
000221 */
000222 SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){
000223 assert( sqlite3VdbeCheckMemInvariants(pMem) );
000224 assert( !sqlite3VdbeMemIsRowSet(pMem) );
000225 testcase( pMem->db==0 );
000226
000227 /* If the bPreserve flag is set to true, then the memory cell must already
000228 ** contain a valid string or blob value. */
000229 assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
000230 testcase( bPreserve && pMem->z==0 );
000231
000232 assert( pMem->szMalloc==0
000233 || pMem->szMalloc==sqlite3DbMallocSize(pMem->db, pMem->zMalloc) );
000234 if( pMem->szMalloc>0 && bPreserve && pMem->z==pMem->zMalloc ){
000235 if( pMem->db ){
000236 pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
000237 }else{
000238 pMem->zMalloc = sqlite3Realloc(pMem->z, n);
000239 if( pMem->zMalloc==0 ) sqlite3_free(pMem->z);
000240 pMem->z = pMem->zMalloc;
000241 }
000242 bPreserve = 0;
000243 }else{
000244 if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
000245 pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
000246 }
000247 if( pMem->zMalloc==0 ){
000248 sqlite3VdbeMemSetNull(pMem);
000249 pMem->z = 0;
000250 pMem->szMalloc = 0;
000251 return SQLITE_NOMEM_BKPT;
000252 }else{
000253 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
000254 }
000255
000256 if( bPreserve && pMem->z ){
000257 assert( pMem->z!=pMem->zMalloc );
000258 memcpy(pMem->zMalloc, pMem->z, pMem->n);
000259 }
000260 if( (pMem->flags&MEM_Dyn)!=0 ){
000261 assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC );
000262 pMem->xDel((void *)(pMem->z));
000263 }
000264
000265 pMem->z = pMem->zMalloc;
000266 pMem->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Static);
000267 return SQLITE_OK;
000268 }
000269
000270 /*
000271 ** Change the pMem->zMalloc allocation to be at least szNew bytes.
000272 ** If pMem->zMalloc already meets or exceeds the requested size, this
000273 ** routine is a no-op.
000274 **
000275 ** Any prior string or blob content in the pMem object may be discarded.
000276 ** The pMem->xDel destructor is called, if it exists. Though MEM_Str
000277 ** and MEM_Blob values may be discarded, MEM_Int, MEM_Real, MEM_IntReal,
000278 ** and MEM_Null values are preserved.
000279 **
000280 ** Return SQLITE_OK on success or an error code (probably SQLITE_NOMEM)
000281 ** if unable to complete the resizing.
000282 */
000283 int sqlite3VdbeMemClearAndResize(Mem *pMem, int szNew){
000284 assert( CORRUPT_DB || szNew>0 );
000285 assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 );
000286 if( pMem->szMalloc<szNew ){
000287 return sqlite3VdbeMemGrow(pMem, szNew, 0);
000288 }
000289 assert( (pMem->flags & MEM_Dyn)==0 );
000290 pMem->z = pMem->zMalloc;
000291 pMem->flags &= (MEM_Null|MEM_Int|MEM_Real|MEM_IntReal);
000292 return SQLITE_OK;
000293 }
000294
000295 /*
000296 ** It is already known that pMem contains an unterminated string.
000297 ** Add the zero terminator.
000298 **
000299 ** Three bytes of zero are added. In this way, there is guaranteed
000300 ** to be a double-zero byte at an even byte boundary in order to
000301 ** terminate a UTF16 string, even if the initial size of the buffer
000302 ** is an odd number of bytes.
000303 */
000304 static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){
000305 if( sqlite3VdbeMemGrow(pMem, pMem->n+3, 1) ){
000306 return SQLITE_NOMEM_BKPT;
000307 }
000308 pMem->z[pMem->n] = 0;
000309 pMem->z[pMem->n+1] = 0;
000310 pMem->z[pMem->n+2] = 0;
000311 pMem->flags |= MEM_Term;
000312 return SQLITE_OK;
000313 }
000314
000315 /*
000316 ** Change pMem so that its MEM_Str or MEM_Blob value is stored in
000317 ** MEM.zMalloc, where it can be safely written.
000318 **
000319 ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
000320 */
000321 int sqlite3VdbeMemMakeWriteable(Mem *pMem){
000322 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
000323 assert( !sqlite3VdbeMemIsRowSet(pMem) );
000324 if( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ){
000325 if( ExpandBlob(pMem) ) return SQLITE_NOMEM;
000326 if( pMem->szMalloc==0 || pMem->z!=pMem->zMalloc ){
000327 int rc = vdbeMemAddTerminator(pMem);
000328 if( rc ) return rc;
000329 }
000330 }
000331 pMem->flags &= ~MEM_Ephem;
000332 #ifdef SQLITE_DEBUG
000333 pMem->pScopyFrom = 0;
000334 #endif
000335
000336 return SQLITE_OK;
000337 }
000338
000339 /*
000340 ** If the given Mem* has a zero-filled tail, turn it into an ordinary
000341 ** blob stored in dynamically allocated space.
000342 */
000343 #ifndef SQLITE_OMIT_INCRBLOB
000344 int sqlite3VdbeMemExpandBlob(Mem *pMem){
000345 int nByte;
000346 assert( pMem->flags & MEM_Zero );
000347 assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) );
000348 testcase( sqlite3_value_nochange(pMem) );
000349 assert( !sqlite3VdbeMemIsRowSet(pMem) );
000350 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
000351
000352 /* Set nByte to the number of bytes required to store the expanded blob. */
000353 nByte = pMem->n + pMem->u.nZero;
000354 if( nByte<=0 ){
000355 if( (pMem->flags & MEM_Blob)==0 ) return SQLITE_OK;
000356 nByte = 1;
000357 }
000358 if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
000359 return SQLITE_NOMEM_BKPT;
000360 }
000361
000362 memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
000363 pMem->n += pMem->u.nZero;
000364 pMem->flags &= ~(MEM_Zero|MEM_Term);
000365 return SQLITE_OK;
000366 }
000367 #endif
000368
000369 /*
000370 ** Make sure the given Mem is \u0000 terminated.
000371 */
000372 int sqlite3VdbeMemNulTerminate(Mem *pMem){
000373 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
000374 testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) );
000375 testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 );
000376 if( (pMem->flags & (MEM_Term|MEM_Str))!=MEM_Str ){
000377 return SQLITE_OK; /* Nothing to do */
000378 }else{
000379 return vdbeMemAddTerminator(pMem);
000380 }
000381 }
000382
000383 /*
000384 ** Add MEM_Str to the set of representations for the given Mem. This
000385 ** routine is only called if pMem is a number of some kind, not a NULL
000386 ** or a BLOB.
000387 **
000388 ** Existing representations MEM_Int, MEM_Real, or MEM_IntReal are invalidated
000389 ** if bForce is true but are retained if bForce is false.
000390 **
000391 ** A MEM_Null value will never be passed to this function. This function is
000392 ** used for converting values to text for returning to the user (i.e. via
000393 ** sqlite3_value_text()), or for ensuring that values to be used as btree
000394 ** keys are strings. In the former case a NULL pointer is returned the
000395 ** user and the latter is an internal programming error.
000396 */
000397 int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){
000398 const int nByte = 32;
000399
000400 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
000401 assert( !(pMem->flags&MEM_Zero) );
000402 assert( !(pMem->flags&(MEM_Str|MEM_Blob)) );
000403 assert( pMem->flags&(MEM_Int|MEM_Real|MEM_IntReal) );
000404 assert( !sqlite3VdbeMemIsRowSet(pMem) );
000405 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
000406
000407
000408 if( sqlite3VdbeMemClearAndResize(pMem, nByte) ){
000409 pMem->enc = 0;
000410 return SQLITE_NOMEM_BKPT;
000411 }
000412
000413 vdbeMemRenderNum(nByte, pMem->z, pMem);
000414 assert( pMem->z!=0 );
000415 pMem->n = sqlite3Strlen30NN(pMem->z);
000416 pMem->enc = SQLITE_UTF8;
000417 pMem->flags |= MEM_Str|MEM_Term;
000418 if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal);
000419 sqlite3VdbeChangeEncoding(pMem, enc);
000420 return SQLITE_OK;
000421 }
000422
000423 /*
000424 ** Memory cell pMem contains the context of an aggregate function.
000425 ** This routine calls the finalize method for that function. The
000426 ** result of the aggregate is stored back into pMem.
000427 **
000428 ** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK
000429 ** otherwise.
000430 */
000431 int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
000432 sqlite3_context ctx;
000433 Mem t;
000434 assert( pFunc!=0 );
000435 assert( pFunc->xFinalize!=0 );
000436 assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
000437 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
000438 memset(&ctx, 0, sizeof(ctx));
000439 memset(&t, 0, sizeof(t));
000440 t.flags = MEM_Null;
000441 t.db = pMem->db;
000442 ctx.pOut = &t;
000443 ctx.pMem = pMem;
000444 ctx.pFunc = pFunc;
000445 pFunc->xFinalize(&ctx); /* IMP: R-24505-23230 */
000446 assert( (pMem->flags & MEM_Dyn)==0 );
000447 if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
000448 memcpy(pMem, &t, sizeof(t));
000449 return ctx.isError;
000450 }
000451
000452 /*
000453 ** Memory cell pAccum contains the context of an aggregate function.
000454 ** This routine calls the xValue method for that function and stores
000455 ** the results in memory cell pMem.
000456 **
000457 ** SQLITE_ERROR is returned if xValue() reports an error. SQLITE_OK
000458 ** otherwise.
000459 */
000460 #ifndef SQLITE_OMIT_WINDOWFUNC
000461 int sqlite3VdbeMemAggValue(Mem *pAccum, Mem *pOut, FuncDef *pFunc){
000462 sqlite3_context ctx;
000463 assert( pFunc!=0 );
000464 assert( pFunc->xValue!=0 );
000465 assert( (pAccum->flags & MEM_Null)!=0 || pFunc==pAccum->u.pDef );
000466 assert( pAccum->db==0 || sqlite3_mutex_held(pAccum->db->mutex) );
000467 memset(&ctx, 0, sizeof(ctx));
000468 sqlite3VdbeMemSetNull(pOut);
000469 ctx.pOut = pOut;
000470 ctx.pMem = pAccum;
000471 ctx.pFunc = pFunc;
000472 pFunc->xValue(&ctx);
000473 return ctx.isError;
000474 }
000475 #endif /* SQLITE_OMIT_WINDOWFUNC */
000476
000477 /*
000478 ** If the memory cell contains a value that must be freed by
000479 ** invoking the external callback in Mem.xDel, then this routine
000480 ** will free that value. It also sets Mem.flags to MEM_Null.
000481 **
000482 ** This is a helper routine for sqlite3VdbeMemSetNull() and
000483 ** for sqlite3VdbeMemRelease(). Use those other routines as the
000484 ** entry point for releasing Mem resources.
000485 */
000486 static SQLITE_NOINLINE void vdbeMemClearExternAndSetNull(Mem *p){
000487 assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
000488 assert( VdbeMemDynamic(p) );
000489 if( p->flags&MEM_Agg ){
000490 sqlite3VdbeMemFinalize(p, p->u.pDef);
000491 assert( (p->flags & MEM_Agg)==0 );
000492 testcase( p->flags & MEM_Dyn );
000493 }
000494 if( p->flags&MEM_Dyn ){
000495 assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 );
000496 p->xDel((void *)p->z);
000497 }
000498 p->flags = MEM_Null;
000499 }
000500
000501 /*
000502 ** Release memory held by the Mem p, both external memory cleared
000503 ** by p->xDel and memory in p->zMalloc.
000504 **
000505 ** This is a helper routine invoked by sqlite3VdbeMemRelease() in
000506 ** the unusual case where there really is memory in p that needs
000507 ** to be freed.
000508 */
000509 static SQLITE_NOINLINE void vdbeMemClear(Mem *p){
000510 if( VdbeMemDynamic(p) ){
000511 vdbeMemClearExternAndSetNull(p);
000512 }
000513 if( p->szMalloc ){
000514 sqlite3DbFreeNN(p->db, p->zMalloc);
000515 p->szMalloc = 0;
000516 }
000517 p->z = 0;
000518 }
000519
000520 /*
000521 ** Release any memory resources held by the Mem. Both the memory that is
000522 ** free by Mem.xDel and the Mem.zMalloc allocation are freed.
000523 **
000524 ** Use this routine prior to clean up prior to abandoning a Mem, or to
000525 ** reset a Mem back to its minimum memory utilization.
000526 **
000527 ** Use sqlite3VdbeMemSetNull() to release just the Mem.xDel space
000528 ** prior to inserting new content into the Mem.
000529 */
000530 void sqlite3VdbeMemRelease(Mem *p){
000531 assert( sqlite3VdbeCheckMemInvariants(p) );
000532 if( VdbeMemDynamic(p) || p->szMalloc ){
000533 vdbeMemClear(p);
000534 }
000535 }
000536
000537 /*
000538 ** Convert a 64-bit IEEE double into a 64-bit signed integer.
000539 ** If the double is out of range of a 64-bit signed integer then
000540 ** return the closest available 64-bit signed integer.
000541 */
000542 static SQLITE_NOINLINE i64 doubleToInt64(double r){
000543 #ifdef SQLITE_OMIT_FLOATING_POINT
000544 /* When floating-point is omitted, double and int64 are the same thing */
000545 return r;
000546 #else
000547 /*
000548 ** Many compilers we encounter do not define constants for the
000549 ** minimum and maximum 64-bit integers, or they define them
000550 ** inconsistently. And many do not understand the "LL" notation.
000551 ** So we define our own static constants here using nothing
000552 ** larger than a 32-bit integer constant.
000553 */
000554 static const i64 maxInt = LARGEST_INT64;
000555 static const i64 minInt = SMALLEST_INT64;
000556
000557 if( r<=(double)minInt ){
000558 return minInt;
000559 }else if( r>=(double)maxInt ){
000560 return maxInt;
000561 }else{
000562 return (i64)r;
000563 }
000564 #endif
000565 }
000566
000567 /*
000568 ** Return some kind of integer value which is the best we can do
000569 ** at representing the value that *pMem describes as an integer.
000570 ** If pMem is an integer, then the value is exact. If pMem is
000571 ** a floating-point then the value returned is the integer part.
000572 ** If pMem is a string or blob, then we make an attempt to convert
000573 ** it into an integer and return that. If pMem represents an
000574 ** an SQL-NULL value, return 0.
000575 **
000576 ** If pMem represents a string value, its encoding might be changed.
000577 */
000578 static SQLITE_NOINLINE i64 memIntValue(Mem *pMem){
000579 i64 value = 0;
000580 sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
000581 return value;
000582 }
000583 i64 sqlite3VdbeIntValue(Mem *pMem){
000584 int flags;
000585 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
000586 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
000587 flags = pMem->flags;
000588 if( flags & (MEM_Int|MEM_IntReal) ){
000589 testcase( flags & MEM_IntReal );
000590 return pMem->u.i;
000591 }else if( flags & MEM_Real ){
000592 return doubleToInt64(pMem->u.r);
000593 }else if( (flags & (MEM_Str|MEM_Blob))!=0 && pMem->z!=0 ){
000594 return memIntValue(pMem);
000595 }else{
000596 return 0;
000597 }
000598 }
000599
000600 /*
000601 ** Return the best representation of pMem that we can get into a
000602 ** double. If pMem is already a double or an integer, return its
000603 ** value. If it is a string or blob, try to convert it to a double.
000604 ** If it is a NULL, return 0.0.
000605 */
000606 static SQLITE_NOINLINE double memRealValue(Mem *pMem){
000607 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
000608 double val = (double)0;
000609 sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc);
000610 return val;
000611 }
000612 double sqlite3VdbeRealValue(Mem *pMem){
000613 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
000614 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
000615 if( pMem->flags & MEM_Real ){
000616 return pMem->u.r;
000617 }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){
000618 testcase( pMem->flags & MEM_IntReal );
000619 return (double)pMem->u.i;
000620 }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
000621 return memRealValue(pMem);
000622 }else{
000623 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
000624 return (double)0;
000625 }
000626 }
000627
000628 /*
000629 ** Return 1 if pMem represents true, and return 0 if pMem represents false.
000630 ** Return the value ifNull if pMem is NULL.
000631 */
000632 int sqlite3VdbeBooleanValue(Mem *pMem, int ifNull){
000633 testcase( pMem->flags & MEM_IntReal );
000634 if( pMem->flags & (MEM_Int|MEM_IntReal) ) return pMem->u.i!=0;
000635 if( pMem->flags & MEM_Null ) return ifNull;
000636 return sqlite3VdbeRealValue(pMem)!=0.0;
000637 }
000638
000639 /*
000640 ** The MEM structure is already a MEM_Real. Try to also make it a
000641 ** MEM_Int if we can.
000642 */
000643 void sqlite3VdbeIntegerAffinity(Mem *pMem){
000644 i64 ix;
000645 assert( pMem->flags & MEM_Real );
000646 assert( !sqlite3VdbeMemIsRowSet(pMem) );
000647 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
000648 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
000649
000650 ix = doubleToInt64(pMem->u.r);
000651
000652 /* Only mark the value as an integer if
000653 **
000654 ** (1) the round-trip conversion real->int->real is a no-op, and
000655 ** (2) The integer is neither the largest nor the smallest
000656 ** possible integer (ticket #3922)
000657 **
000658 ** The second and third terms in the following conditional enforces
000659 ** the second condition under the assumption that addition overflow causes
000660 ** values to wrap around.
000661 */
000662 if( pMem->u.r==ix && ix>SMALLEST_INT64 && ix<LARGEST_INT64 ){
000663 pMem->u.i = ix;
000664 MemSetTypeFlag(pMem, MEM_Int);
000665 }
000666 }
000667
000668 /*
000669 ** Convert pMem to type integer. Invalidate any prior representations.
000670 */
000671 int sqlite3VdbeMemIntegerify(Mem *pMem){
000672 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
000673 assert( !sqlite3VdbeMemIsRowSet(pMem) );
000674 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
000675
000676 pMem->u.i = sqlite3VdbeIntValue(pMem);
000677 MemSetTypeFlag(pMem, MEM_Int);
000678 return SQLITE_OK;
000679 }
000680
000681 /*
000682 ** Convert pMem so that it is of type MEM_Real.
000683 ** Invalidate any prior representations.
000684 */
000685 int sqlite3VdbeMemRealify(Mem *pMem){
000686 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
000687 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
000688
000689 pMem->u.r = sqlite3VdbeRealValue(pMem);
000690 MemSetTypeFlag(pMem, MEM_Real);
000691 return SQLITE_OK;
000692 }
000693
000694 /* Compare a floating point value to an integer. Return true if the two
000695 ** values are the same within the precision of the floating point value.
000696 **
000697 ** This function assumes that i was obtained by assignment from r1.
000698 **
000699 ** For some versions of GCC on 32-bit machines, if you do the more obvious
000700 ** comparison of "r1==(double)i" you sometimes get an answer of false even
000701 ** though the r1 and (double)i values are bit-for-bit the same.
000702 */
000703 int sqlite3RealSameAsInt(double r1, sqlite3_int64 i){
000704 double r2 = (double)i;
000705 return r1==0.0
000706 || (memcmp(&r1, &r2, sizeof(r1))==0
000707 && i >= -2251799813685248LL && i < 2251799813685248LL);
000708 }
000709
000710 /*
000711 ** Convert pMem so that it has type MEM_Real or MEM_Int.
000712 ** Invalidate any prior representations.
000713 **
000714 ** Every effort is made to force the conversion, even if the input
000715 ** is a string that does not look completely like a number. Convert
000716 ** as much of the string as we can and ignore the rest.
000717 */
000718 int sqlite3VdbeMemNumerify(Mem *pMem){
000719 testcase( pMem->flags & MEM_Int );
000720 testcase( pMem->flags & MEM_Real );
000721 testcase( pMem->flags & MEM_IntReal );
000722 testcase( pMem->flags & MEM_Null );
000723 if( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))==0 ){
000724 int rc;
000725 sqlite3_int64 ix;
000726 assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
000727 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
000728 rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
000729 if( ((rc==0 || rc==1) && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1)
000730 || sqlite3RealSameAsInt(pMem->u.r, (ix = (i64)pMem->u.r))
000731 ){
000732 pMem->u.i = ix;
000733 MemSetTypeFlag(pMem, MEM_Int);
000734 }else{
000735 MemSetTypeFlag(pMem, MEM_Real);
000736 }
000737 }
000738 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))!=0 );
000739 pMem->flags &= ~(MEM_Str|MEM_Blob|MEM_Zero);
000740 return SQLITE_OK;
000741 }
000742
000743 /*
000744 ** Cast the datatype of the value in pMem according to the affinity
000745 ** "aff". Casting is different from applying affinity in that a cast
000746 ** is forced. In other words, the value is converted into the desired
000747 ** affinity even if that results in loss of data. This routine is
000748 ** used (for example) to implement the SQL "cast()" operator.
000749 */
000750 int sqlite3VdbeMemCast(Mem *pMem, u8 aff, u8 encoding){
000751 if( pMem->flags & MEM_Null ) return SQLITE_OK;
000752 switch( aff ){
000753 case SQLITE_AFF_BLOB: { /* Really a cast to BLOB */
000754 if( (pMem->flags & MEM_Blob)==0 ){
000755 sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding);
000756 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
000757 if( pMem->flags & MEM_Str ) MemSetTypeFlag(pMem, MEM_Blob);
000758 }else{
000759 pMem->flags &= ~(MEM_TypeMask&~MEM_Blob);
000760 }
000761 break;
000762 }
000763 case SQLITE_AFF_NUMERIC: {
000764 sqlite3VdbeMemNumerify(pMem);
000765 break;
000766 }
000767 case SQLITE_AFF_INTEGER: {
000768 sqlite3VdbeMemIntegerify(pMem);
000769 break;
000770 }
000771 case SQLITE_AFF_REAL: {
000772 sqlite3VdbeMemRealify(pMem);
000773 break;
000774 }
000775 default: {
000776 assert( aff==SQLITE_AFF_TEXT );
000777 assert( MEM_Str==(MEM_Blob>>3) );
000778 pMem->flags |= (pMem->flags&MEM_Blob)>>3;
000779 sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding);
000780 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
000781 pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal|MEM_Blob|MEM_Zero);
000782 return sqlite3VdbeChangeEncoding(pMem, encoding);
000783 }
000784 }
000785 return SQLITE_OK;
000786 }
000787
000788 /*
000789 ** Initialize bulk memory to be a consistent Mem object.
000790 **
000791 ** The minimum amount of initialization feasible is performed.
000792 */
000793 void sqlite3VdbeMemInit(Mem *pMem, sqlite3 *db, u16 flags){
000794 assert( (flags & ~MEM_TypeMask)==0 );
000795 pMem->flags = flags;
000796 pMem->db = db;
000797 pMem->szMalloc = 0;
000798 }
000799
000800
000801 /*
000802 ** Delete any previous value and set the value stored in *pMem to NULL.
000803 **
000804 ** This routine calls the Mem.xDel destructor to dispose of values that
000805 ** require the destructor. But it preserves the Mem.zMalloc memory allocation.
000806 ** To free all resources, use sqlite3VdbeMemRelease(), which both calls this
000807 ** routine to invoke the destructor and deallocates Mem.zMalloc.
000808 **
000809 ** Use this routine to reset the Mem prior to insert a new value.
000810 **
000811 ** Use sqlite3VdbeMemRelease() to complete erase the Mem prior to abandoning it.
000812 */
000813 void sqlite3VdbeMemSetNull(Mem *pMem){
000814 if( VdbeMemDynamic(pMem) ){
000815 vdbeMemClearExternAndSetNull(pMem);
000816 }else{
000817 pMem->flags = MEM_Null;
000818 }
000819 }
000820 void sqlite3ValueSetNull(sqlite3_value *p){
000821 sqlite3VdbeMemSetNull((Mem*)p);
000822 }
000823
000824 /*
000825 ** Delete any previous value and set the value to be a BLOB of length
000826 ** n containing all zeros.
000827 */
000828 void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
000829 sqlite3VdbeMemRelease(pMem);
000830 pMem->flags = MEM_Blob|MEM_Zero;
000831 pMem->n = 0;
000832 if( n<0 ) n = 0;
000833 pMem->u.nZero = n;
000834 pMem->enc = SQLITE_UTF8;
000835 pMem->z = 0;
000836 }
000837
000838 /*
000839 ** The pMem is known to contain content that needs to be destroyed prior
000840 ** to a value change. So invoke the destructor, then set the value to
000841 ** a 64-bit integer.
000842 */
000843 static SQLITE_NOINLINE void vdbeReleaseAndSetInt64(Mem *pMem, i64 val){
000844 sqlite3VdbeMemSetNull(pMem);
000845 pMem->u.i = val;
000846 pMem->flags = MEM_Int;
000847 }
000848
000849 /*
000850 ** Delete any previous value and set the value stored in *pMem to val,
000851 ** manifest type INTEGER.
000852 */
000853 void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
000854 if( VdbeMemDynamic(pMem) ){
000855 vdbeReleaseAndSetInt64(pMem, val);
000856 }else{
000857 pMem->u.i = val;
000858 pMem->flags = MEM_Int;
000859 }
000860 }
000861
000862 /* A no-op destructor */
000863 void sqlite3NoopDestructor(void *p){ UNUSED_PARAMETER(p); }
000864
000865 /*
000866 ** Set the value stored in *pMem should already be a NULL.
000867 ** Also store a pointer to go with it.
000868 */
000869 void sqlite3VdbeMemSetPointer(
000870 Mem *pMem,
000871 void *pPtr,
000872 const char *zPType,
000873 void (*xDestructor)(void*)
000874 ){
000875 assert( pMem->flags==MEM_Null );
000876 pMem->u.zPType = zPType ? zPType : "";
000877 pMem->z = pPtr;
000878 pMem->flags = MEM_Null|MEM_Dyn|MEM_Subtype|MEM_Term;
000879 pMem->eSubtype = 'p';
000880 pMem->xDel = xDestructor ? xDestructor : sqlite3NoopDestructor;
000881 }
000882
000883 #ifndef SQLITE_OMIT_FLOATING_POINT
000884 /*
000885 ** Delete any previous value and set the value stored in *pMem to val,
000886 ** manifest type REAL.
000887 */
000888 void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
000889 sqlite3VdbeMemSetNull(pMem);
000890 if( !sqlite3IsNaN(val) ){
000891 pMem->u.r = val;
000892 pMem->flags = MEM_Real;
000893 }
000894 }
000895 #endif
000896
000897 #ifdef SQLITE_DEBUG
000898 /*
000899 ** Return true if the Mem holds a RowSet object. This routine is intended
000900 ** for use inside of assert() statements.
000901 */
000902 int sqlite3VdbeMemIsRowSet(const Mem *pMem){
000903 return (pMem->flags&(MEM_Blob|MEM_Dyn))==(MEM_Blob|MEM_Dyn)
000904 && pMem->xDel==sqlite3RowSetDelete;
000905 }
000906 #endif
000907
000908 /*
000909 ** Delete any previous value and set the value of pMem to be an
000910 ** empty boolean index.
000911 **
000912 ** Return SQLITE_OK on success and SQLITE_NOMEM if a memory allocation
000913 ** error occurs.
000914 */
000915 int sqlite3VdbeMemSetRowSet(Mem *pMem){
000916 sqlite3 *db = pMem->db;
000917 RowSet *p;
000918 assert( db!=0 );
000919 assert( !sqlite3VdbeMemIsRowSet(pMem) );
000920 sqlite3VdbeMemRelease(pMem);
000921 p = sqlite3RowSetInit(db);
000922 if( p==0 ) return SQLITE_NOMEM;
000923 pMem->z = (char*)p;
000924 pMem->flags = MEM_Blob|MEM_Dyn;
000925 pMem->xDel = sqlite3RowSetDelete;
000926 return SQLITE_OK;
000927 }
000928
000929 /*
000930 ** Return true if the Mem object contains a TEXT or BLOB that is
000931 ** too large - whose size exceeds SQLITE_MAX_LENGTH.
000932 */
000933 int sqlite3VdbeMemTooBig(Mem *p){
000934 assert( p->db!=0 );
000935 if( p->flags & (MEM_Str|MEM_Blob) ){
000936 int n = p->n;
000937 if( p->flags & MEM_Zero ){
000938 n += p->u.nZero;
000939 }
000940 return n>p->db->aLimit[SQLITE_LIMIT_LENGTH];
000941 }
000942 return 0;
000943 }
000944
000945 #ifdef SQLITE_DEBUG
000946 /*
000947 ** This routine prepares a memory cell for modification by breaking
000948 ** its link to a shallow copy and by marking any current shallow
000949 ** copies of this cell as invalid.
000950 **
000951 ** This is used for testing and debugging only - to make sure shallow
000952 ** copies are not misused.
000953 */
000954 void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
000955 int i;
000956 Mem *pX;
000957 for(i=0, pX=pVdbe->aMem; i<pVdbe->nMem; i++, pX++){
000958 if( pX->pScopyFrom==pMem ){
000959 /* If pX is marked as a shallow copy of pMem, then verify that
000960 ** no significant changes have been made to pX since the OP_SCopy.
000961 ** A significant change would indicated a missed call to this
000962 ** function for pX. Minor changes, such as adding or removing a
000963 ** dual type, are allowed, as long as the underlying value is the
000964 ** same. */
000965 u16 mFlags = pMem->flags & pX->flags & pX->mScopyFlags;
000966 assert( (mFlags&(MEM_Int|MEM_IntReal))==0 || pMem->u.i==pX->u.i );
000967 assert( (mFlags&MEM_Real)==0 || pMem->u.r==pX->u.r );
000968 assert( (mFlags&MEM_Str)==0 || (pMem->n==pX->n && pMem->z==pX->z) );
000969 assert( (mFlags&MEM_Blob)==0 || sqlite3BlobCompare(pMem,pX)==0 );
000970
000971 /* pMem is the register that is changing. But also mark pX as
000972 ** undefined so that we can quickly detect the shallow-copy error */
000973 pX->flags = MEM_Undefined;
000974 pX->pScopyFrom = 0;
000975 }
000976 }
000977 pMem->pScopyFrom = 0;
000978 }
000979 #endif /* SQLITE_DEBUG */
000980
000981
000982 /*
000983 ** Make an shallow copy of pFrom into pTo. Prior contents of
000984 ** pTo are freed. The pFrom->z field is not duplicated. If
000985 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
000986 ** and flags gets srcType (either MEM_Ephem or MEM_Static).
000987 */
000988 static SQLITE_NOINLINE void vdbeClrCopy(Mem *pTo, const Mem *pFrom, int eType){
000989 vdbeMemClearExternAndSetNull(pTo);
000990 assert( !VdbeMemDynamic(pTo) );
000991 sqlite3VdbeMemShallowCopy(pTo, pFrom, eType);
000992 }
000993 void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
000994 assert( !sqlite3VdbeMemIsRowSet(pFrom) );
000995 assert( pTo->db==pFrom->db );
000996 if( VdbeMemDynamic(pTo) ){ vdbeClrCopy(pTo,pFrom,srcType); return; }
000997 memcpy(pTo, pFrom, MEMCELLSIZE);
000998 if( (pFrom->flags&MEM_Static)==0 ){
000999 pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
001000 assert( srcType==MEM_Ephem || srcType==MEM_Static );
001001 pTo->flags |= srcType;
001002 }
001003 }
001004
001005 /*
001006 ** Make a full copy of pFrom into pTo. Prior contents of pTo are
001007 ** freed before the copy is made.
001008 */
001009 int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
001010 int rc = SQLITE_OK;
001011
001012 assert( !sqlite3VdbeMemIsRowSet(pFrom) );
001013 if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(pTo);
001014 memcpy(pTo, pFrom, MEMCELLSIZE);
001015 pTo->flags &= ~MEM_Dyn;
001016 if( pTo->flags&(MEM_Str|MEM_Blob) ){
001017 if( 0==(pFrom->flags&MEM_Static) ){
001018 pTo->flags |= MEM_Ephem;
001019 rc = sqlite3VdbeMemMakeWriteable(pTo);
001020 }
001021 }
001022
001023 return rc;
001024 }
001025
001026 /*
001027 ** Transfer the contents of pFrom to pTo. Any existing value in pTo is
001028 ** freed. If pFrom contains ephemeral data, a copy is made.
001029 **
001030 ** pFrom contains an SQL NULL when this routine returns.
001031 */
001032 void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
001033 assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
001034 assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
001035 assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
001036
001037 sqlite3VdbeMemRelease(pTo);
001038 memcpy(pTo, pFrom, sizeof(Mem));
001039 pFrom->flags = MEM_Null;
001040 pFrom->szMalloc = 0;
001041 }
001042
001043 /*
001044 ** Change the value of a Mem to be a string or a BLOB.
001045 **
001046 ** The memory management strategy depends on the value of the xDel
001047 ** parameter. If the value passed is SQLITE_TRANSIENT, then the
001048 ** string is copied into a (possibly existing) buffer managed by the
001049 ** Mem structure. Otherwise, any existing buffer is freed and the
001050 ** pointer copied.
001051 **
001052 ** If the string is too large (if it exceeds the SQLITE_LIMIT_LENGTH
001053 ** size limit) then no memory allocation occurs. If the string can be
001054 ** stored without allocating memory, then it is. If a memory allocation
001055 ** is required to store the string, then value of pMem is unchanged. In
001056 ** either case, SQLITE_TOOBIG is returned.
001057 */
001058 int sqlite3VdbeMemSetStr(
001059 Mem *pMem, /* Memory cell to set to string value */
001060 const char *z, /* String pointer */
001061 int n, /* Bytes in string, or negative */
001062 u8 enc, /* Encoding of z. 0 for BLOBs */
001063 void (*xDel)(void*) /* Destructor function */
001064 ){
001065 int nByte = n; /* New value for pMem->n */
001066 int iLimit; /* Maximum allowed string or blob size */
001067 u16 flags = 0; /* New value for pMem->flags */
001068
001069 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
001070 assert( !sqlite3VdbeMemIsRowSet(pMem) );
001071
001072 /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
001073 if( !z ){
001074 sqlite3VdbeMemSetNull(pMem);
001075 return SQLITE_OK;
001076 }
001077
001078 if( pMem->db ){
001079 iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH];
001080 }else{
001081 iLimit = SQLITE_MAX_LENGTH;
001082 }
001083 flags = (enc==0?MEM_Blob:MEM_Str);
001084 if( nByte<0 ){
001085 assert( enc!=0 );
001086 if( enc==SQLITE_UTF8 ){
001087 nByte = 0x7fffffff & (int)strlen(z);
001088 }else{
001089 for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
001090 }
001091 flags |= MEM_Term;
001092 }
001093
001094 /* The following block sets the new values of Mem.z and Mem.xDel. It
001095 ** also sets a flag in local variable "flags" to indicate the memory
001096 ** management (one of MEM_Dyn or MEM_Static).
001097 */
001098 if( xDel==SQLITE_TRANSIENT ){
001099 u32 nAlloc = nByte;
001100 if( flags&MEM_Term ){
001101 nAlloc += (enc==SQLITE_UTF8?1:2);
001102 }
001103 if( nByte>iLimit ){
001104 return sqlite3ErrorToParser(pMem->db, SQLITE_TOOBIG);
001105 }
001106 testcase( nAlloc==0 );
001107 testcase( nAlloc==31 );
001108 testcase( nAlloc==32 );
001109 if( sqlite3VdbeMemClearAndResize(pMem, (int)MAX(nAlloc,32)) ){
001110 return SQLITE_NOMEM_BKPT;
001111 }
001112 memcpy(pMem->z, z, nAlloc);
001113 }else{
001114 sqlite3VdbeMemRelease(pMem);
001115 pMem->z = (char *)z;
001116 if( xDel==SQLITE_DYNAMIC ){
001117 pMem->zMalloc = pMem->z;
001118 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
001119 }else{
001120 pMem->xDel = xDel;
001121 flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn);
001122 }
001123 }
001124
001125 pMem->n = nByte;
001126 pMem->flags = flags;
001127 pMem->enc = (enc==0 ? SQLITE_UTF8 : enc);
001128
001129 #ifndef SQLITE_OMIT_UTF16
001130 if( pMem->enc!=SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
001131 return SQLITE_NOMEM_BKPT;
001132 }
001133 #endif
001134
001135 if( nByte>iLimit ){
001136 return SQLITE_TOOBIG;
001137 }
001138
001139 return SQLITE_OK;
001140 }
001141
001142 /*
001143 ** Move data out of a btree key or data field and into a Mem structure.
001144 ** The data is payload from the entry that pCur is currently pointing
001145 ** to. offset and amt determine what portion of the data or key to retrieve.
001146 ** The result is written into the pMem element.
001147 **
001148 ** The pMem object must have been initialized. This routine will use
001149 ** pMem->zMalloc to hold the content from the btree, if possible. New
001150 ** pMem->zMalloc space will be allocated if necessary. The calling routine
001151 ** is responsible for making sure that the pMem object is eventually
001152 ** destroyed.
001153 **
001154 ** If this routine fails for any reason (malloc returns NULL or unable
001155 ** to read from the disk) then the pMem is left in an inconsistent state.
001156 */
001157 static SQLITE_NOINLINE int vdbeMemFromBtreeResize(
001158 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
001159 u32 offset, /* Offset from the start of data to return bytes from. */
001160 u32 amt, /* Number of bytes to return. */
001161 Mem *pMem /* OUT: Return data in this Mem structure. */
001162 ){
001163 int rc;
001164 pMem->flags = MEM_Null;
001165 if( sqlite3BtreeMaxRecordSize(pCur)<offset+amt ){
001166 return SQLITE_CORRUPT_BKPT;
001167 }
001168 if( SQLITE_OK==(rc = sqlite3VdbeMemClearAndResize(pMem, amt+1)) ){
001169 rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
001170 if( rc==SQLITE_OK ){
001171 pMem->z[amt] = 0; /* Overrun area used when reading malformed records */
001172 pMem->flags = MEM_Blob;
001173 pMem->n = (int)amt;
001174 }else{
001175 sqlite3VdbeMemRelease(pMem);
001176 }
001177 }
001178 return rc;
001179 }
001180 int sqlite3VdbeMemFromBtree(
001181 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
001182 u32 offset, /* Offset from the start of data to return bytes from. */
001183 u32 amt, /* Number of bytes to return. */
001184 Mem *pMem /* OUT: Return data in this Mem structure. */
001185 ){
001186 char *zData; /* Data from the btree layer */
001187 u32 available = 0; /* Number of bytes available on the local btree page */
001188 int rc = SQLITE_OK; /* Return code */
001189
001190 assert( sqlite3BtreeCursorIsValid(pCur) );
001191 assert( !VdbeMemDynamic(pMem) );
001192
001193 /* Note: the calls to BtreeKeyFetch() and DataFetch() below assert()
001194 ** that both the BtShared and database handle mutexes are held. */
001195 assert( !sqlite3VdbeMemIsRowSet(pMem) );
001196 zData = (char *)sqlite3BtreePayloadFetch(pCur, &available);
001197 assert( zData!=0 );
001198
001199 if( offset+amt<=available ){
001200 pMem->z = &zData[offset];
001201 pMem->flags = MEM_Blob|MEM_Ephem;
001202 pMem->n = (int)amt;
001203 }else{
001204 rc = vdbeMemFromBtreeResize(pCur, offset, amt, pMem);
001205 }
001206
001207 return rc;
001208 }
001209
001210 /*
001211 ** The pVal argument is known to be a value other than NULL.
001212 ** Convert it into a string with encoding enc and return a pointer
001213 ** to a zero-terminated version of that string.
001214 */
001215 static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){
001216 assert( pVal!=0 );
001217 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
001218 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
001219 assert( !sqlite3VdbeMemIsRowSet(pVal) );
001220 assert( (pVal->flags & (MEM_Null))==0 );
001221 if( pVal->flags & (MEM_Blob|MEM_Str) ){
001222 if( ExpandBlob(pVal) ) return 0;
001223 pVal->flags |= MEM_Str;
001224 if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){
001225 sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
001226 }
001227 if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
001228 assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
001229 if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
001230 return 0;
001231 }
001232 }
001233 sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */
001234 }else{
001235 sqlite3VdbeMemStringify(pVal, enc, 0);
001236 assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
001237 }
001238 assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
001239 || pVal->db->mallocFailed );
001240 if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
001241 assert( sqlite3VdbeMemValidStrRep(pVal) );
001242 return pVal->z;
001243 }else{
001244 return 0;
001245 }
001246 }
001247
001248 /* This function is only available internally, it is not part of the
001249 ** external API. It works in a similar way to sqlite3_value_text(),
001250 ** except the data returned is in the encoding specified by the second
001251 ** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
001252 ** SQLITE_UTF8.
001253 **
001254 ** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
001255 ** If that is the case, then the result must be aligned on an even byte
001256 ** boundary.
001257 */
001258 const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
001259 if( !pVal ) return 0;
001260 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
001261 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
001262 assert( !sqlite3VdbeMemIsRowSet(pVal) );
001263 if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
001264 assert( sqlite3VdbeMemValidStrRep(pVal) );
001265 return pVal->z;
001266 }
001267 if( pVal->flags&MEM_Null ){
001268 return 0;
001269 }
001270 return valueToText(pVal, enc);
001271 }
001272
001273 /*
001274 ** Create a new sqlite3_value object.
001275 */
001276 sqlite3_value *sqlite3ValueNew(sqlite3 *db){
001277 Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
001278 if( p ){
001279 p->flags = MEM_Null;
001280 p->db = db;
001281 }
001282 return p;
001283 }
001284
001285 /*
001286 ** Context object passed by sqlite3Stat4ProbeSetValue() through to
001287 ** valueNew(). See comments above valueNew() for details.
001288 */
001289 struct ValueNewStat4Ctx {
001290 Parse *pParse;
001291 Index *pIdx;
001292 UnpackedRecord **ppRec;
001293 int iVal;
001294 };
001295
001296 /*
001297 ** Allocate and return a pointer to a new sqlite3_value object. If
001298 ** the second argument to this function is NULL, the object is allocated
001299 ** by calling sqlite3ValueNew().
001300 **
001301 ** Otherwise, if the second argument is non-zero, then this function is
001302 ** being called indirectly by sqlite3Stat4ProbeSetValue(). If it has not
001303 ** already been allocated, allocate the UnpackedRecord structure that
001304 ** that function will return to its caller here. Then return a pointer to
001305 ** an sqlite3_value within the UnpackedRecord.a[] array.
001306 */
001307 static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){
001308 #ifdef SQLITE_ENABLE_STAT4
001309 if( p ){
001310 UnpackedRecord *pRec = p->ppRec[0];
001311
001312 if( pRec==0 ){
001313 Index *pIdx = p->pIdx; /* Index being probed */
001314 int nByte; /* Bytes of space to allocate */
001315 int i; /* Counter variable */
001316 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
001317
001318 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
001319 pRec = (UnpackedRecord*)sqlite3DbMallocZero(db, nByte);
001320 if( pRec ){
001321 pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx);
001322 if( pRec->pKeyInfo ){
001323 assert( pRec->pKeyInfo->nAllField==nCol );
001324 assert( pRec->pKeyInfo->enc==ENC(db) );
001325 pRec->aMem = (Mem *)((u8*)pRec + ROUND8(sizeof(UnpackedRecord)));
001326 for(i=0; i<nCol; i++){
001327 pRec->aMem[i].flags = MEM_Null;
001328 pRec->aMem[i].db = db;
001329 }
001330 }else{
001331 sqlite3DbFreeNN(db, pRec);
001332 pRec = 0;
001333 }
001334 }
001335 if( pRec==0 ) return 0;
001336 p->ppRec[0] = pRec;
001337 }
001338
001339 pRec->nField = p->iVal+1;
001340 return &pRec->aMem[p->iVal];
001341 }
001342 #else
001343 UNUSED_PARAMETER(p);
001344 #endif /* defined(SQLITE_ENABLE_STAT4) */
001345 return sqlite3ValueNew(db);
001346 }
001347
001348 /*
001349 ** The expression object indicated by the second argument is guaranteed
001350 ** to be a scalar SQL function. If
001351 **
001352 ** * all function arguments are SQL literals,
001353 ** * one of the SQLITE_FUNC_CONSTANT or _SLOCHNG function flags is set, and
001354 ** * the SQLITE_FUNC_NEEDCOLL function flag is not set,
001355 **
001356 ** then this routine attempts to invoke the SQL function. Assuming no
001357 ** error occurs, output parameter (*ppVal) is set to point to a value
001358 ** object containing the result before returning SQLITE_OK.
001359 **
001360 ** Affinity aff is applied to the result of the function before returning.
001361 ** If the result is a text value, the sqlite3_value object uses encoding
001362 ** enc.
001363 **
001364 ** If the conditions above are not met, this function returns SQLITE_OK
001365 ** and sets (*ppVal) to NULL. Or, if an error occurs, (*ppVal) is set to
001366 ** NULL and an SQLite error code returned.
001367 */
001368 #ifdef SQLITE_ENABLE_STAT4
001369 static int valueFromFunction(
001370 sqlite3 *db, /* The database connection */
001371 Expr *p, /* The expression to evaluate */
001372 u8 enc, /* Encoding to use */
001373 u8 aff, /* Affinity to use */
001374 sqlite3_value **ppVal, /* Write the new value here */
001375 struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */
001376 ){
001377 sqlite3_context ctx; /* Context object for function invocation */
001378 sqlite3_value **apVal = 0; /* Function arguments */
001379 int nVal = 0; /* Size of apVal[] array */
001380 FuncDef *pFunc = 0; /* Function definition */
001381 sqlite3_value *pVal = 0; /* New value */
001382 int rc = SQLITE_OK; /* Return code */
001383 ExprList *pList = 0; /* Function arguments */
001384 int i; /* Iterator variable */
001385
001386 assert( pCtx!=0 );
001387 assert( (p->flags & EP_TokenOnly)==0 );
001388 pList = p->x.pList;
001389 if( pList ) nVal = pList->nExpr;
001390 pFunc = sqlite3FindFunction(db, p->u.zToken, nVal, enc, 0);
001391 assert( pFunc );
001392 if( (pFunc->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG))==0
001393 || (pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL)
001394 ){
001395 return SQLITE_OK;
001396 }
001397
001398 if( pList ){
001399 apVal = (sqlite3_value**)sqlite3DbMallocZero(db, sizeof(apVal[0]) * nVal);
001400 if( apVal==0 ){
001401 rc = SQLITE_NOMEM_BKPT;
001402 goto value_from_function_out;
001403 }
001404 for(i=0; i<nVal; i++){
001405 rc = sqlite3ValueFromExpr(db, pList->a[i].pExpr, enc, aff, &apVal[i]);
001406 if( apVal[i]==0 || rc!=SQLITE_OK ) goto value_from_function_out;
001407 }
001408 }
001409
001410 pVal = valueNew(db, pCtx);
001411 if( pVal==0 ){
001412 rc = SQLITE_NOMEM_BKPT;
001413 goto value_from_function_out;
001414 }
001415
001416 assert( pCtx->pParse->rc==SQLITE_OK );
001417 memset(&ctx, 0, sizeof(ctx));
001418 ctx.pOut = pVal;
001419 ctx.pFunc = pFunc;
001420 pFunc->xSFunc(&ctx, nVal, apVal);
001421 if( ctx.isError ){
001422 rc = ctx.isError;
001423 sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal));
001424 }else{
001425 sqlite3ValueApplyAffinity(pVal, aff, SQLITE_UTF8);
001426 assert( rc==SQLITE_OK );
001427 rc = sqlite3VdbeChangeEncoding(pVal, enc);
001428 if( rc==SQLITE_OK && sqlite3VdbeMemTooBig(pVal) ){
001429 rc = SQLITE_TOOBIG;
001430 pCtx->pParse->nErr++;
001431 }
001432 }
001433 pCtx->pParse->rc = rc;
001434
001435 value_from_function_out:
001436 if( rc!=SQLITE_OK ){
001437 pVal = 0;
001438 }
001439 if( apVal ){
001440 for(i=0; i<nVal; i++){
001441 sqlite3ValueFree(apVal[i]);
001442 }
001443 sqlite3DbFreeNN(db, apVal);
001444 }
001445
001446 *ppVal = pVal;
001447 return rc;
001448 }
001449 #else
001450 # define valueFromFunction(a,b,c,d,e,f) SQLITE_OK
001451 #endif /* defined(SQLITE_ENABLE_STAT4) */
001452
001453 /*
001454 ** Extract a value from the supplied expression in the manner described
001455 ** above sqlite3ValueFromExpr(). Allocate the sqlite3_value object
001456 ** using valueNew().
001457 **
001458 ** If pCtx is NULL and an error occurs after the sqlite3_value object
001459 ** has been allocated, it is freed before returning. Or, if pCtx is not
001460 ** NULL, it is assumed that the caller will free any allocated object
001461 ** in all cases.
001462 */
001463 static int valueFromExpr(
001464 sqlite3 *db, /* The database connection */
001465 Expr *pExpr, /* The expression to evaluate */
001466 u8 enc, /* Encoding to use */
001467 u8 affinity, /* Affinity to use */
001468 sqlite3_value **ppVal, /* Write the new value here */
001469 struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */
001470 ){
001471 int op;
001472 char *zVal = 0;
001473 sqlite3_value *pVal = 0;
001474 int negInt = 1;
001475 const char *zNeg = "";
001476 int rc = SQLITE_OK;
001477
001478 assert( pExpr!=0 );
001479 while( (op = pExpr->op)==TK_UPLUS || op==TK_SPAN ) pExpr = pExpr->pLeft;
001480 #if defined(SQLITE_ENABLE_STAT4)
001481 if( op==TK_REGISTER ) op = pExpr->op2;
001482 #else
001483 if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
001484 #endif
001485
001486 /* Compressed expressions only appear when parsing the DEFAULT clause
001487 ** on a table column definition, and hence only when pCtx==0. This
001488 ** check ensures that an EP_TokenOnly expression is never passed down
001489 ** into valueFromFunction(). */
001490 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
001491
001492 if( op==TK_CAST ){
001493 u8 aff = sqlite3AffinityType(pExpr->u.zToken,0);
001494 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
001495 testcase( rc!=SQLITE_OK );
001496 if( *ppVal ){
001497 sqlite3VdbeMemCast(*ppVal, aff, SQLITE_UTF8);
001498 sqlite3ValueApplyAffinity(*ppVal, affinity, SQLITE_UTF8);
001499 }
001500 return rc;
001501 }
001502
001503 /* Handle negative integers in a single step. This is needed in the
001504 ** case when the value is -9223372036854775808.
001505 */
001506 if( op==TK_UMINUS
001507 && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){
001508 pExpr = pExpr->pLeft;
001509 op = pExpr->op;
001510 negInt = -1;
001511 zNeg = "-";
001512 }
001513
001514 if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
001515 pVal = valueNew(db, pCtx);
001516 if( pVal==0 ) goto no_mem;
001517 if( ExprHasProperty(pExpr, EP_IntValue) ){
001518 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
001519 }else{
001520 zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
001521 if( zVal==0 ) goto no_mem;
001522 sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
001523 }
001524 if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_BLOB ){
001525 sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);
001526 }else{
001527 sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
001528 }
001529 assert( (pVal->flags & MEM_IntReal)==0 );
001530 if( pVal->flags & (MEM_Int|MEM_IntReal|MEM_Real) ){
001531 testcase( pVal->flags & MEM_Int );
001532 testcase( pVal->flags & MEM_Real );
001533 pVal->flags &= ~MEM_Str;
001534 }
001535 if( enc!=SQLITE_UTF8 ){
001536 rc = sqlite3VdbeChangeEncoding(pVal, enc);
001537 }
001538 }else if( op==TK_UMINUS ) {
001539 /* This branch happens for multiple negative signs. Ex: -(-5) */
001540 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
001541 && pVal!=0
001542 ){
001543 sqlite3VdbeMemNumerify(pVal);
001544 if( pVal->flags & MEM_Real ){
001545 pVal->u.r = -pVal->u.r;
001546 }else if( pVal->u.i==SMALLEST_INT64 ){
001547 pVal->u.r = -(double)SMALLEST_INT64;
001548 MemSetTypeFlag(pVal, MEM_Real);
001549 }else{
001550 pVal->u.i = -pVal->u.i;
001551 }
001552 sqlite3ValueApplyAffinity(pVal, affinity, enc);
001553 }
001554 }else if( op==TK_NULL ){
001555 pVal = valueNew(db, pCtx);
001556 if( pVal==0 ) goto no_mem;
001557 sqlite3VdbeMemSetNull(pVal);
001558 }
001559 #ifndef SQLITE_OMIT_BLOB_LITERAL
001560 else if( op==TK_BLOB ){
001561 int nVal;
001562 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
001563 assert( pExpr->u.zToken[1]=='\'' );
001564 pVal = valueNew(db, pCtx);
001565 if( !pVal ) goto no_mem;
001566 zVal = &pExpr->u.zToken[2];
001567 nVal = sqlite3Strlen30(zVal)-1;
001568 assert( zVal[nVal]=='\'' );
001569 sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
001570 0, SQLITE_DYNAMIC);
001571 }
001572 #endif
001573 #ifdef SQLITE_ENABLE_STAT4
001574 else if( op==TK_FUNCTION && pCtx!=0 ){
001575 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
001576 }
001577 #endif
001578 else if( op==TK_TRUEFALSE ){
001579 pVal = valueNew(db, pCtx);
001580 if( pVal ){
001581 pVal->flags = MEM_Int;
001582 pVal->u.i = pExpr->u.zToken[4]==0;
001583 }
001584 }
001585
001586 *ppVal = pVal;
001587 return rc;
001588
001589 no_mem:
001590 #ifdef SQLITE_ENABLE_STAT4
001591 if( pCtx==0 || pCtx->pParse->nErr==0 )
001592 #endif
001593 sqlite3OomFault(db);
001594 sqlite3DbFree(db, zVal);
001595 assert( *ppVal==0 );
001596 #ifdef SQLITE_ENABLE_STAT4
001597 if( pCtx==0 ) sqlite3ValueFree(pVal);
001598 #else
001599 assert( pCtx==0 ); sqlite3ValueFree(pVal);
001600 #endif
001601 return SQLITE_NOMEM_BKPT;
001602 }
001603
001604 /*
001605 ** Create a new sqlite3_value object, containing the value of pExpr.
001606 **
001607 ** This only works for very simple expressions that consist of one constant
001608 ** token (i.e. "5", "5.1", "'a string'"). If the expression can
001609 ** be converted directly into a value, then the value is allocated and
001610 ** a pointer written to *ppVal. The caller is responsible for deallocating
001611 ** the value by passing it to sqlite3ValueFree() later on. If the expression
001612 ** cannot be converted to a value, then *ppVal is set to NULL.
001613 */
001614 int sqlite3ValueFromExpr(
001615 sqlite3 *db, /* The database connection */
001616 Expr *pExpr, /* The expression to evaluate */
001617 u8 enc, /* Encoding to use */
001618 u8 affinity, /* Affinity to use */
001619 sqlite3_value **ppVal /* Write the new value here */
001620 ){
001621 return pExpr ? valueFromExpr(db, pExpr, enc, affinity, ppVal, 0) : 0;
001622 }
001623
001624 #ifdef SQLITE_ENABLE_STAT4
001625 /*
001626 ** Attempt to extract a value from pExpr and use it to construct *ppVal.
001627 **
001628 ** If pAlloc is not NULL, then an UnpackedRecord object is created for
001629 ** pAlloc if one does not exist and the new value is added to the
001630 ** UnpackedRecord object.
001631 **
001632 ** A value is extracted in the following cases:
001633 **
001634 ** * (pExpr==0). In this case the value is assumed to be an SQL NULL,
001635 **
001636 ** * The expression is a bound variable, and this is a reprepare, or
001637 **
001638 ** * The expression is a literal value.
001639 **
001640 ** On success, *ppVal is made to point to the extracted value. The caller
001641 ** is responsible for ensuring that the value is eventually freed.
001642 */
001643 static int stat4ValueFromExpr(
001644 Parse *pParse, /* Parse context */
001645 Expr *pExpr, /* The expression to extract a value from */
001646 u8 affinity, /* Affinity to use */
001647 struct ValueNewStat4Ctx *pAlloc,/* How to allocate space. Or NULL */
001648 sqlite3_value **ppVal /* OUT: New value object (or NULL) */
001649 ){
001650 int rc = SQLITE_OK;
001651 sqlite3_value *pVal = 0;
001652 sqlite3 *db = pParse->db;
001653
001654 /* Skip over any TK_COLLATE nodes */
001655 pExpr = sqlite3ExprSkipCollate(pExpr);
001656
001657 assert( pExpr==0 || pExpr->op!=TK_REGISTER || pExpr->op2!=TK_VARIABLE );
001658 if( !pExpr ){
001659 pVal = valueNew(db, pAlloc);
001660 if( pVal ){
001661 sqlite3VdbeMemSetNull((Mem*)pVal);
001662 }
001663 }else if( pExpr->op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){
001664 Vdbe *v;
001665 int iBindVar = pExpr->iColumn;
001666 sqlite3VdbeSetVarmask(pParse->pVdbe, iBindVar);
001667 if( (v = pParse->pReprepare)!=0 ){
001668 pVal = valueNew(db, pAlloc);
001669 if( pVal ){
001670 rc = sqlite3VdbeMemCopy((Mem*)pVal, &v->aVar[iBindVar-1]);
001671 sqlite3ValueApplyAffinity(pVal, affinity, ENC(db));
001672 pVal->db = pParse->db;
001673 }
001674 }
001675 }else{
001676 rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc);
001677 }
001678
001679 assert( pVal==0 || pVal->db==db );
001680 *ppVal = pVal;
001681 return rc;
001682 }
001683
001684 /*
001685 ** This function is used to allocate and populate UnpackedRecord
001686 ** structures intended to be compared against sample index keys stored
001687 ** in the sqlite_stat4 table.
001688 **
001689 ** A single call to this function populates zero or more fields of the
001690 ** record starting with field iVal (fields are numbered from left to
001691 ** right starting with 0). A single field is populated if:
001692 **
001693 ** * (pExpr==0). In this case the value is assumed to be an SQL NULL,
001694 **
001695 ** * The expression is a bound variable, and this is a reprepare, or
001696 **
001697 ** * The sqlite3ValueFromExpr() function is able to extract a value
001698 ** from the expression (i.e. the expression is a literal value).
001699 **
001700 ** Or, if pExpr is a TK_VECTOR, one field is populated for each of the
001701 ** vector components that match either of the two latter criteria listed
001702 ** above.
001703 **
001704 ** Before any value is appended to the record, the affinity of the
001705 ** corresponding column within index pIdx is applied to it. Before
001706 ** this function returns, output parameter *pnExtract is set to the
001707 ** number of values appended to the record.
001708 **
001709 ** When this function is called, *ppRec must either point to an object
001710 ** allocated by an earlier call to this function, or must be NULL. If it
001711 ** is NULL and a value can be successfully extracted, a new UnpackedRecord
001712 ** is allocated (and *ppRec set to point to it) before returning.
001713 **
001714 ** Unless an error is encountered, SQLITE_OK is returned. It is not an
001715 ** error if a value cannot be extracted from pExpr. If an error does
001716 ** occur, an SQLite error code is returned.
001717 */
001718 int sqlite3Stat4ProbeSetValue(
001719 Parse *pParse, /* Parse context */
001720 Index *pIdx, /* Index being probed */
001721 UnpackedRecord **ppRec, /* IN/OUT: Probe record */
001722 Expr *pExpr, /* The expression to extract a value from */
001723 int nElem, /* Maximum number of values to append */
001724 int iVal, /* Array element to populate */
001725 int *pnExtract /* OUT: Values appended to the record */
001726 ){
001727 int rc = SQLITE_OK;
001728 int nExtract = 0;
001729
001730 if( pExpr==0 || pExpr->op!=TK_SELECT ){
001731 int i;
001732 struct ValueNewStat4Ctx alloc;
001733
001734 alloc.pParse = pParse;
001735 alloc.pIdx = pIdx;
001736 alloc.ppRec = ppRec;
001737
001738 for(i=0; i<nElem; i++){
001739 sqlite3_value *pVal = 0;
001740 Expr *pElem = (pExpr ? sqlite3VectorFieldSubexpr(pExpr, i) : 0);
001741 u8 aff = sqlite3IndexColumnAffinity(pParse->db, pIdx, iVal+i);
001742 alloc.iVal = iVal+i;
001743 rc = stat4ValueFromExpr(pParse, pElem, aff, &alloc, &pVal);
001744 if( !pVal ) break;
001745 nExtract++;
001746 }
001747 }
001748
001749 *pnExtract = nExtract;
001750 return rc;
001751 }
001752
001753 /*
001754 ** Attempt to extract a value from expression pExpr using the methods
001755 ** as described for sqlite3Stat4ProbeSetValue() above.
001756 **
001757 ** If successful, set *ppVal to point to a new value object and return
001758 ** SQLITE_OK. If no value can be extracted, but no other error occurs
001759 ** (e.g. OOM), return SQLITE_OK and set *ppVal to NULL. Or, if an error
001760 ** does occur, return an SQLite error code. The final value of *ppVal
001761 ** is undefined in this case.
001762 */
001763 int sqlite3Stat4ValueFromExpr(
001764 Parse *pParse, /* Parse context */
001765 Expr *pExpr, /* The expression to extract a value from */
001766 u8 affinity, /* Affinity to use */
001767 sqlite3_value **ppVal /* OUT: New value object (or NULL) */
001768 ){
001769 return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal);
001770 }
001771
001772 /*
001773 ** Extract the iCol-th column from the nRec-byte record in pRec. Write
001774 ** the column value into *ppVal. If *ppVal is initially NULL then a new
001775 ** sqlite3_value object is allocated.
001776 **
001777 ** If *ppVal is initially NULL then the caller is responsible for
001778 ** ensuring that the value written into *ppVal is eventually freed.
001779 */
001780 int sqlite3Stat4Column(
001781 sqlite3 *db, /* Database handle */
001782 const void *pRec, /* Pointer to buffer containing record */
001783 int nRec, /* Size of buffer pRec in bytes */
001784 int iCol, /* Column to extract */
001785 sqlite3_value **ppVal /* OUT: Extracted value */
001786 ){
001787 u32 t = 0; /* a column type code */
001788 int nHdr; /* Size of the header in the record */
001789 int iHdr; /* Next unread header byte */
001790 int iField; /* Next unread data byte */
001791 int szField = 0; /* Size of the current data field */
001792 int i; /* Column index */
001793 u8 *a = (u8*)pRec; /* Typecast byte array */
001794 Mem *pMem = *ppVal; /* Write result into this Mem object */
001795
001796 assert( iCol>0 );
001797 iHdr = getVarint32(a, nHdr);
001798 if( nHdr>nRec || iHdr>=nHdr ) return SQLITE_CORRUPT_BKPT;
001799 iField = nHdr;
001800 for(i=0; i<=iCol; i++){
001801 iHdr += getVarint32(&a[iHdr], t);
001802 testcase( iHdr==nHdr );
001803 testcase( iHdr==nHdr+1 );
001804 if( iHdr>nHdr ) return SQLITE_CORRUPT_BKPT;
001805 szField = sqlite3VdbeSerialTypeLen(t);
001806 iField += szField;
001807 }
001808 testcase( iField==nRec );
001809 testcase( iField==nRec+1 );
001810 if( iField>nRec ) return SQLITE_CORRUPT_BKPT;
001811 if( pMem==0 ){
001812 pMem = *ppVal = sqlite3ValueNew(db);
001813 if( pMem==0 ) return SQLITE_NOMEM_BKPT;
001814 }
001815 sqlite3VdbeSerialGet(&a[iField-szField], t, pMem);
001816 pMem->enc = ENC(db);
001817 return SQLITE_OK;
001818 }
001819
001820 /*
001821 ** Unless it is NULL, the argument must be an UnpackedRecord object returned
001822 ** by an earlier call to sqlite3Stat4ProbeSetValue(). This call deletes
001823 ** the object.
001824 */
001825 void sqlite3Stat4ProbeFree(UnpackedRecord *pRec){
001826 if( pRec ){
001827 int i;
001828 int nCol = pRec->pKeyInfo->nAllField;
001829 Mem *aMem = pRec->aMem;
001830 sqlite3 *db = aMem[0].db;
001831 for(i=0; i<nCol; i++){
001832 sqlite3VdbeMemRelease(&aMem[i]);
001833 }
001834 sqlite3KeyInfoUnref(pRec->pKeyInfo);
001835 sqlite3DbFreeNN(db, pRec);
001836 }
001837 }
001838 #endif /* ifdef SQLITE_ENABLE_STAT4 */
001839
001840 /*
001841 ** Change the string value of an sqlite3_value object
001842 */
001843 void sqlite3ValueSetStr(
001844 sqlite3_value *v, /* Value to be set */
001845 int n, /* Length of string z */
001846 const void *z, /* Text of the new string */
001847 u8 enc, /* Encoding to use */
001848 void (*xDel)(void*) /* Destructor for the string */
001849 ){
001850 if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
001851 }
001852
001853 /*
001854 ** Free an sqlite3_value object
001855 */
001856 void sqlite3ValueFree(sqlite3_value *v){
001857 if( !v ) return;
001858 sqlite3VdbeMemRelease((Mem *)v);
001859 sqlite3DbFreeNN(((Mem*)v)->db, v);
001860 }
001861
001862 /*
001863 ** The sqlite3ValueBytes() routine returns the number of bytes in the
001864 ** sqlite3_value object assuming that it uses the encoding "enc".
001865 ** The valueBytes() routine is a helper function.
001866 */
001867 static SQLITE_NOINLINE int valueBytes(sqlite3_value *pVal, u8 enc){
001868 return valueToText(pVal, enc)!=0 ? pVal->n : 0;
001869 }
001870 int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
001871 Mem *p = (Mem*)pVal;
001872 assert( (p->flags & MEM_Null)==0 || (p->flags & (MEM_Str|MEM_Blob))==0 );
001873 if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){
001874 return p->n;
001875 }
001876 if( (p->flags & MEM_Blob)!=0 ){
001877 if( p->flags & MEM_Zero ){
001878 return p->n + p->u.nZero;
001879 }else{
001880 return p->n;
001881 }
001882 }
001883 if( p->flags & MEM_Null ) return 0;
001884 return valueBytes(pVal, enc);
001885 }