Merge Chromium + Blink git repositories
[chromium-blink-merge.git] / third_party / sqlite / sqlite-src-3080704 / src / vdbemem.c
blob870fb5bd891c2c83ae8c8683afa5ceca93b99649
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.
11 *************************************************************************
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
18 #include "sqliteInt.h"
19 #include "vdbeInt.h"
21 #ifdef SQLITE_DEBUG
23 ** Check invariants on a Mem object.
25 ** This routine is intended for use inside of assert() statements, like
26 ** this: assert( sqlite3VdbeCheckMemInvariants(pMem) );
28 int sqlite3VdbeCheckMemInvariants(Mem *p){
29 /* If MEM_Dyn is set then Mem.xDel!=0.
30 ** Mem.xDel is might not be initialized if MEM_Dyn is clear.
32 assert( (p->flags & MEM_Dyn)==0 || p->xDel!=0 );
34 /* MEM_Dyn may only be set if Mem.szMalloc==0. In this way we
35 ** ensure that if Mem.szMalloc>0 then it is safe to do
36 ** Mem.z = Mem.zMalloc without having to check Mem.flags&MEM_Dyn.
37 ** That saves a few cycles in inner loops. */
38 assert( (p->flags & MEM_Dyn)==0 || p->szMalloc==0 );
40 /* Cannot be both MEM_Int and MEM_Real at the same time */
41 assert( (p->flags & (MEM_Int|MEM_Real))!=(MEM_Int|MEM_Real) );
43 /* The szMalloc field holds the correct memory allocation size */
44 assert( p->szMalloc==0
45 || p->szMalloc==sqlite3DbMallocSize(p->db,p->zMalloc) );
47 /* If p holds a string or blob, the Mem.z must point to exactly
48 ** one of the following:
50 ** (1) Memory in Mem.zMalloc and managed by the Mem object
51 ** (2) Memory to be freed using Mem.xDel
52 ** (3) An ephemeral string or blob
53 ** (4) A static string or blob
55 if( (p->flags & (MEM_Str|MEM_Blob)) && p->n>0 ){
56 assert(
57 ((p->szMalloc>0 && p->z==p->zMalloc)? 1 : 0) +
58 ((p->flags&MEM_Dyn)!=0 ? 1 : 0) +
59 ((p->flags&MEM_Ephem)!=0 ? 1 : 0) +
60 ((p->flags&MEM_Static)!=0 ? 1 : 0) == 1
63 return 1;
65 #endif
69 ** If pMem is an object with a valid string representation, this routine
70 ** ensures the internal encoding for the string representation is
71 ** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE.
73 ** If pMem is not a string object, or the encoding of the string
74 ** representation is already stored using the requested encoding, then this
75 ** routine is a no-op.
77 ** SQLITE_OK is returned if the conversion is successful (or not required).
78 ** SQLITE_NOMEM may be returned if a malloc() fails during conversion
79 ** between formats.
81 int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
82 #ifndef SQLITE_OMIT_UTF16
83 int rc;
84 #endif
85 assert( (pMem->flags&MEM_RowSet)==0 );
86 assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE
87 || desiredEnc==SQLITE_UTF16BE );
88 if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
89 return SQLITE_OK;
91 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
92 #ifdef SQLITE_OMIT_UTF16
93 return SQLITE_ERROR;
94 #else
96 /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
97 ** then the encoding of the value may not have changed.
99 rc = sqlite3VdbeMemTranslate(pMem, (u8)desiredEnc);
100 assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
101 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
102 assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
103 return rc;
104 #endif
108 ** Make sure pMem->z points to a writable allocation of at least
109 ** min(n,32) bytes.
111 ** If the bPreserve argument is true, then copy of the content of
112 ** pMem->z into the new allocation. pMem must be either a string or
113 ** blob if bPreserve is true. If bPreserve is false, any prior content
114 ** in pMem->z is discarded.
116 SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){
117 assert( sqlite3VdbeCheckMemInvariants(pMem) );
118 assert( (pMem->flags&MEM_RowSet)==0 );
120 /* If the bPreserve flag is set to true, then the memory cell must already
121 ** contain a valid string or blob value. */
122 assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
123 testcase( bPreserve && pMem->z==0 );
125 assert( pMem->szMalloc==0
126 || pMem->szMalloc==sqlite3DbMallocSize(pMem->db, pMem->zMalloc) );
127 if( pMem->szMalloc<n ){
128 if( n<32 ) n = 32;
129 if( bPreserve && pMem->szMalloc>0 && pMem->z==pMem->zMalloc ){
130 pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
131 bPreserve = 0;
132 }else{
133 if( pMem->szMalloc>0 ) sqlite3DbFree(pMem->db, pMem->zMalloc);
134 pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
136 if( pMem->zMalloc==0 ){
137 sqlite3VdbeMemSetNull(pMem);
138 pMem->z = 0;
139 pMem->szMalloc = 0;
140 return SQLITE_NOMEM;
141 }else{
142 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
146 if( bPreserve && pMem->z && pMem->z!=pMem->zMalloc ){
147 memcpy(pMem->zMalloc, pMem->z, pMem->n);
149 if( (pMem->flags&MEM_Dyn)!=0 ){
150 assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC );
151 pMem->xDel((void *)(pMem->z));
154 pMem->z = pMem->zMalloc;
155 pMem->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Static);
156 return SQLITE_OK;
160 ** Change the pMem->zMalloc allocation to be at least szNew bytes.
161 ** If pMem->zMalloc already meets or exceeds the requested size, this
162 ** routine is a no-op.
164 ** Any prior string or blob content in the pMem object may be discarded.
165 ** The pMem->xDel destructor is called, if it exists. Though MEM_Str
166 ** and MEM_Blob values may be discarded, MEM_Int, MEM_Real, and MEM_Null
167 ** values are preserved.
169 ** Return SQLITE_OK on success or an error code (probably SQLITE_NOMEM)
170 ** if unable to complete the resizing.
172 int sqlite3VdbeMemClearAndResize(Mem *pMem, int szNew){
173 assert( szNew>0 );
174 assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 );
175 if( pMem->szMalloc<szNew ){
176 return sqlite3VdbeMemGrow(pMem, szNew, 0);
178 assert( (pMem->flags & MEM_Dyn)==0 );
179 pMem->z = pMem->zMalloc;
180 pMem->flags &= (MEM_Null|MEM_Int|MEM_Real);
181 return SQLITE_OK;
185 ** Change pMem so that its MEM_Str or MEM_Blob value is stored in
186 ** MEM.zMalloc, where it can be safely written.
188 ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
190 int sqlite3VdbeMemMakeWriteable(Mem *pMem){
191 int f;
192 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
193 assert( (pMem->flags&MEM_RowSet)==0 );
194 ExpandBlob(pMem);
195 f = pMem->flags;
196 if( (f&(MEM_Str|MEM_Blob)) && (pMem->szMalloc==0 || pMem->z!=pMem->zMalloc) ){
197 if( sqlite3VdbeMemGrow(pMem, pMem->n + 2, 1) ){
198 return SQLITE_NOMEM;
200 pMem->z[pMem->n] = 0;
201 pMem->z[pMem->n+1] = 0;
202 pMem->flags |= MEM_Term;
203 #ifdef SQLITE_DEBUG
204 pMem->pScopyFrom = 0;
205 #endif
208 return SQLITE_OK;
212 ** If the given Mem* has a zero-filled tail, turn it into an ordinary
213 ** blob stored in dynamically allocated space.
215 #ifndef SQLITE_OMIT_INCRBLOB
216 int sqlite3VdbeMemExpandBlob(Mem *pMem){
217 if( pMem->flags & MEM_Zero ){
218 int nByte;
219 assert( pMem->flags&MEM_Blob );
220 assert( (pMem->flags&MEM_RowSet)==0 );
221 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
223 /* Set nByte to the number of bytes required to store the expanded blob. */
224 nByte = pMem->n + pMem->u.nZero;
225 if( nByte<=0 ){
226 nByte = 1;
228 if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
229 return SQLITE_NOMEM;
232 memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
233 pMem->n += pMem->u.nZero;
234 pMem->flags &= ~(MEM_Zero|MEM_Term);
236 return SQLITE_OK;
238 #endif
241 ** It is already known that pMem contains an unterminated string.
242 ** Add the zero terminator.
244 static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){
245 if( sqlite3VdbeMemGrow(pMem, pMem->n+2, 1) ){
246 return SQLITE_NOMEM;
248 pMem->z[pMem->n] = 0;
249 pMem->z[pMem->n+1] = 0;
250 pMem->flags |= MEM_Term;
251 return SQLITE_OK;
255 ** Make sure the given Mem is \u0000 terminated.
257 int sqlite3VdbeMemNulTerminate(Mem *pMem){
258 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
259 testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) );
260 testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 );
261 if( (pMem->flags & (MEM_Term|MEM_Str))!=MEM_Str ){
262 return SQLITE_OK; /* Nothing to do */
263 }else{
264 return vdbeMemAddTerminator(pMem);
269 ** Add MEM_Str to the set of representations for the given Mem. Numbers
270 ** are converted using sqlite3_snprintf(). Converting a BLOB to a string
271 ** is a no-op.
273 ** Existing representations MEM_Int and MEM_Real are invalidated if
274 ** bForce is true but are retained if bForce is false.
276 ** A MEM_Null value will never be passed to this function. This function is
277 ** used for converting values to text for returning to the user (i.e. via
278 ** sqlite3_value_text()), or for ensuring that values to be used as btree
279 ** keys are strings. In the former case a NULL pointer is returned the
280 ** user and the latter is an internal programming error.
282 int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){
283 int fg = pMem->flags;
284 const int nByte = 32;
286 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
287 assert( !(fg&MEM_Zero) );
288 assert( !(fg&(MEM_Str|MEM_Blob)) );
289 assert( fg&(MEM_Int|MEM_Real) );
290 assert( (pMem->flags&MEM_RowSet)==0 );
291 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
294 if( sqlite3VdbeMemClearAndResize(pMem, nByte) ){
295 return SQLITE_NOMEM;
298 /* For a Real or Integer, use sqlite3_snprintf() to produce the UTF-8
299 ** string representation of the value. Then, if the required encoding
300 ** is UTF-16le or UTF-16be do a translation.
302 ** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16.
304 if( fg & MEM_Int ){
305 sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
306 }else{
307 assert( fg & MEM_Real );
308 sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->u.r);
310 pMem->n = sqlite3Strlen30(pMem->z);
311 pMem->enc = SQLITE_UTF8;
312 pMem->flags |= MEM_Str|MEM_Term;
313 if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real);
314 sqlite3VdbeChangeEncoding(pMem, enc);
315 return SQLITE_OK;
319 ** Memory cell pMem contains the context of an aggregate function.
320 ** This routine calls the finalize method for that function. The
321 ** result of the aggregate is stored back into pMem.
323 ** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK
324 ** otherwise.
326 int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
327 int rc = SQLITE_OK;
328 if( ALWAYS(pFunc && pFunc->xFinalize) ){
329 sqlite3_context ctx;
330 Mem t;
331 assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
332 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
333 memset(&ctx, 0, sizeof(ctx));
334 memset(&t, 0, sizeof(t));
335 t.flags = MEM_Null;
336 t.db = pMem->db;
337 ctx.pOut = &t;
338 ctx.pMem = pMem;
339 ctx.pFunc = pFunc;
340 pFunc->xFinalize(&ctx); /* IMP: R-24505-23230 */
341 assert( (pMem->flags & MEM_Dyn)==0 );
342 if( pMem->szMalloc>0 ) sqlite3DbFree(pMem->db, pMem->zMalloc);
343 memcpy(pMem, &t, sizeof(t));
344 rc = ctx.isError;
346 return rc;
350 ** If the memory cell contains a value that must be freed by
351 ** invoking the external callback in Mem.xDel, then this routine
352 ** will free that value. It also sets Mem.flags to MEM_Null.
354 ** This is a helper routine for sqlite3VdbeMemSetNull() and
355 ** for sqlite3VdbeMemRelease(). Use those other routines as the
356 ** entry point for releasing Mem resources.
358 static SQLITE_NOINLINE void vdbeMemClearExternAndSetNull(Mem *p){
359 assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
360 assert( VdbeMemDynamic(p) );
361 if( p->flags&MEM_Agg ){
362 sqlite3VdbeMemFinalize(p, p->u.pDef);
363 assert( (p->flags & MEM_Agg)==0 );
364 testcase( p->flags & MEM_Dyn );
366 if( p->flags&MEM_Dyn ){
367 assert( (p->flags&MEM_RowSet)==0 );
368 assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 );
369 p->xDel((void *)p->z);
370 }else if( p->flags&MEM_RowSet ){
371 sqlite3RowSetClear(p->u.pRowSet);
372 }else if( p->flags&MEM_Frame ){
373 VdbeFrame *pFrame = p->u.pFrame;
374 pFrame->pParent = pFrame->v->pDelFrame;
375 pFrame->v->pDelFrame = pFrame;
377 p->flags = MEM_Null;
381 ** Release memory held by the Mem p, both external memory cleared
382 ** by p->xDel and memory in p->zMalloc.
384 ** This is a helper routine invoked by sqlite3VdbeMemRelease() in
385 ** the unusual case where there really is memory in p that needs
386 ** to be freed.
388 static SQLITE_NOINLINE void vdbeMemClear(Mem *p){
389 if( VdbeMemDynamic(p) ){
390 vdbeMemClearExternAndSetNull(p);
392 if( p->szMalloc ){
393 sqlite3DbFree(p->db, p->zMalloc);
394 p->szMalloc = 0;
396 p->z = 0;
400 ** Release any memory resources held by the Mem. Both the memory that is
401 ** free by Mem.xDel and the Mem.zMalloc allocation are freed.
403 ** Use this routine prior to clean up prior to abandoning a Mem, or to
404 ** reset a Mem back to its minimum memory utilization.
406 ** Use sqlite3VdbeMemSetNull() to release just the Mem.xDel space
407 ** prior to inserting new content into the Mem.
409 void sqlite3VdbeMemRelease(Mem *p){
410 assert( sqlite3VdbeCheckMemInvariants(p) );
411 if( VdbeMemDynamic(p) || p->szMalloc ){
412 vdbeMemClear(p);
417 ** Convert a 64-bit IEEE double into a 64-bit signed integer.
418 ** If the double is out of range of a 64-bit signed integer then
419 ** return the closest available 64-bit signed integer.
421 static i64 doubleToInt64(double r){
422 #ifdef SQLITE_OMIT_FLOATING_POINT
423 /* When floating-point is omitted, double and int64 are the same thing */
424 return r;
425 #else
427 ** Many compilers we encounter do not define constants for the
428 ** minimum and maximum 64-bit integers, or they define them
429 ** inconsistently. And many do not understand the "LL" notation.
430 ** So we define our own static constants here using nothing
431 ** larger than a 32-bit integer constant.
433 static const i64 maxInt = LARGEST_INT64;
434 static const i64 minInt = SMALLEST_INT64;
436 if( r<=(double)minInt ){
437 return minInt;
438 }else if( r>=(double)maxInt ){
439 return maxInt;
440 }else{
441 return (i64)r;
443 #endif
447 ** Return some kind of integer value which is the best we can do
448 ** at representing the value that *pMem describes as an integer.
449 ** If pMem is an integer, then the value is exact. If pMem is
450 ** a floating-point then the value returned is the integer part.
451 ** If pMem is a string or blob, then we make an attempt to convert
452 ** it into an integer and return that. If pMem represents an
453 ** an SQL-NULL value, return 0.
455 ** If pMem represents a string value, its encoding might be changed.
457 i64 sqlite3VdbeIntValue(Mem *pMem){
458 int flags;
459 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
460 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
461 flags = pMem->flags;
462 if( flags & MEM_Int ){
463 return pMem->u.i;
464 }else if( flags & MEM_Real ){
465 return doubleToInt64(pMem->u.r);
466 }else if( flags & (MEM_Str|MEM_Blob) ){
467 i64 value = 0;
468 assert( pMem->z || pMem->n==0 );
469 sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
470 return value;
471 }else{
472 return 0;
477 ** Return the best representation of pMem that we can get into a
478 ** double. If pMem is already a double or an integer, return its
479 ** value. If it is a string or blob, try to convert it to a double.
480 ** If it is a NULL, return 0.0.
482 double sqlite3VdbeRealValue(Mem *pMem){
483 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
484 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
485 if( pMem->flags & MEM_Real ){
486 return pMem->u.r;
487 }else if( pMem->flags & MEM_Int ){
488 return (double)pMem->u.i;
489 }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
490 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
491 double val = (double)0;
492 sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc);
493 return val;
494 }else{
495 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
496 return (double)0;
501 ** The MEM structure is already a MEM_Real. Try to also make it a
502 ** MEM_Int if we can.
504 void sqlite3VdbeIntegerAffinity(Mem *pMem){
505 i64 ix;
506 assert( pMem->flags & MEM_Real );
507 assert( (pMem->flags & MEM_RowSet)==0 );
508 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
509 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
511 ix = doubleToInt64(pMem->u.r);
513 /* Only mark the value as an integer if
515 ** (1) the round-trip conversion real->int->real is a no-op, and
516 ** (2) The integer is neither the largest nor the smallest
517 ** possible integer (ticket #3922)
519 ** The second and third terms in the following conditional enforces
520 ** the second condition under the assumption that addition overflow causes
521 ** values to wrap around.
523 if( pMem->u.r==ix && ix>SMALLEST_INT64 && ix<LARGEST_INT64 ){
524 pMem->u.i = ix;
525 MemSetTypeFlag(pMem, MEM_Int);
530 ** Convert pMem to type integer. Invalidate any prior representations.
532 int sqlite3VdbeMemIntegerify(Mem *pMem){
533 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
534 assert( (pMem->flags & MEM_RowSet)==0 );
535 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
537 pMem->u.i = sqlite3VdbeIntValue(pMem);
538 MemSetTypeFlag(pMem, MEM_Int);
539 return SQLITE_OK;
543 ** Convert pMem so that it is of type MEM_Real.
544 ** Invalidate any prior representations.
546 int sqlite3VdbeMemRealify(Mem *pMem){
547 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
548 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
550 pMem->u.r = sqlite3VdbeRealValue(pMem);
551 MemSetTypeFlag(pMem, MEM_Real);
552 return SQLITE_OK;
556 ** Convert pMem so that it has types MEM_Real or MEM_Int or both.
557 ** Invalidate any prior representations.
559 ** Every effort is made to force the conversion, even if the input
560 ** is a string that does not look completely like a number. Convert
561 ** as much of the string as we can and ignore the rest.
563 int sqlite3VdbeMemNumerify(Mem *pMem){
564 if( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 ){
565 assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
566 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
567 if( 0==sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc) ){
568 MemSetTypeFlag(pMem, MEM_Int);
569 }else{
570 pMem->u.r = sqlite3VdbeRealValue(pMem);
571 MemSetTypeFlag(pMem, MEM_Real);
572 sqlite3VdbeIntegerAffinity(pMem);
575 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))!=0 );
576 pMem->flags &= ~(MEM_Str|MEM_Blob);
577 return SQLITE_OK;
581 ** Cast the datatype of the value in pMem according to the affinity
582 ** "aff". Casting is different from applying affinity in that a cast
583 ** is forced. In other words, the value is converted into the desired
584 ** affinity even if that results in loss of data. This routine is
585 ** used (for example) to implement the SQL "cast()" operator.
587 void sqlite3VdbeMemCast(Mem *pMem, u8 aff, u8 encoding){
588 if( pMem->flags & MEM_Null ) return;
589 switch( aff ){
590 case SQLITE_AFF_NONE: { /* Really a cast to BLOB */
591 if( (pMem->flags & MEM_Blob)==0 ){
592 sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding);
593 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
594 MemSetTypeFlag(pMem, MEM_Blob);
595 }else{
596 pMem->flags &= ~(MEM_TypeMask&~MEM_Blob);
598 break;
600 case SQLITE_AFF_NUMERIC: {
601 sqlite3VdbeMemNumerify(pMem);
602 break;
604 case SQLITE_AFF_INTEGER: {
605 sqlite3VdbeMemIntegerify(pMem);
606 break;
608 case SQLITE_AFF_REAL: {
609 sqlite3VdbeMemRealify(pMem);
610 break;
612 default: {
613 assert( aff==SQLITE_AFF_TEXT );
614 assert( MEM_Str==(MEM_Blob>>3) );
615 pMem->flags |= (pMem->flags&MEM_Blob)>>3;
616 sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding);
617 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
618 pMem->flags &= ~(MEM_Int|MEM_Real|MEM_Blob|MEM_Zero);
619 break;
625 ** Initialize bulk memory to be a consistent Mem object.
627 ** The minimum amount of initialization feasible is performed.
629 void sqlite3VdbeMemInit(Mem *pMem, sqlite3 *db, u16 flags){
630 assert( (flags & ~MEM_TypeMask)==0 );
631 pMem->flags = flags;
632 pMem->db = db;
633 pMem->szMalloc = 0;
638 ** Delete any previous value and set the value stored in *pMem to NULL.
640 ** This routine calls the Mem.xDel destructor to dispose of values that
641 ** require the destructor. But it preserves the Mem.zMalloc memory allocation.
642 ** To free all resources, use sqlite3VdbeMemRelease(), which both calls this
643 ** routine to invoke the destructor and deallocates Mem.zMalloc.
645 ** Use this routine to reset the Mem prior to insert a new value.
647 ** Use sqlite3VdbeMemRelease() to complete erase the Mem prior to abandoning it.
649 void sqlite3VdbeMemSetNull(Mem *pMem){
650 if( VdbeMemDynamic(pMem) ){
651 vdbeMemClearExternAndSetNull(pMem);
652 }else{
653 pMem->flags = MEM_Null;
656 void sqlite3ValueSetNull(sqlite3_value *p){
657 sqlite3VdbeMemSetNull((Mem*)p);
661 ** Delete any previous value and set the value to be a BLOB of length
662 ** n containing all zeros.
664 void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
665 sqlite3VdbeMemRelease(pMem);
666 pMem->flags = MEM_Blob|MEM_Zero;
667 pMem->n = 0;
668 if( n<0 ) n = 0;
669 pMem->u.nZero = n;
670 pMem->enc = SQLITE_UTF8;
671 pMem->z = 0;
675 ** The pMem is known to contain content that needs to be destroyed prior
676 ** to a value change. So invoke the destructor, then set the value to
677 ** a 64-bit integer.
679 static SQLITE_NOINLINE void vdbeReleaseAndSetInt64(Mem *pMem, i64 val){
680 sqlite3VdbeMemSetNull(pMem);
681 pMem->u.i = val;
682 pMem->flags = MEM_Int;
686 ** Delete any previous value and set the value stored in *pMem to val,
687 ** manifest type INTEGER.
689 void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
690 if( VdbeMemDynamic(pMem) ){
691 vdbeReleaseAndSetInt64(pMem, val);
692 }else{
693 pMem->u.i = val;
694 pMem->flags = MEM_Int;
698 #ifndef SQLITE_OMIT_FLOATING_POINT
700 ** Delete any previous value and set the value stored in *pMem to val,
701 ** manifest type REAL.
703 void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
704 sqlite3VdbeMemSetNull(pMem);
705 if( !sqlite3IsNaN(val) ){
706 pMem->u.r = val;
707 pMem->flags = MEM_Real;
710 #endif
713 ** Delete any previous value and set the value of pMem to be an
714 ** empty boolean index.
716 void sqlite3VdbeMemSetRowSet(Mem *pMem){
717 sqlite3 *db = pMem->db;
718 assert( db!=0 );
719 assert( (pMem->flags & MEM_RowSet)==0 );
720 sqlite3VdbeMemRelease(pMem);
721 pMem->zMalloc = sqlite3DbMallocRaw(db, 64);
722 if( db->mallocFailed ){
723 pMem->flags = MEM_Null;
724 pMem->szMalloc = 0;
725 }else{
726 assert( pMem->zMalloc );
727 pMem->szMalloc = sqlite3DbMallocSize(db, pMem->zMalloc);
728 pMem->u.pRowSet = sqlite3RowSetInit(db, pMem->zMalloc, pMem->szMalloc);
729 assert( pMem->u.pRowSet!=0 );
730 pMem->flags = MEM_RowSet;
735 ** Return true if the Mem object contains a TEXT or BLOB that is
736 ** too large - whose size exceeds SQLITE_MAX_LENGTH.
738 int sqlite3VdbeMemTooBig(Mem *p){
739 assert( p->db!=0 );
740 if( p->flags & (MEM_Str|MEM_Blob) ){
741 int n = p->n;
742 if( p->flags & MEM_Zero ){
743 n += p->u.nZero;
745 return n>p->db->aLimit[SQLITE_LIMIT_LENGTH];
747 return 0;
750 #ifdef SQLITE_DEBUG
752 ** This routine prepares a memory cell for modification by breaking
753 ** its link to a shallow copy and by marking any current shallow
754 ** copies of this cell as invalid.
756 ** This is used for testing and debugging only - to make sure shallow
757 ** copies are not misused.
759 void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
760 int i;
761 Mem *pX;
762 for(i=1, pX=&pVdbe->aMem[1]; i<=pVdbe->nMem; i++, pX++){
763 if( pX->pScopyFrom==pMem ){
764 pX->flags |= MEM_Undefined;
765 pX->pScopyFrom = 0;
768 pMem->pScopyFrom = 0;
770 #endif /* SQLITE_DEBUG */
773 ** Size of struct Mem not including the Mem.zMalloc member.
775 #define MEMCELLSIZE offsetof(Mem,zMalloc)
778 ** Make an shallow copy of pFrom into pTo. Prior contents of
779 ** pTo are freed. The pFrom->z field is not duplicated. If
780 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
781 ** and flags gets srcType (either MEM_Ephem or MEM_Static).
783 void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
784 assert( (pFrom->flags & MEM_RowSet)==0 );
785 assert( pTo->db==pFrom->db );
786 if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(pTo);
787 memcpy(pTo, pFrom, MEMCELLSIZE);
788 if( (pFrom->flags&MEM_Static)==0 ){
789 pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
790 assert( srcType==MEM_Ephem || srcType==MEM_Static );
791 pTo->flags |= srcType;
796 ** Make a full copy of pFrom into pTo. Prior contents of pTo are
797 ** freed before the copy is made.
799 int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
800 int rc = SQLITE_OK;
802 assert( pTo->db==pFrom->db );
803 assert( (pFrom->flags & MEM_RowSet)==0 );
804 if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(pTo);
805 memcpy(pTo, pFrom, MEMCELLSIZE);
806 pTo->flags &= ~MEM_Dyn;
807 if( pTo->flags&(MEM_Str|MEM_Blob) ){
808 if( 0==(pFrom->flags&MEM_Static) ){
809 pTo->flags |= MEM_Ephem;
810 rc = sqlite3VdbeMemMakeWriteable(pTo);
814 return rc;
818 ** Transfer the contents of pFrom to pTo. Any existing value in pTo is
819 ** freed. If pFrom contains ephemeral data, a copy is made.
821 ** pFrom contains an SQL NULL when this routine returns.
823 void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
824 assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
825 assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
826 assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
828 sqlite3VdbeMemRelease(pTo);
829 memcpy(pTo, pFrom, sizeof(Mem));
830 pFrom->flags = MEM_Null;
831 pFrom->szMalloc = 0;
835 ** Change the value of a Mem to be a string or a BLOB.
837 ** The memory management strategy depends on the value of the xDel
838 ** parameter. If the value passed is SQLITE_TRANSIENT, then the
839 ** string is copied into a (possibly existing) buffer managed by the
840 ** Mem structure. Otherwise, any existing buffer is freed and the
841 ** pointer copied.
843 ** If the string is too large (if it exceeds the SQLITE_LIMIT_LENGTH
844 ** size limit) then no memory allocation occurs. If the string can be
845 ** stored without allocating memory, then it is. If a memory allocation
846 ** is required to store the string, then value of pMem is unchanged. In
847 ** either case, SQLITE_TOOBIG is returned.
849 int sqlite3VdbeMemSetStr(
850 Mem *pMem, /* Memory cell to set to string value */
851 const char *z, /* String pointer */
852 int n, /* Bytes in string, or negative */
853 u8 enc, /* Encoding of z. 0 for BLOBs */
854 void (*xDel)(void*) /* Destructor function */
856 int nByte = n; /* New value for pMem->n */
857 int iLimit; /* Maximum allowed string or blob size */
858 u16 flags = 0; /* New value for pMem->flags */
860 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
861 assert( (pMem->flags & MEM_RowSet)==0 );
863 /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
864 if( !z ){
865 sqlite3VdbeMemSetNull(pMem);
866 return SQLITE_OK;
869 if( pMem->db ){
870 iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH];
871 }else{
872 iLimit = SQLITE_MAX_LENGTH;
874 flags = (enc==0?MEM_Blob:MEM_Str);
875 if( nByte<0 ){
876 assert( enc!=0 );
877 if( enc==SQLITE_UTF8 ){
878 nByte = sqlite3Strlen30(z);
879 if( nByte>iLimit ) nByte = iLimit+1;
880 }else{
881 for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
883 flags |= MEM_Term;
886 /* The following block sets the new values of Mem.z and Mem.xDel. It
887 ** also sets a flag in local variable "flags" to indicate the memory
888 ** management (one of MEM_Dyn or MEM_Static).
890 if( xDel==SQLITE_TRANSIENT ){
891 int nAlloc = nByte;
892 if( flags&MEM_Term ){
893 nAlloc += (enc==SQLITE_UTF8?1:2);
895 if( nByte>iLimit ){
896 return SQLITE_TOOBIG;
898 testcase( nAlloc==0 );
899 testcase( nAlloc==31 );
900 testcase( nAlloc==32 );
901 if( sqlite3VdbeMemClearAndResize(pMem, MAX(nAlloc,32)) ){
902 return SQLITE_NOMEM;
904 memcpy(pMem->z, z, nAlloc);
905 }else if( xDel==SQLITE_DYNAMIC ){
906 sqlite3VdbeMemRelease(pMem);
907 pMem->zMalloc = pMem->z = (char *)z;
908 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
909 }else{
910 sqlite3VdbeMemRelease(pMem);
911 pMem->z = (char *)z;
912 pMem->xDel = xDel;
913 flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn);
916 pMem->n = nByte;
917 pMem->flags = flags;
918 pMem->enc = (enc==0 ? SQLITE_UTF8 : enc);
920 #ifndef SQLITE_OMIT_UTF16
921 if( pMem->enc!=SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
922 return SQLITE_NOMEM;
924 #endif
926 if( nByte>iLimit ){
927 return SQLITE_TOOBIG;
930 return SQLITE_OK;
934 ** Move data out of a btree key or data field and into a Mem structure.
935 ** The data or key is taken from the entry that pCur is currently pointing
936 ** to. offset and amt determine what portion of the data or key to retrieve.
937 ** key is true to get the key or false to get data. The result is written
938 ** into the pMem element.
940 ** The pMem object must have been initialized. This routine will use
941 ** pMem->zMalloc to hold the content from the btree, if possible. New
942 ** pMem->zMalloc space will be allocated if necessary. The calling routine
943 ** is responsible for making sure that the pMem object is eventually
944 ** destroyed.
946 ** If this routine fails for any reason (malloc returns NULL or unable
947 ** to read from the disk) then the pMem is left in an inconsistent state.
949 int sqlite3VdbeMemFromBtree(
950 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
951 u32 offset, /* Offset from the start of data to return bytes from. */
952 u32 amt, /* Number of bytes to return. */
953 int key, /* If true, retrieve from the btree key, not data. */
954 Mem *pMem /* OUT: Return data in this Mem structure. */
956 char *zData; /* Data from the btree layer */
957 u32 available = 0; /* Number of bytes available on the local btree page */
958 int rc = SQLITE_OK; /* Return code */
960 assert( sqlite3BtreeCursorIsValid(pCur) );
961 assert( !VdbeMemDynamic(pMem) );
963 /* Note: the calls to BtreeKeyFetch() and DataFetch() below assert()
964 ** that both the BtShared and database handle mutexes are held. */
965 assert( (pMem->flags & MEM_RowSet)==0 );
966 if( key ){
967 zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
968 }else{
969 zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
971 assert( zData!=0 );
973 if( offset+amt<=available ){
974 pMem->z = &zData[offset];
975 pMem->flags = MEM_Blob|MEM_Ephem;
976 pMem->n = (int)amt;
977 }else{
978 pMem->flags = MEM_Null;
979 if( SQLITE_OK==(rc = sqlite3VdbeMemClearAndResize(pMem, amt+2)) ){
980 if( key ){
981 rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
982 }else{
983 rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
985 if( rc==SQLITE_OK ){
986 pMem->z[amt] = 0;
987 pMem->z[amt+1] = 0;
988 pMem->flags = MEM_Blob|MEM_Term;
989 pMem->n = (int)amt;
990 }else{
991 sqlite3VdbeMemRelease(pMem);
996 return rc;
1000 ** The pVal argument is known to be a value other than NULL.
1001 ** Convert it into a string with encoding enc and return a pointer
1002 ** to a zero-terminated version of that string.
1004 static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){
1005 assert( pVal!=0 );
1006 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
1007 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
1008 assert( (pVal->flags & MEM_RowSet)==0 );
1009 assert( (pVal->flags & (MEM_Null))==0 );
1010 if( pVal->flags & (MEM_Blob|MEM_Str) ){
1011 pVal->flags |= MEM_Str;
1012 if( pVal->flags & MEM_Zero ){
1013 sqlite3VdbeMemExpandBlob(pVal);
1015 if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){
1016 sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
1018 if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
1019 assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
1020 if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
1021 return 0;
1024 sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */
1025 }else{
1026 sqlite3VdbeMemStringify(pVal, enc, 0);
1027 assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
1029 assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
1030 || pVal->db->mallocFailed );
1031 if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
1032 return pVal->z;
1033 }else{
1034 return 0;
1038 /* This function is only available internally, it is not part of the
1039 ** external API. It works in a similar way to sqlite3_value_text(),
1040 ** except the data returned is in the encoding specified by the second
1041 ** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
1042 ** SQLITE_UTF8.
1044 ** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
1045 ** If that is the case, then the result must be aligned on an even byte
1046 ** boundary.
1048 const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
1049 if( !pVal ) return 0;
1050 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
1051 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
1052 assert( (pVal->flags & MEM_RowSet)==0 );
1053 if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
1054 return pVal->z;
1056 if( pVal->flags&MEM_Null ){
1057 return 0;
1059 return valueToText(pVal, enc);
1063 ** Create a new sqlite3_value object.
1065 sqlite3_value *sqlite3ValueNew(sqlite3 *db){
1066 Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
1067 if( p ){
1068 p->flags = MEM_Null;
1069 p->db = db;
1071 return p;
1075 ** Context object passed by sqlite3Stat4ProbeSetValue() through to
1076 ** valueNew(). See comments above valueNew() for details.
1078 struct ValueNewStat4Ctx {
1079 Parse *pParse;
1080 Index *pIdx;
1081 UnpackedRecord **ppRec;
1082 int iVal;
1086 ** Allocate and return a pointer to a new sqlite3_value object. If
1087 ** the second argument to this function is NULL, the object is allocated
1088 ** by calling sqlite3ValueNew().
1090 ** Otherwise, if the second argument is non-zero, then this function is
1091 ** being called indirectly by sqlite3Stat4ProbeSetValue(). If it has not
1092 ** already been allocated, allocate the UnpackedRecord structure that
1093 ** that function will return to its caller here. Then return a pointer
1094 ** an sqlite3_value within the UnpackedRecord.a[] array.
1096 static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){
1097 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
1098 if( p ){
1099 UnpackedRecord *pRec = p->ppRec[0];
1101 if( pRec==0 ){
1102 Index *pIdx = p->pIdx; /* Index being probed */
1103 int nByte; /* Bytes of space to allocate */
1104 int i; /* Counter variable */
1105 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
1107 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
1108 pRec = (UnpackedRecord*)sqlite3DbMallocZero(db, nByte);
1109 if( pRec ){
1110 pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx);
1111 if( pRec->pKeyInfo ){
1112 assert( pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField==nCol );
1113 assert( pRec->pKeyInfo->enc==ENC(db) );
1114 pRec->aMem = (Mem *)((u8*)pRec + ROUND8(sizeof(UnpackedRecord)));
1115 for(i=0; i<nCol; i++){
1116 pRec->aMem[i].flags = MEM_Null;
1117 pRec->aMem[i].db = db;
1119 }else{
1120 sqlite3DbFree(db, pRec);
1121 pRec = 0;
1124 if( pRec==0 ) return 0;
1125 p->ppRec[0] = pRec;
1128 pRec->nField = p->iVal+1;
1129 return &pRec->aMem[p->iVal];
1131 #else
1132 UNUSED_PARAMETER(p);
1133 #endif /* defined(SQLITE_ENABLE_STAT3_OR_STAT4) */
1134 return sqlite3ValueNew(db);
1138 ** Extract a value from the supplied expression in the manner described
1139 ** above sqlite3ValueFromExpr(). Allocate the sqlite3_value object
1140 ** using valueNew().
1142 ** If pCtx is NULL and an error occurs after the sqlite3_value object
1143 ** has been allocated, it is freed before returning. Or, if pCtx is not
1144 ** NULL, it is assumed that the caller will free any allocated object
1145 ** in all cases.
1147 static int valueFromExpr(
1148 sqlite3 *db, /* The database connection */
1149 Expr *pExpr, /* The expression to evaluate */
1150 u8 enc, /* Encoding to use */
1151 u8 affinity, /* Affinity to use */
1152 sqlite3_value **ppVal, /* Write the new value here */
1153 struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */
1155 int op;
1156 char *zVal = 0;
1157 sqlite3_value *pVal = 0;
1158 int negInt = 1;
1159 const char *zNeg = "";
1160 int rc = SQLITE_OK;
1162 if( !pExpr ){
1163 *ppVal = 0;
1164 return SQLITE_OK;
1166 while( (op = pExpr->op)==TK_UPLUS ) pExpr = pExpr->pLeft;
1167 if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
1169 if( op==TK_CAST ){
1170 u8 aff = sqlite3AffinityType(pExpr->u.zToken,0);
1171 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
1172 testcase( rc!=SQLITE_OK );
1173 if( *ppVal ){
1174 sqlite3VdbeMemCast(*ppVal, aff, SQLITE_UTF8);
1175 sqlite3ValueApplyAffinity(*ppVal, affinity, SQLITE_UTF8);
1177 return rc;
1180 /* Handle negative integers in a single step. This is needed in the
1181 ** case when the value is -9223372036854775808.
1183 if( op==TK_UMINUS
1184 && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){
1185 pExpr = pExpr->pLeft;
1186 op = pExpr->op;
1187 negInt = -1;
1188 zNeg = "-";
1191 if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
1192 pVal = valueNew(db, pCtx);
1193 if( pVal==0 ) goto no_mem;
1194 if( ExprHasProperty(pExpr, EP_IntValue) ){
1195 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
1196 }else{
1197 zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
1198 if( zVal==0 ) goto no_mem;
1199 sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
1201 if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
1202 sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);
1203 }else{
1204 sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
1206 if( pVal->flags & (MEM_Int|MEM_Real) ) pVal->flags &= ~MEM_Str;
1207 if( enc!=SQLITE_UTF8 ){
1208 rc = sqlite3VdbeChangeEncoding(pVal, enc);
1210 }else if( op==TK_UMINUS ) {
1211 /* This branch happens for multiple negative signs. Ex: -(-5) */
1212 if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal)
1213 && pVal!=0
1215 sqlite3VdbeMemNumerify(pVal);
1216 if( pVal->flags & MEM_Real ){
1217 pVal->u.r = -pVal->u.r;
1218 }else if( pVal->u.i==SMALLEST_INT64 ){
1219 pVal->u.r = -(double)SMALLEST_INT64;
1220 MemSetTypeFlag(pVal, MEM_Real);
1221 }else{
1222 pVal->u.i = -pVal->u.i;
1224 sqlite3ValueApplyAffinity(pVal, affinity, enc);
1226 }else if( op==TK_NULL ){
1227 pVal = valueNew(db, pCtx);
1228 if( pVal==0 ) goto no_mem;
1230 #ifndef SQLITE_OMIT_BLOB_LITERAL
1231 else if( op==TK_BLOB ){
1232 int nVal;
1233 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
1234 assert( pExpr->u.zToken[1]=='\'' );
1235 pVal = valueNew(db, pCtx);
1236 if( !pVal ) goto no_mem;
1237 zVal = &pExpr->u.zToken[2];
1238 nVal = sqlite3Strlen30(zVal)-1;
1239 assert( zVal[nVal]=='\'' );
1240 sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
1241 0, SQLITE_DYNAMIC);
1243 #endif
1245 *ppVal = pVal;
1246 return rc;
1248 no_mem:
1249 db->mallocFailed = 1;
1250 sqlite3DbFree(db, zVal);
1251 assert( *ppVal==0 );
1252 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
1253 if( pCtx==0 ) sqlite3ValueFree(pVal);
1254 #else
1255 assert( pCtx==0 ); sqlite3ValueFree(pVal);
1256 #endif
1257 return SQLITE_NOMEM;
1261 ** Create a new sqlite3_value object, containing the value of pExpr.
1263 ** This only works for very simple expressions that consist of one constant
1264 ** token (i.e. "5", "5.1", "'a string'"). If the expression can
1265 ** be converted directly into a value, then the value is allocated and
1266 ** a pointer written to *ppVal. The caller is responsible for deallocating
1267 ** the value by passing it to sqlite3ValueFree() later on. If the expression
1268 ** cannot be converted to a value, then *ppVal is set to NULL.
1270 int sqlite3ValueFromExpr(
1271 sqlite3 *db, /* The database connection */
1272 Expr *pExpr, /* The expression to evaluate */
1273 u8 enc, /* Encoding to use */
1274 u8 affinity, /* Affinity to use */
1275 sqlite3_value **ppVal /* Write the new value here */
1277 return valueFromExpr(db, pExpr, enc, affinity, ppVal, 0);
1280 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
1282 ** The implementation of the sqlite_record() function. This function accepts
1283 ** a single argument of any type. The return value is a formatted database
1284 ** record (a blob) containing the argument value.
1286 ** This is used to convert the value stored in the 'sample' column of the
1287 ** sqlite_stat3 table to the record format SQLite uses internally.
1289 static void recordFunc(
1290 sqlite3_context *context,
1291 int argc,
1292 sqlite3_value **argv
1294 const int file_format = 1;
1295 int iSerial; /* Serial type */
1296 int nSerial; /* Bytes of space for iSerial as varint */
1297 int nVal; /* Bytes of space required for argv[0] */
1298 int nRet;
1299 sqlite3 *db;
1300 u8 *aRet;
1302 UNUSED_PARAMETER( argc );
1303 iSerial = sqlite3VdbeSerialType(argv[0], file_format);
1304 nSerial = sqlite3VarintLen(iSerial);
1305 nVal = sqlite3VdbeSerialTypeLen(iSerial);
1306 db = sqlite3_context_db_handle(context);
1308 nRet = 1 + nSerial + nVal;
1309 aRet = sqlite3DbMallocRaw(db, nRet);
1310 if( aRet==0 ){
1311 sqlite3_result_error_nomem(context);
1312 }else{
1313 aRet[0] = nSerial+1;
1314 putVarint32(&aRet[1], iSerial);
1315 sqlite3VdbeSerialPut(&aRet[1+nSerial], argv[0], iSerial);
1316 sqlite3_result_blob(context, aRet, nRet, SQLITE_TRANSIENT);
1317 sqlite3DbFree(db, aRet);
1322 ** Register built-in functions used to help read ANALYZE data.
1324 void sqlite3AnalyzeFunctions(void){
1325 static SQLITE_WSD FuncDef aAnalyzeTableFuncs[] = {
1326 FUNCTION(sqlite_record, 1, 0, 0, recordFunc),
1328 int i;
1329 FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
1330 FuncDef *aFunc = (FuncDef*)&GLOBAL(FuncDef, aAnalyzeTableFuncs);
1331 for(i=0; i<ArraySize(aAnalyzeTableFuncs); i++){
1332 sqlite3FuncDefInsert(pHash, &aFunc[i]);
1337 ** Attempt to extract a value from pExpr and use it to construct *ppVal.
1339 ** If pAlloc is not NULL, then an UnpackedRecord object is created for
1340 ** pAlloc if one does not exist and the new value is added to the
1341 ** UnpackedRecord object.
1343 ** A value is extracted in the following cases:
1345 ** * (pExpr==0). In this case the value is assumed to be an SQL NULL,
1347 ** * The expression is a bound variable, and this is a reprepare, or
1349 ** * The expression is a literal value.
1351 ** On success, *ppVal is made to point to the extracted value. The caller
1352 ** is responsible for ensuring that the value is eventually freed.
1354 static int stat4ValueFromExpr(
1355 Parse *pParse, /* Parse context */
1356 Expr *pExpr, /* The expression to extract a value from */
1357 u8 affinity, /* Affinity to use */
1358 struct ValueNewStat4Ctx *pAlloc,/* How to allocate space. Or NULL */
1359 sqlite3_value **ppVal /* OUT: New value object (or NULL) */
1361 int rc = SQLITE_OK;
1362 sqlite3_value *pVal = 0;
1363 sqlite3 *db = pParse->db;
1365 /* Skip over any TK_COLLATE nodes */
1366 pExpr = sqlite3ExprSkipCollate(pExpr);
1368 if( !pExpr ){
1369 pVal = valueNew(db, pAlloc);
1370 if( pVal ){
1371 sqlite3VdbeMemSetNull((Mem*)pVal);
1373 }else if( pExpr->op==TK_VARIABLE
1374 || NEVER(pExpr->op==TK_REGISTER && pExpr->op2==TK_VARIABLE)
1376 Vdbe *v;
1377 int iBindVar = pExpr->iColumn;
1378 sqlite3VdbeSetVarmask(pParse->pVdbe, iBindVar);
1379 if( (v = pParse->pReprepare)!=0 ){
1380 pVal = valueNew(db, pAlloc);
1381 if( pVal ){
1382 rc = sqlite3VdbeMemCopy((Mem*)pVal, &v->aVar[iBindVar-1]);
1383 if( rc==SQLITE_OK ){
1384 sqlite3ValueApplyAffinity(pVal, affinity, ENC(db));
1386 pVal->db = pParse->db;
1389 }else{
1390 rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc);
1393 assert( pVal==0 || pVal->db==db );
1394 *ppVal = pVal;
1395 return rc;
1399 ** This function is used to allocate and populate UnpackedRecord
1400 ** structures intended to be compared against sample index keys stored
1401 ** in the sqlite_stat4 table.
1403 ** A single call to this function attempts to populates field iVal (leftmost
1404 ** is 0 etc.) of the unpacked record with a value extracted from expression
1405 ** pExpr. Extraction of values is possible if:
1407 ** * (pExpr==0). In this case the value is assumed to be an SQL NULL,
1409 ** * The expression is a bound variable, and this is a reprepare, or
1411 ** * The sqlite3ValueFromExpr() function is able to extract a value
1412 ** from the expression (i.e. the expression is a literal value).
1414 ** If a value can be extracted, the affinity passed as the 5th argument
1415 ** is applied to it before it is copied into the UnpackedRecord. Output
1416 ** parameter *pbOk is set to true if a value is extracted, or false
1417 ** otherwise.
1419 ** When this function is called, *ppRec must either point to an object
1420 ** allocated by an earlier call to this function, or must be NULL. If it
1421 ** is NULL and a value can be successfully extracted, a new UnpackedRecord
1422 ** is allocated (and *ppRec set to point to it) before returning.
1424 ** Unless an error is encountered, SQLITE_OK is returned. It is not an
1425 ** error if a value cannot be extracted from pExpr. If an error does
1426 ** occur, an SQLite error code is returned.
1428 int sqlite3Stat4ProbeSetValue(
1429 Parse *pParse, /* Parse context */
1430 Index *pIdx, /* Index being probed */
1431 UnpackedRecord **ppRec, /* IN/OUT: Probe record */
1432 Expr *pExpr, /* The expression to extract a value from */
1433 u8 affinity, /* Affinity to use */
1434 int iVal, /* Array element to populate */
1435 int *pbOk /* OUT: True if value was extracted */
1437 int rc;
1438 sqlite3_value *pVal = 0;
1439 struct ValueNewStat4Ctx alloc;
1441 alloc.pParse = pParse;
1442 alloc.pIdx = pIdx;
1443 alloc.ppRec = ppRec;
1444 alloc.iVal = iVal;
1446 rc = stat4ValueFromExpr(pParse, pExpr, affinity, &alloc, &pVal);
1447 assert( pVal==0 || pVal->db==pParse->db );
1448 *pbOk = (pVal!=0);
1449 return rc;
1453 ** Attempt to extract a value from expression pExpr using the methods
1454 ** as described for sqlite3Stat4ProbeSetValue() above.
1456 ** If successful, set *ppVal to point to a new value object and return
1457 ** SQLITE_OK. If no value can be extracted, but no other error occurs
1458 ** (e.g. OOM), return SQLITE_OK and set *ppVal to NULL. Or, if an error
1459 ** does occur, return an SQLite error code. The final value of *ppVal
1460 ** is undefined in this case.
1462 int sqlite3Stat4ValueFromExpr(
1463 Parse *pParse, /* Parse context */
1464 Expr *pExpr, /* The expression to extract a value from */
1465 u8 affinity, /* Affinity to use */
1466 sqlite3_value **ppVal /* OUT: New value object (or NULL) */
1468 return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal);
1472 ** Extract the iCol-th column from the nRec-byte record in pRec. Write
1473 ** the column value into *ppVal. If *ppVal is initially NULL then a new
1474 ** sqlite3_value object is allocated.
1476 ** If *ppVal is initially NULL then the caller is responsible for
1477 ** ensuring that the value written into *ppVal is eventually freed.
1479 int sqlite3Stat4Column(
1480 sqlite3 *db, /* Database handle */
1481 const void *pRec, /* Pointer to buffer containing record */
1482 int nRec, /* Size of buffer pRec in bytes */
1483 int iCol, /* Column to extract */
1484 sqlite3_value **ppVal /* OUT: Extracted value */
1486 u32 t; /* a column type code */
1487 int nHdr; /* Size of the header in the record */
1488 int iHdr; /* Next unread header byte */
1489 int iField; /* Next unread data byte */
1490 int szField; /* Size of the current data field */
1491 int i; /* Column index */
1492 u8 *a = (u8*)pRec; /* Typecast byte array */
1493 Mem *pMem = *ppVal; /* Write result into this Mem object */
1495 assert( iCol>0 );
1496 iHdr = getVarint32(a, nHdr);
1497 if( nHdr>nRec || iHdr>=nHdr ) return SQLITE_CORRUPT_BKPT;
1498 iField = nHdr;
1499 for(i=0; i<=iCol; i++){
1500 iHdr += getVarint32(&a[iHdr], t);
1501 testcase( iHdr==nHdr );
1502 testcase( iHdr==nHdr+1 );
1503 if( iHdr>nHdr ) return SQLITE_CORRUPT_BKPT;
1504 szField = sqlite3VdbeSerialTypeLen(t);
1505 iField += szField;
1507 testcase( iField==nRec );
1508 testcase( iField==nRec+1 );
1509 if( iField>nRec ) return SQLITE_CORRUPT_BKPT;
1510 if( pMem==0 ){
1511 pMem = *ppVal = sqlite3ValueNew(db);
1512 if( pMem==0 ) return SQLITE_NOMEM;
1514 sqlite3VdbeSerialGet(&a[iField-szField], t, pMem);
1515 pMem->enc = ENC(db);
1516 return SQLITE_OK;
1520 ** Unless it is NULL, the argument must be an UnpackedRecord object returned
1521 ** by an earlier call to sqlite3Stat4ProbeSetValue(). This call deletes
1522 ** the object.
1524 void sqlite3Stat4ProbeFree(UnpackedRecord *pRec){
1525 if( pRec ){
1526 int i;
1527 int nCol = pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField;
1528 Mem *aMem = pRec->aMem;
1529 sqlite3 *db = aMem[0].db;
1530 for(i=0; i<nCol; i++){
1531 if( aMem[i].szMalloc ) sqlite3DbFree(db, aMem[i].zMalloc);
1533 sqlite3KeyInfoUnref(pRec->pKeyInfo);
1534 sqlite3DbFree(db, pRec);
1537 #endif /* ifdef SQLITE_ENABLE_STAT4 */
1540 ** Change the string value of an sqlite3_value object
1542 void sqlite3ValueSetStr(
1543 sqlite3_value *v, /* Value to be set */
1544 int n, /* Length of string z */
1545 const void *z, /* Text of the new string */
1546 u8 enc, /* Encoding to use */
1547 void (*xDel)(void*) /* Destructor for the string */
1549 if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
1553 ** Free an sqlite3_value object
1555 void sqlite3ValueFree(sqlite3_value *v){
1556 if( !v ) return;
1557 sqlite3VdbeMemRelease((Mem *)v);
1558 sqlite3DbFree(((Mem*)v)->db, v);
1562 ** Return the number of bytes in the sqlite3_value object assuming
1563 ** that it uses the encoding "enc"
1565 int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
1566 Mem *p = (Mem*)pVal;
1567 if( (p->flags & MEM_Blob)!=0 || sqlite3ValueText(pVal, enc) ){
1568 if( p->flags & MEM_Zero ){
1569 return p->n + p->u.nZero;
1570 }else{
1571 return p->n;
1574 return 0;