4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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
18 #include "sqliteInt.h"
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 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 if( p
->flags
& MEM_Null
){
44 /* Cannot be both MEM_Null and some other type */
45 assert( (p
->flags
& (MEM_Int
|MEM_Real
|MEM_Str
|MEM_Blob
46 |MEM_RowSet
|MEM_Frame
|MEM_Agg
))==0 );
48 /* If MEM_Null is set, then either the value is a pure NULL (the usual
49 ** case) or it is a pointer set using sqlite3_bind_pointer() or
50 ** sqlite3_result_pointer(). If a pointer, then MEM_Term must also be
53 if( (p
->flags
& (MEM_Term
|MEM_Subtype
))==(MEM_Term
|MEM_Subtype
) ){
54 /* This is a pointer type. There may be a flag to indicate what to
55 ** do with the pointer. */
56 assert( ((p
->flags
&MEM_Dyn
)!=0 ? 1 : 0) +
57 ((p
->flags
&MEM_Ephem
)!=0 ? 1 : 0) +
58 ((p
->flags
&MEM_Static
)!=0 ? 1 : 0) <= 1 );
60 /* No other bits set */
61 assert( (p
->flags
& ~(MEM_Null
|MEM_Term
|MEM_Subtype
62 |MEM_Dyn
|MEM_Ephem
|MEM_Static
))==0 );
64 /* A pure NULL might have other flags, such as MEM_Static, MEM_Dyn,
65 ** MEM_Ephem, MEM_Cleared, or MEM_Subtype */
68 /* The MEM_Cleared bit is only allowed on NULLs */
69 assert( (p
->flags
& MEM_Cleared
)==0 );
72 /* The szMalloc field holds the correct memory allocation size */
73 assert( p
->szMalloc
==0
74 || p
->szMalloc
==sqlite3DbMallocSize(p
->db
,p
->zMalloc
) );
76 /* If p holds a string or blob, the Mem.z must point to exactly
77 ** one of the following:
79 ** (1) Memory in Mem.zMalloc and managed by the Mem object
80 ** (2) Memory to be freed using Mem.xDel
81 ** (3) An ephemeral string or blob
82 ** (4) A static string or blob
84 if( (p
->flags
& (MEM_Str
|MEM_Blob
)) && p
->n
>0 ){
86 ((p
->szMalloc
>0 && p
->z
==p
->zMalloc
)? 1 : 0) +
87 ((p
->flags
&MEM_Dyn
)!=0 ? 1 : 0) +
88 ((p
->flags
&MEM_Ephem
)!=0 ? 1 : 0) +
89 ((p
->flags
&MEM_Static
)!=0 ? 1 : 0) == 1
98 ** Check that string value of pMem agrees with its integer or real value.
100 ** A single int or real value always converts to the same strings. But
101 ** many different strings can be converted into the same int or real.
102 ** If a table contains a numeric value and an index is based on the
103 ** corresponding string value, then it is important that the string be
104 ** derived from the numeric value, not the other way around, to ensure
105 ** that the index and table are consistent. See ticket
106 ** https://www.sqlite.org/src/info/343634942dd54ab (2018-01-31) for
109 ** This routine looks at pMem to verify that if it has both a numeric
110 ** representation and a string representation then the string rep has
111 ** been derived from the numeric and not the other way around. It returns
112 ** true if everything is ok and false if there is a problem.
114 ** This routine is for use inside of assert() statements only.
116 int sqlite3VdbeMemConsistentDualRep(Mem
*p
){
120 if( (p
->flags
& MEM_Str
)==0 ) return 1;
121 if( (p
->flags
& (MEM_Int
|MEM_Real
))==0 ) return 1;
122 if( p
->flags
& MEM_Int
){
123 sqlite3_snprintf(sizeof(zBuf
),zBuf
,"%lld",p
->u
.i
);
125 sqlite3_snprintf(sizeof(zBuf
),zBuf
,"%!.15g",p
->u
.r
);
130 if( p
->enc
!=SQLITE_UTF8
){
132 if( p
->enc
==SQLITE_UTF16BE
) z
++;
135 if( zBuf
[j
++]!=z
[i
] ) return 0;
140 #endif /* SQLITE_DEBUG */
143 ** If pMem is an object with a valid string representation, this routine
144 ** ensures the internal encoding for the string representation is
145 ** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE.
147 ** If pMem is not a string object, or the encoding of the string
148 ** representation is already stored using the requested encoding, then this
149 ** routine is a no-op.
151 ** SQLITE_OK is returned if the conversion is successful (or not required).
152 ** SQLITE_NOMEM may be returned if a malloc() fails during conversion
155 int sqlite3VdbeChangeEncoding(Mem
*pMem
, int desiredEnc
){
156 #ifndef SQLITE_OMIT_UTF16
159 assert( (pMem
->flags
&MEM_RowSet
)==0 );
160 assert( desiredEnc
==SQLITE_UTF8
|| desiredEnc
==SQLITE_UTF16LE
161 || desiredEnc
==SQLITE_UTF16BE
);
162 if( !(pMem
->flags
&MEM_Str
) || pMem
->enc
==desiredEnc
){
165 assert( pMem
->db
==0 || sqlite3_mutex_held(pMem
->db
->mutex
) );
166 #ifdef SQLITE_OMIT_UTF16
170 /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
171 ** then the encoding of the value may not have changed.
173 rc
= sqlite3VdbeMemTranslate(pMem
, (u8
)desiredEnc
);
174 assert(rc
==SQLITE_OK
|| rc
==SQLITE_NOMEM
);
175 assert(rc
==SQLITE_OK
|| pMem
->enc
!=desiredEnc
);
176 assert(rc
==SQLITE_NOMEM
|| pMem
->enc
==desiredEnc
);
182 ** Make sure pMem->z points to a writable allocation of at least
185 ** If the bPreserve argument is true, then copy of the content of
186 ** pMem->z into the new allocation. pMem must be either a string or
187 ** blob if bPreserve is true. If bPreserve is false, any prior content
188 ** in pMem->z is discarded.
190 SQLITE_NOINLINE
int sqlite3VdbeMemGrow(Mem
*pMem
, int n
, int bPreserve
){
191 assert( sqlite3VdbeCheckMemInvariants(pMem
) );
192 assert( (pMem
->flags
&MEM_RowSet
)==0 );
193 testcase( pMem
->db
==0 );
195 /* If the bPreserve flag is set to true, then the memory cell must already
196 ** contain a valid string or blob value. */
197 assert( bPreserve
==0 || pMem
->flags
&(MEM_Blob
|MEM_Str
) );
198 testcase( bPreserve
&& pMem
->z
==0 );
200 assert( pMem
->szMalloc
==0
201 || pMem
->szMalloc
==sqlite3DbMallocSize(pMem
->db
, pMem
->zMalloc
) );
203 if( pMem
->szMalloc
>0 && bPreserve
&& pMem
->z
==pMem
->zMalloc
){
204 pMem
->z
= pMem
->zMalloc
= sqlite3DbReallocOrFree(pMem
->db
, pMem
->z
, n
);
207 if( pMem
->szMalloc
>0 ) sqlite3DbFreeNN(pMem
->db
, pMem
->zMalloc
);
208 pMem
->zMalloc
= sqlite3DbMallocRaw(pMem
->db
, n
);
210 if( pMem
->zMalloc
==0 ){
211 sqlite3VdbeMemSetNull(pMem
);
214 return SQLITE_NOMEM_BKPT
;
216 pMem
->szMalloc
= sqlite3DbMallocSize(pMem
->db
, pMem
->zMalloc
);
219 if( bPreserve
&& pMem
->z
){
220 assert( pMem
->z
!=pMem
->zMalloc
);
221 memcpy(pMem
->zMalloc
, pMem
->z
, pMem
->n
);
223 if( (pMem
->flags
&MEM_Dyn
)!=0 ){
224 assert( pMem
->xDel
!=0 && pMem
->xDel
!=SQLITE_DYNAMIC
);
225 pMem
->xDel((void *)(pMem
->z
));
228 pMem
->z
= pMem
->zMalloc
;
229 pMem
->flags
&= ~(MEM_Dyn
|MEM_Ephem
|MEM_Static
);
234 ** Change the pMem->zMalloc allocation to be at least szNew bytes.
235 ** If pMem->zMalloc already meets or exceeds the requested size, this
236 ** routine is a no-op.
238 ** Any prior string or blob content in the pMem object may be discarded.
239 ** The pMem->xDel destructor is called, if it exists. Though MEM_Str
240 ** and MEM_Blob values may be discarded, MEM_Int, MEM_Real, and MEM_Null
241 ** values are preserved.
243 ** Return SQLITE_OK on success or an error code (probably SQLITE_NOMEM)
244 ** if unable to complete the resizing.
246 int sqlite3VdbeMemClearAndResize(Mem
*pMem
, int szNew
){
248 assert( (pMem
->flags
& MEM_Dyn
)==0 || pMem
->szMalloc
==0 );
249 if( pMem
->szMalloc
<szNew
){
250 return sqlite3VdbeMemGrow(pMem
, szNew
, 0);
252 assert( (pMem
->flags
& MEM_Dyn
)==0 );
253 pMem
->z
= pMem
->zMalloc
;
254 pMem
->flags
&= (MEM_Null
|MEM_Int
|MEM_Real
);
259 ** It is already known that pMem contains an unterminated string.
260 ** Add the zero terminator.
262 static SQLITE_NOINLINE
int vdbeMemAddTerminator(Mem
*pMem
){
263 if( sqlite3VdbeMemGrow(pMem
, pMem
->n
+2, 1) ){
264 return SQLITE_NOMEM_BKPT
;
266 pMem
->z
[pMem
->n
] = 0;
267 pMem
->z
[pMem
->n
+1] = 0;
268 pMem
->flags
|= MEM_Term
;
273 ** Change pMem so that its MEM_Str or MEM_Blob value is stored in
274 ** MEM.zMalloc, where it can be safely written.
276 ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
278 int sqlite3VdbeMemMakeWriteable(Mem
*pMem
){
279 assert( pMem
->db
==0 || sqlite3_mutex_held(pMem
->db
->mutex
) );
280 assert( (pMem
->flags
&MEM_RowSet
)==0 );
281 if( (pMem
->flags
& (MEM_Str
|MEM_Blob
))!=0 ){
282 if( ExpandBlob(pMem
) ) return SQLITE_NOMEM
;
283 if( pMem
->szMalloc
==0 || pMem
->z
!=pMem
->zMalloc
){
284 int rc
= vdbeMemAddTerminator(pMem
);
288 pMem
->flags
&= ~MEM_Ephem
;
290 pMem
->pScopyFrom
= 0;
297 ** If the given Mem* has a zero-filled tail, turn it into an ordinary
298 ** blob stored in dynamically allocated space.
300 #ifndef SQLITE_OMIT_INCRBLOB
301 int sqlite3VdbeMemExpandBlob(Mem
*pMem
){
303 assert( pMem
->flags
& MEM_Zero
);
304 assert( pMem
->flags
&MEM_Blob
);
305 assert( (pMem
->flags
&MEM_RowSet
)==0 );
306 assert( pMem
->db
==0 || sqlite3_mutex_held(pMem
->db
->mutex
) );
308 /* Set nByte to the number of bytes required to store the expanded blob. */
309 nByte
= pMem
->n
+ pMem
->u
.nZero
;
313 if( sqlite3VdbeMemGrow(pMem
, nByte
, 1) ){
314 return SQLITE_NOMEM_BKPT
;
317 memset(&pMem
->z
[pMem
->n
], 0, pMem
->u
.nZero
);
318 pMem
->n
+= pMem
->u
.nZero
;
319 pMem
->flags
&= ~(MEM_Zero
|MEM_Term
);
325 ** Make sure the given Mem is \u0000 terminated.
327 int sqlite3VdbeMemNulTerminate(Mem
*pMem
){
328 assert( pMem
->db
==0 || sqlite3_mutex_held(pMem
->db
->mutex
) );
329 testcase( (pMem
->flags
& (MEM_Term
|MEM_Str
))==(MEM_Term
|MEM_Str
) );
330 testcase( (pMem
->flags
& (MEM_Term
|MEM_Str
))==0 );
331 if( (pMem
->flags
& (MEM_Term
|MEM_Str
))!=MEM_Str
){
332 return SQLITE_OK
; /* Nothing to do */
334 return vdbeMemAddTerminator(pMem
);
339 ** Add MEM_Str to the set of representations for the given Mem. Numbers
340 ** are converted using sqlite3_snprintf(). Converting a BLOB to a string
343 ** Existing representations MEM_Int and MEM_Real are invalidated if
344 ** bForce is true but are retained if bForce is false.
346 ** A MEM_Null value will never be passed to this function. This function is
347 ** used for converting values to text for returning to the user (i.e. via
348 ** sqlite3_value_text()), or for ensuring that values to be used as btree
349 ** keys are strings. In the former case a NULL pointer is returned the
350 ** user and the latter is an internal programming error.
352 int sqlite3VdbeMemStringify(Mem
*pMem
, u8 enc
, u8 bForce
){
353 int fg
= pMem
->flags
;
354 const int nByte
= 32;
356 assert( pMem
->db
==0 || sqlite3_mutex_held(pMem
->db
->mutex
) );
357 assert( !(fg
&MEM_Zero
) );
358 assert( !(fg
&(MEM_Str
|MEM_Blob
)) );
359 assert( fg
&(MEM_Int
|MEM_Real
) );
360 assert( (pMem
->flags
&MEM_RowSet
)==0 );
361 assert( EIGHT_BYTE_ALIGNMENT(pMem
) );
364 if( sqlite3VdbeMemClearAndResize(pMem
, nByte
) ){
366 return SQLITE_NOMEM_BKPT
;
369 /* For a Real or Integer, use sqlite3_snprintf() to produce the UTF-8
370 ** string representation of the value. Then, if the required encoding
371 ** is UTF-16le or UTF-16be do a translation.
373 ** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16.
376 sqlite3_snprintf(nByte
, pMem
->z
, "%lld", pMem
->u
.i
);
378 assert( fg
& MEM_Real
);
379 sqlite3_snprintf(nByte
, pMem
->z
, "%!.15g", pMem
->u
.r
);
381 pMem
->n
= sqlite3Strlen30(pMem
->z
);
382 pMem
->enc
= SQLITE_UTF8
;
383 pMem
->flags
|= MEM_Str
|MEM_Term
;
384 if( bForce
) pMem
->flags
&= ~(MEM_Int
|MEM_Real
);
385 sqlite3VdbeChangeEncoding(pMem
, enc
);
390 ** Memory cell pMem contains the context of an aggregate function.
391 ** This routine calls the finalize method for that function. The
392 ** result of the aggregate is stored back into pMem.
394 ** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK
397 int sqlite3VdbeMemFinalize(Mem
*pMem
, FuncDef
*pFunc
){
401 assert( pFunc
->xFinalize
!=0 );
402 assert( (pMem
->flags
& MEM_Null
)!=0 || pFunc
==pMem
->u
.pDef
);
403 assert( pMem
->db
==0 || sqlite3_mutex_held(pMem
->db
->mutex
) );
404 memset(&ctx
, 0, sizeof(ctx
));
405 memset(&t
, 0, sizeof(t
));
411 pFunc
->xFinalize(&ctx
); /* IMP: R-24505-23230 */
412 assert( (pMem
->flags
& MEM_Dyn
)==0 );
413 if( pMem
->szMalloc
>0 ) sqlite3DbFreeNN(pMem
->db
, pMem
->zMalloc
);
414 memcpy(pMem
, &t
, sizeof(t
));
419 ** Memory cell pAccum contains the context of an aggregate function.
420 ** This routine calls the xValue method for that function and stores
421 ** the results in memory cell pMem.
423 ** SQLITE_ERROR is returned if xValue() reports an error. SQLITE_OK
426 #ifndef SQLITE_OMIT_WINDOWFUNC
427 int sqlite3VdbeMemAggValue(Mem
*pAccum
, Mem
*pOut
, FuncDef
*pFunc
){
431 assert( pFunc
->xValue
!=0 );
432 assert( (pAccum
->flags
& MEM_Null
)!=0 || pFunc
==pAccum
->u
.pDef
);
433 assert( pAccum
->db
==0 || sqlite3_mutex_held(pAccum
->db
->mutex
) );
434 memset(&ctx
, 0, sizeof(ctx
));
435 memset(&t
, 0, sizeof(t
));
438 sqlite3VdbeMemSetNull(pOut
);
445 #endif /* SQLITE_OMIT_WINDOWFUNC */
448 ** If the memory cell contains a value that must be freed by
449 ** invoking the external callback in Mem.xDel, then this routine
450 ** will free that value. It also sets Mem.flags to MEM_Null.
452 ** This is a helper routine for sqlite3VdbeMemSetNull() and
453 ** for sqlite3VdbeMemRelease(). Use those other routines as the
454 ** entry point for releasing Mem resources.
456 static SQLITE_NOINLINE
void vdbeMemClearExternAndSetNull(Mem
*p
){
457 assert( p
->db
==0 || sqlite3_mutex_held(p
->db
->mutex
) );
458 assert( VdbeMemDynamic(p
) );
459 if( p
->flags
&MEM_Agg
){
460 sqlite3VdbeMemFinalize(p
, p
->u
.pDef
);
461 assert( (p
->flags
& MEM_Agg
)==0 );
462 testcase( p
->flags
& MEM_Dyn
);
464 if( p
->flags
&MEM_Dyn
){
465 assert( (p
->flags
&MEM_RowSet
)==0 );
466 assert( p
->xDel
!=SQLITE_DYNAMIC
&& p
->xDel
!=0 );
467 p
->xDel((void *)p
->z
);
468 }else if( p
->flags
&MEM_RowSet
){
469 sqlite3RowSetClear(p
->u
.pRowSet
);
470 }else if( p
->flags
&MEM_Frame
){
471 VdbeFrame
*pFrame
= p
->u
.pFrame
;
472 pFrame
->pParent
= pFrame
->v
->pDelFrame
;
473 pFrame
->v
->pDelFrame
= pFrame
;
479 ** Release memory held by the Mem p, both external memory cleared
480 ** by p->xDel and memory in p->zMalloc.
482 ** This is a helper routine invoked by sqlite3VdbeMemRelease() in
483 ** the unusual case where there really is memory in p that needs
486 static SQLITE_NOINLINE
void vdbeMemClear(Mem
*p
){
487 if( VdbeMemDynamic(p
) ){
488 vdbeMemClearExternAndSetNull(p
);
491 sqlite3DbFreeNN(p
->db
, p
->zMalloc
);
498 ** Release any memory resources held by the Mem. Both the memory that is
499 ** free by Mem.xDel and the Mem.zMalloc allocation are freed.
501 ** Use this routine prior to clean up prior to abandoning a Mem, or to
502 ** reset a Mem back to its minimum memory utilization.
504 ** Use sqlite3VdbeMemSetNull() to release just the Mem.xDel space
505 ** prior to inserting new content into the Mem.
507 void sqlite3VdbeMemRelease(Mem
*p
){
508 assert( sqlite3VdbeCheckMemInvariants(p
) );
509 if( VdbeMemDynamic(p
) || p
->szMalloc
){
515 ** Convert a 64-bit IEEE double into a 64-bit signed integer.
516 ** If the double is out of range of a 64-bit signed integer then
517 ** return the closest available 64-bit signed integer.
519 static SQLITE_NOINLINE i64
doubleToInt64(double r
){
520 #ifdef SQLITE_OMIT_FLOATING_POINT
521 /* When floating-point is omitted, double and int64 are the same thing */
525 ** Many compilers we encounter do not define constants for the
526 ** minimum and maximum 64-bit integers, or they define them
527 ** inconsistently. And many do not understand the "LL" notation.
528 ** So we define our own static constants here using nothing
529 ** larger than a 32-bit integer constant.
531 static const i64 maxInt
= LARGEST_INT64
;
532 static const i64 minInt
= SMALLEST_INT64
;
534 if( r
<=(double)minInt
){
536 }else if( r
>=(double)maxInt
){
545 ** Return some kind of integer value which is the best we can do
546 ** at representing the value that *pMem describes as an integer.
547 ** If pMem is an integer, then the value is exact. If pMem is
548 ** a floating-point then the value returned is the integer part.
549 ** If pMem is a string or blob, then we make an attempt to convert
550 ** it into an integer and return that. If pMem represents an
551 ** an SQL-NULL value, return 0.
553 ** If pMem represents a string value, its encoding might be changed.
555 static SQLITE_NOINLINE i64
memIntValue(Mem
*pMem
){
557 sqlite3Atoi64(pMem
->z
, &value
, pMem
->n
, pMem
->enc
);
560 i64
sqlite3VdbeIntValue(Mem
*pMem
){
562 assert( pMem
->db
==0 || sqlite3_mutex_held(pMem
->db
->mutex
) );
563 assert( EIGHT_BYTE_ALIGNMENT(pMem
) );
565 if( flags
& MEM_Int
){
567 }else if( flags
& MEM_Real
){
568 return doubleToInt64(pMem
->u
.r
);
569 }else if( flags
& (MEM_Str
|MEM_Blob
) ){
570 assert( pMem
->z
|| pMem
->n
==0 );
571 return memIntValue(pMem
);
578 ** Return the best representation of pMem that we can get into a
579 ** double. If pMem is already a double or an integer, return its
580 ** value. If it is a string or blob, try to convert it to a double.
581 ** If it is a NULL, return 0.0.
583 static SQLITE_NOINLINE
double memRealValue(Mem
*pMem
){
584 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
585 double val
= (double)0;
586 sqlite3AtoF(pMem
->z
, &val
, pMem
->n
, pMem
->enc
);
589 double sqlite3VdbeRealValue(Mem
*pMem
){
590 assert( pMem
->db
==0 || sqlite3_mutex_held(pMem
->db
->mutex
) );
591 assert( EIGHT_BYTE_ALIGNMENT(pMem
) );
592 if( pMem
->flags
& MEM_Real
){
594 }else if( pMem
->flags
& MEM_Int
){
595 return (double)pMem
->u
.i
;
596 }else if( pMem
->flags
& (MEM_Str
|MEM_Blob
) ){
597 return memRealValue(pMem
);
599 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
605 ** Return 1 if pMem represents true, and return 0 if pMem represents false.
606 ** Return the value ifNull if pMem is NULL.
608 int sqlite3VdbeBooleanValue(Mem
*pMem
, int ifNull
){
609 if( pMem
->flags
& MEM_Int
) return pMem
->u
.i
!=0;
610 if( pMem
->flags
& MEM_Null
) return ifNull
;
611 return sqlite3VdbeRealValue(pMem
)!=0.0;
615 ** The MEM structure is already a MEM_Real. Try to also make it a
616 ** MEM_Int if we can.
618 void sqlite3VdbeIntegerAffinity(Mem
*pMem
){
620 assert( pMem
->flags
& MEM_Real
);
621 assert( (pMem
->flags
& MEM_RowSet
)==0 );
622 assert( pMem
->db
==0 || sqlite3_mutex_held(pMem
->db
->mutex
) );
623 assert( EIGHT_BYTE_ALIGNMENT(pMem
) );
625 ix
= doubleToInt64(pMem
->u
.r
);
627 /* Only mark the value as an integer if
629 ** (1) the round-trip conversion real->int->real is a no-op, and
630 ** (2) The integer is neither the largest nor the smallest
631 ** possible integer (ticket #3922)
633 ** The second and third terms in the following conditional enforces
634 ** the second condition under the assumption that addition overflow causes
635 ** values to wrap around.
637 if( pMem
->u
.r
==ix
&& ix
>SMALLEST_INT64
&& ix
<LARGEST_INT64
){
639 MemSetTypeFlag(pMem
, MEM_Int
);
644 ** Convert pMem to type integer. Invalidate any prior representations.
646 int sqlite3VdbeMemIntegerify(Mem
*pMem
){
647 assert( pMem
->db
==0 || sqlite3_mutex_held(pMem
->db
->mutex
) );
648 assert( (pMem
->flags
& MEM_RowSet
)==0 );
649 assert( EIGHT_BYTE_ALIGNMENT(pMem
) );
651 pMem
->u
.i
= sqlite3VdbeIntValue(pMem
);
652 MemSetTypeFlag(pMem
, MEM_Int
);
657 ** Convert pMem so that it is of type MEM_Real.
658 ** Invalidate any prior representations.
660 int sqlite3VdbeMemRealify(Mem
*pMem
){
661 assert( pMem
->db
==0 || sqlite3_mutex_held(pMem
->db
->mutex
) );
662 assert( EIGHT_BYTE_ALIGNMENT(pMem
) );
664 pMem
->u
.r
= sqlite3VdbeRealValue(pMem
);
665 MemSetTypeFlag(pMem
, MEM_Real
);
669 /* Compare a floating point value to an integer. Return true if the two
670 ** values are the same within the precision of the floating point value.
672 ** For some versions of GCC on 32-bit machines, if you do the more obvious
673 ** comparison of "r1==(double)i" you sometimes get an answer of false even
674 ** though the r1 and (double)i values are bit-for-bit the same.
676 static int sqlite3RealSameAsInt(double r1
, sqlite3_int64 i
){
677 double r2
= (double)i
;
678 return memcmp(&r1
, &r2
, sizeof(r1
))==0;
682 ** Convert pMem so that it has types MEM_Real or MEM_Int or both.
683 ** Invalidate any prior representations.
685 ** Every effort is made to force the conversion, even if the input
686 ** is a string that does not look completely like a number. Convert
687 ** as much of the string as we can and ignore the rest.
689 int sqlite3VdbeMemNumerify(Mem
*pMem
){
690 if( (pMem
->flags
& (MEM_Int
|MEM_Real
|MEM_Null
))==0 ){
692 assert( (pMem
->flags
& (MEM_Blob
|MEM_Str
))!=0 );
693 assert( pMem
->db
==0 || sqlite3_mutex_held(pMem
->db
->mutex
) );
694 rc
= sqlite3Atoi64(pMem
->z
, &pMem
->u
.i
, pMem
->n
, pMem
->enc
);
696 MemSetTypeFlag(pMem
, MEM_Int
);
699 sqlite3AtoF(pMem
->z
, &pMem
->u
.r
, pMem
->n
, pMem
->enc
);
700 if( rc
==1 && sqlite3RealSameAsInt(pMem
->u
.r
, i
) ){
702 MemSetTypeFlag(pMem
, MEM_Int
);
704 MemSetTypeFlag(pMem
, MEM_Real
);
708 assert( (pMem
->flags
& (MEM_Int
|MEM_Real
|MEM_Null
))!=0 );
709 pMem
->flags
&= ~(MEM_Str
|MEM_Blob
|MEM_Zero
);
714 ** Cast the datatype of the value in pMem according to the affinity
715 ** "aff". Casting is different from applying affinity in that a cast
716 ** is forced. In other words, the value is converted into the desired
717 ** affinity even if that results in loss of data. This routine is
718 ** used (for example) to implement the SQL "cast()" operator.
720 void sqlite3VdbeMemCast(Mem
*pMem
, u8 aff
, u8 encoding
){
721 if( pMem
->flags
& MEM_Null
) return;
723 case SQLITE_AFF_BLOB
: { /* Really a cast to BLOB */
724 if( (pMem
->flags
& MEM_Blob
)==0 ){
725 sqlite3ValueApplyAffinity(pMem
, SQLITE_AFF_TEXT
, encoding
);
726 assert( pMem
->flags
& MEM_Str
|| pMem
->db
->mallocFailed
);
727 if( pMem
->flags
& MEM_Str
) MemSetTypeFlag(pMem
, MEM_Blob
);
729 pMem
->flags
&= ~(MEM_TypeMask
&~MEM_Blob
);
733 case SQLITE_AFF_NUMERIC
: {
734 sqlite3VdbeMemNumerify(pMem
);
737 case SQLITE_AFF_INTEGER
: {
738 sqlite3VdbeMemIntegerify(pMem
);
741 case SQLITE_AFF_REAL
: {
742 sqlite3VdbeMemRealify(pMem
);
746 assert( aff
==SQLITE_AFF_TEXT
);
747 assert( MEM_Str
==(MEM_Blob
>>3) );
748 pMem
->flags
|= (pMem
->flags
&MEM_Blob
)>>3;
749 sqlite3ValueApplyAffinity(pMem
, SQLITE_AFF_TEXT
, encoding
);
750 assert( pMem
->flags
& MEM_Str
|| pMem
->db
->mallocFailed
);
751 pMem
->flags
&= ~(MEM_Int
|MEM_Real
|MEM_Blob
|MEM_Zero
);
758 ** Initialize bulk memory to be a consistent Mem object.
760 ** The minimum amount of initialization feasible is performed.
762 void sqlite3VdbeMemInit(Mem
*pMem
, sqlite3
*db
, u16 flags
){
763 assert( (flags
& ~MEM_TypeMask
)==0 );
771 ** Delete any previous value and set the value stored in *pMem to NULL.
773 ** This routine calls the Mem.xDel destructor to dispose of values that
774 ** require the destructor. But it preserves the Mem.zMalloc memory allocation.
775 ** To free all resources, use sqlite3VdbeMemRelease(), which both calls this
776 ** routine to invoke the destructor and deallocates Mem.zMalloc.
778 ** Use this routine to reset the Mem prior to insert a new value.
780 ** Use sqlite3VdbeMemRelease() to complete erase the Mem prior to abandoning it.
782 void sqlite3VdbeMemSetNull(Mem
*pMem
){
783 if( VdbeMemDynamic(pMem
) ){
784 vdbeMemClearExternAndSetNull(pMem
);
786 pMem
->flags
= MEM_Null
;
789 void sqlite3ValueSetNull(sqlite3_value
*p
){
790 sqlite3VdbeMemSetNull((Mem
*)p
);
794 ** Delete any previous value and set the value to be a BLOB of length
795 ** n containing all zeros.
797 void sqlite3VdbeMemSetZeroBlob(Mem
*pMem
, int n
){
798 sqlite3VdbeMemRelease(pMem
);
799 pMem
->flags
= MEM_Blob
|MEM_Zero
;
803 pMem
->enc
= SQLITE_UTF8
;
808 ** The pMem is known to contain content that needs to be destroyed prior
809 ** to a value change. So invoke the destructor, then set the value to
812 static SQLITE_NOINLINE
void vdbeReleaseAndSetInt64(Mem
*pMem
, i64 val
){
813 sqlite3VdbeMemSetNull(pMem
);
815 pMem
->flags
= MEM_Int
;
819 ** Delete any previous value and set the value stored in *pMem to val,
820 ** manifest type INTEGER.
822 void sqlite3VdbeMemSetInt64(Mem
*pMem
, i64 val
){
823 if( VdbeMemDynamic(pMem
) ){
824 vdbeReleaseAndSetInt64(pMem
, val
);
827 pMem
->flags
= MEM_Int
;
831 /* A no-op destructor */
832 void sqlite3NoopDestructor(void *p
){ UNUSED_PARAMETER(p
); }
835 ** Set the value stored in *pMem should already be a NULL.
836 ** Also store a pointer to go with it.
838 void sqlite3VdbeMemSetPointer(
842 void (*xDestructor
)(void*)
844 assert( pMem
->flags
==MEM_Null
);
845 pMem
->u
.zPType
= zPType
? zPType
: "";
847 pMem
->flags
= MEM_Null
|MEM_Dyn
|MEM_Subtype
|MEM_Term
;
848 pMem
->eSubtype
= 'p';
849 pMem
->xDel
= xDestructor
? xDestructor
: sqlite3NoopDestructor
;
852 #ifndef SQLITE_OMIT_FLOATING_POINT
854 ** Delete any previous value and set the value stored in *pMem to val,
855 ** manifest type REAL.
857 void sqlite3VdbeMemSetDouble(Mem
*pMem
, double val
){
858 sqlite3VdbeMemSetNull(pMem
);
859 if( !sqlite3IsNaN(val
) ){
861 pMem
->flags
= MEM_Real
;
867 ** Delete any previous value and set the value of pMem to be an
868 ** empty boolean index.
870 void sqlite3VdbeMemSetRowSet(Mem
*pMem
){
871 sqlite3
*db
= pMem
->db
;
873 assert( (pMem
->flags
& MEM_RowSet
)==0 );
874 sqlite3VdbeMemRelease(pMem
);
875 pMem
->zMalloc
= sqlite3DbMallocRawNN(db
, 64);
876 if( db
->mallocFailed
){
877 pMem
->flags
= MEM_Null
;
880 assert( pMem
->zMalloc
);
881 pMem
->szMalloc
= sqlite3DbMallocSize(db
, pMem
->zMalloc
);
882 pMem
->u
.pRowSet
= sqlite3RowSetInit(db
, pMem
->zMalloc
, pMem
->szMalloc
);
883 assert( pMem
->u
.pRowSet
!=0 );
884 pMem
->flags
= MEM_RowSet
;
889 ** Return true if the Mem object contains a TEXT or BLOB that is
890 ** too large - whose size exceeds SQLITE_MAX_LENGTH.
892 int sqlite3VdbeMemTooBig(Mem
*p
){
894 if( p
->flags
& (MEM_Str
|MEM_Blob
) ){
896 if( p
->flags
& MEM_Zero
){
899 return n
>p
->db
->aLimit
[SQLITE_LIMIT_LENGTH
];
906 ** This routine prepares a memory cell for modification by breaking
907 ** its link to a shallow copy and by marking any current shallow
908 ** copies of this cell as invalid.
910 ** This is used for testing and debugging only - to make sure shallow
911 ** copies are not misused.
913 void sqlite3VdbeMemAboutToChange(Vdbe
*pVdbe
, Mem
*pMem
){
916 for(i
=0, pX
=pVdbe
->aMem
; i
<pVdbe
->nMem
; i
++, pX
++){
917 if( pX
->pScopyFrom
==pMem
){
918 /* If pX is marked as a shallow copy of pMem, then verify that
919 ** no significant changes have been made to pX since the OP_SCopy.
920 ** A significant change would indicated a missed call to this
921 ** function for pX. Minor changes, such as adding or removing a
922 ** dual type, are allowed, as long as the underlying value is the
924 u16 mFlags
= pMem
->flags
& pX
->flags
& pX
->mScopyFlags
;
925 assert( (mFlags
&MEM_Int
)==0 || pMem
->u
.i
==pX
->u
.i
);
926 assert( (mFlags
&MEM_Real
)==0 || pMem
->u
.r
==pX
->u
.r
);
927 assert( (mFlags
&MEM_Str
)==0 || (pMem
->n
==pX
->n
&& pMem
->z
==pX
->z
) );
928 assert( (mFlags
&MEM_Blob
)==0 || sqlite3BlobCompare(pMem
,pX
)==0 );
930 /* pMem is the register that is changing. But also mark pX as
931 ** undefined so that we can quickly detect the shallow-copy error */
932 pX
->flags
= MEM_Undefined
;
936 pMem
->pScopyFrom
= 0;
937 #ifdef SQLITE_DEBUG_COLUMN_CACHE
938 pMem
->iTabColHash
= 0;
941 #endif /* SQLITE_DEBUG */
945 ** Make an shallow copy of pFrom into pTo. Prior contents of
946 ** pTo are freed. The pFrom->z field is not duplicated. If
947 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
948 ** and flags gets srcType (either MEM_Ephem or MEM_Static).
950 static SQLITE_NOINLINE
void vdbeClrCopy(Mem
*pTo
, const Mem
*pFrom
, int eType
){
951 vdbeMemClearExternAndSetNull(pTo
);
952 assert( !VdbeMemDynamic(pTo
) );
953 sqlite3VdbeMemShallowCopy(pTo
, pFrom
, eType
);
955 void sqlite3VdbeMemShallowCopy(Mem
*pTo
, const Mem
*pFrom
, int srcType
){
956 assert( (pFrom
->flags
& MEM_RowSet
)==0 );
957 assert( pTo
->db
==pFrom
->db
);
958 if( VdbeMemDynamic(pTo
) ){ vdbeClrCopy(pTo
,pFrom
,srcType
); return; }
959 memcpy(pTo
, pFrom
, MEMCELLSIZE
);
960 #ifdef SQLITE_DEBUG_COLUMNCACHE
961 pTo
->iTabColHash
= pFrom
->iTabColHash
;
963 if( (pFrom
->flags
&MEM_Static
)==0 ){
964 pTo
->flags
&= ~(MEM_Dyn
|MEM_Static
|MEM_Ephem
);
965 assert( srcType
==MEM_Ephem
|| srcType
==MEM_Static
);
966 pTo
->flags
|= srcType
;
971 ** Make a full copy of pFrom into pTo. Prior contents of pTo are
972 ** freed before the copy is made.
974 int sqlite3VdbeMemCopy(Mem
*pTo
, const Mem
*pFrom
){
977 assert( (pFrom
->flags
& MEM_RowSet
)==0 );
978 if( VdbeMemDynamic(pTo
) ) vdbeMemClearExternAndSetNull(pTo
);
979 memcpy(pTo
, pFrom
, MEMCELLSIZE
);
980 #ifdef SQLITE_DEBUG_COLUMNCACHE
981 pTo
->iTabColHash
= pFrom
->iTabColHash
;
983 pTo
->flags
&= ~MEM_Dyn
;
984 if( pTo
->flags
&(MEM_Str
|MEM_Blob
) ){
985 if( 0==(pFrom
->flags
&MEM_Static
) ){
986 pTo
->flags
|= MEM_Ephem
;
987 rc
= sqlite3VdbeMemMakeWriteable(pTo
);
995 ** Transfer the contents of pFrom to pTo. Any existing value in pTo is
996 ** freed. If pFrom contains ephemeral data, a copy is made.
998 ** pFrom contains an SQL NULL when this routine returns.
1000 void sqlite3VdbeMemMove(Mem
*pTo
, Mem
*pFrom
){
1001 assert( pFrom
->db
==0 || sqlite3_mutex_held(pFrom
->db
->mutex
) );
1002 assert( pTo
->db
==0 || sqlite3_mutex_held(pTo
->db
->mutex
) );
1003 assert( pFrom
->db
==0 || pTo
->db
==0 || pFrom
->db
==pTo
->db
);
1005 sqlite3VdbeMemRelease(pTo
);
1006 memcpy(pTo
, pFrom
, sizeof(Mem
));
1007 pFrom
->flags
= MEM_Null
;
1008 pFrom
->szMalloc
= 0;
1012 ** Change the value of a Mem to be a string or a BLOB.
1014 ** The memory management strategy depends on the value of the xDel
1015 ** parameter. If the value passed is SQLITE_TRANSIENT, then the
1016 ** string is copied into a (possibly existing) buffer managed by the
1017 ** Mem structure. Otherwise, any existing buffer is freed and the
1020 ** If the string is too large (if it exceeds the SQLITE_LIMIT_LENGTH
1021 ** size limit) then no memory allocation occurs. If the string can be
1022 ** stored without allocating memory, then it is. If a memory allocation
1023 ** is required to store the string, then value of pMem is unchanged. In
1024 ** either case, SQLITE_TOOBIG is returned.
1026 int sqlite3VdbeMemSetStr(
1027 Mem
*pMem
, /* Memory cell to set to string value */
1028 const char *z
, /* String pointer */
1029 int n
, /* Bytes in string, or negative */
1030 u8 enc
, /* Encoding of z. 0 for BLOBs */
1031 void (*xDel
)(void*) /* Destructor function */
1033 int nByte
= n
; /* New value for pMem->n */
1034 int iLimit
; /* Maximum allowed string or blob size */
1035 u16 flags
= 0; /* New value for pMem->flags */
1037 assert( pMem
->db
==0 || sqlite3_mutex_held(pMem
->db
->mutex
) );
1038 assert( (pMem
->flags
& MEM_RowSet
)==0 );
1040 /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
1042 sqlite3VdbeMemSetNull(pMem
);
1047 iLimit
= pMem
->db
->aLimit
[SQLITE_LIMIT_LENGTH
];
1049 iLimit
= SQLITE_MAX_LENGTH
;
1051 flags
= (enc
==0?MEM_Blob
:MEM_Str
);
1054 if( enc
==SQLITE_UTF8
){
1055 nByte
= 0x7fffffff & (int)strlen(z
);
1056 if( nByte
>iLimit
) nByte
= iLimit
+1;
1058 for(nByte
=0; nByte
<=iLimit
&& (z
[nByte
] | z
[nByte
+1]); nByte
+=2){}
1063 /* The following block sets the new values of Mem.z and Mem.xDel. It
1064 ** also sets a flag in local variable "flags" to indicate the memory
1065 ** management (one of MEM_Dyn or MEM_Static).
1067 if( xDel
==SQLITE_TRANSIENT
){
1069 if( flags
&MEM_Term
){
1070 nAlloc
+= (enc
==SQLITE_UTF8
?1:2);
1073 return SQLITE_TOOBIG
;
1075 testcase( nAlloc
==0 );
1076 testcase( nAlloc
==31 );
1077 testcase( nAlloc
==32 );
1078 if( sqlite3VdbeMemClearAndResize(pMem
, MAX(nAlloc
,32)) ){
1079 return SQLITE_NOMEM_BKPT
;
1081 memcpy(pMem
->z
, z
, nAlloc
);
1082 }else if( xDel
==SQLITE_DYNAMIC
){
1083 sqlite3VdbeMemRelease(pMem
);
1084 pMem
->zMalloc
= pMem
->z
= (char *)z
;
1085 pMem
->szMalloc
= sqlite3DbMallocSize(pMem
->db
, pMem
->zMalloc
);
1087 sqlite3VdbeMemRelease(pMem
);
1088 pMem
->z
= (char *)z
;
1090 flags
|= ((xDel
==SQLITE_STATIC
)?MEM_Static
:MEM_Dyn
);
1094 pMem
->flags
= flags
;
1095 pMem
->enc
= (enc
==0 ? SQLITE_UTF8
: enc
);
1097 #ifndef SQLITE_OMIT_UTF16
1098 if( pMem
->enc
!=SQLITE_UTF8
&& sqlite3VdbeMemHandleBom(pMem
) ){
1099 return SQLITE_NOMEM_BKPT
;
1104 return SQLITE_TOOBIG
;
1111 ** Move data out of a btree key or data field and into a Mem structure.
1112 ** The data is payload from the entry that pCur is currently pointing
1113 ** to. offset and amt determine what portion of the data or key to retrieve.
1114 ** The result is written into the pMem element.
1116 ** The pMem object must have been initialized. This routine will use
1117 ** pMem->zMalloc to hold the content from the btree, if possible. New
1118 ** pMem->zMalloc space will be allocated if necessary. The calling routine
1119 ** is responsible for making sure that the pMem object is eventually
1122 ** If this routine fails for any reason (malloc returns NULL or unable
1123 ** to read from the disk) then the pMem is left in an inconsistent state.
1125 static SQLITE_NOINLINE
int vdbeMemFromBtreeResize(
1126 BtCursor
*pCur
, /* Cursor pointing at record to retrieve. */
1127 u32 offset
, /* Offset from the start of data to return bytes from. */
1128 u32 amt
, /* Number of bytes to return. */
1129 Mem
*pMem
/* OUT: Return data in this Mem structure. */
1132 pMem
->flags
= MEM_Null
;
1133 if( SQLITE_OK
==(rc
= sqlite3VdbeMemClearAndResize(pMem
, amt
+1)) ){
1134 rc
= sqlite3BtreePayload(pCur
, offset
, amt
, pMem
->z
);
1135 if( rc
==SQLITE_OK
){
1136 pMem
->z
[amt
] = 0; /* Overrun area used when reading malformed records */
1137 pMem
->flags
= MEM_Blob
;
1140 sqlite3VdbeMemRelease(pMem
);
1145 int sqlite3VdbeMemFromBtree(
1146 BtCursor
*pCur
, /* Cursor pointing at record to retrieve. */
1147 u32 offset
, /* Offset from the start of data to return bytes from. */
1148 u32 amt
, /* Number of bytes to return. */
1149 Mem
*pMem
/* OUT: Return data in this Mem structure. */
1151 char *zData
; /* Data from the btree layer */
1152 u32 available
= 0; /* Number of bytes available on the local btree page */
1153 int rc
= SQLITE_OK
; /* Return code */
1155 assert( sqlite3BtreeCursorIsValid(pCur
) );
1156 assert( !VdbeMemDynamic(pMem
) );
1158 /* Note: the calls to BtreeKeyFetch() and DataFetch() below assert()
1159 ** that both the BtShared and database handle mutexes are held. */
1160 assert( (pMem
->flags
& MEM_RowSet
)==0 );
1161 zData
= (char *)sqlite3BtreePayloadFetch(pCur
, &available
);
1164 if( offset
+amt
<=available
){
1165 pMem
->z
= &zData
[offset
];
1166 pMem
->flags
= MEM_Blob
|MEM_Ephem
;
1169 rc
= vdbeMemFromBtreeResize(pCur
, offset
, amt
, pMem
);
1176 ** The pVal argument is known to be a value other than NULL.
1177 ** Convert it into a string with encoding enc and return a pointer
1178 ** to a zero-terminated version of that string.
1180 static SQLITE_NOINLINE
const void *valueToText(sqlite3_value
* pVal
, u8 enc
){
1182 assert( pVal
->db
==0 || sqlite3_mutex_held(pVal
->db
->mutex
) );
1183 assert( (enc
&3)==(enc
&~SQLITE_UTF16_ALIGNED
) );
1184 assert( (pVal
->flags
& MEM_RowSet
)==0 );
1185 assert( (pVal
->flags
& (MEM_Null
))==0 );
1186 if( pVal
->flags
& (MEM_Blob
|MEM_Str
) ){
1187 if( ExpandBlob(pVal
) ) return 0;
1188 pVal
->flags
|= MEM_Str
;
1189 if( pVal
->enc
!= (enc
& ~SQLITE_UTF16_ALIGNED
) ){
1190 sqlite3VdbeChangeEncoding(pVal
, enc
& ~SQLITE_UTF16_ALIGNED
);
1192 if( (enc
& SQLITE_UTF16_ALIGNED
)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal
->z
)) ){
1193 assert( (pVal
->flags
& (MEM_Ephem
|MEM_Static
))!=0 );
1194 if( sqlite3VdbeMemMakeWriteable(pVal
)!=SQLITE_OK
){
1198 sqlite3VdbeMemNulTerminate(pVal
); /* IMP: R-31275-44060 */
1200 sqlite3VdbeMemStringify(pVal
, enc
, 0);
1201 assert( 0==(1&SQLITE_PTR_TO_INT(pVal
->z
)) );
1203 assert(pVal
->enc
==(enc
& ~SQLITE_UTF16_ALIGNED
) || pVal
->db
==0
1204 || pVal
->db
->mallocFailed
);
1205 if( pVal
->enc
==(enc
& ~SQLITE_UTF16_ALIGNED
) ){
1206 assert( sqlite3VdbeMemConsistentDualRep(pVal
) );
1213 /* This function is only available internally, it is not part of the
1214 ** external API. It works in a similar way to sqlite3_value_text(),
1215 ** except the data returned is in the encoding specified by the second
1216 ** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
1219 ** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
1220 ** If that is the case, then the result must be aligned on an even byte
1223 const void *sqlite3ValueText(sqlite3_value
* pVal
, u8 enc
){
1224 if( !pVal
) return 0;
1225 assert( pVal
->db
==0 || sqlite3_mutex_held(pVal
->db
->mutex
) );
1226 assert( (enc
&3)==(enc
&~SQLITE_UTF16_ALIGNED
) );
1227 assert( (pVal
->flags
& MEM_RowSet
)==0 );
1228 if( (pVal
->flags
&(MEM_Str
|MEM_Term
))==(MEM_Str
|MEM_Term
) && pVal
->enc
==enc
){
1229 assert( sqlite3VdbeMemConsistentDualRep(pVal
) );
1232 if( pVal
->flags
&MEM_Null
){
1235 return valueToText(pVal
, enc
);
1239 ** Create a new sqlite3_value object.
1241 sqlite3_value
*sqlite3ValueNew(sqlite3
*db
){
1242 Mem
*p
= sqlite3DbMallocZero(db
, sizeof(*p
));
1244 p
->flags
= MEM_Null
;
1251 ** Context object passed by sqlite3Stat4ProbeSetValue() through to
1252 ** valueNew(). See comments above valueNew() for details.
1254 struct ValueNewStat4Ctx
{
1257 UnpackedRecord
**ppRec
;
1262 ** Allocate and return a pointer to a new sqlite3_value object. If
1263 ** the second argument to this function is NULL, the object is allocated
1264 ** by calling sqlite3ValueNew().
1266 ** Otherwise, if the second argument is non-zero, then this function is
1267 ** being called indirectly by sqlite3Stat4ProbeSetValue(). If it has not
1268 ** already been allocated, allocate the UnpackedRecord structure that
1269 ** that function will return to its caller here. Then return a pointer to
1270 ** an sqlite3_value within the UnpackedRecord.a[] array.
1272 static sqlite3_value
*valueNew(sqlite3
*db
, struct ValueNewStat4Ctx
*p
){
1273 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
1275 UnpackedRecord
*pRec
= p
->ppRec
[0];
1278 Index
*pIdx
= p
->pIdx
; /* Index being probed */
1279 int nByte
; /* Bytes of space to allocate */
1280 int i
; /* Counter variable */
1281 int nCol
= pIdx
->nColumn
; /* Number of index columns including rowid */
1283 nByte
= sizeof(Mem
) * nCol
+ ROUND8(sizeof(UnpackedRecord
));
1284 pRec
= (UnpackedRecord
*)sqlite3DbMallocZero(db
, nByte
);
1286 pRec
->pKeyInfo
= sqlite3KeyInfoOfIndex(p
->pParse
, pIdx
);
1287 if( pRec
->pKeyInfo
){
1288 assert( pRec
->pKeyInfo
->nAllField
==nCol
);
1289 assert( pRec
->pKeyInfo
->enc
==ENC(db
) );
1290 pRec
->aMem
= (Mem
*)((u8
*)pRec
+ ROUND8(sizeof(UnpackedRecord
)));
1291 for(i
=0; i
<nCol
; i
++){
1292 pRec
->aMem
[i
].flags
= MEM_Null
;
1293 pRec
->aMem
[i
].db
= db
;
1296 sqlite3DbFreeNN(db
, pRec
);
1300 if( pRec
==0 ) return 0;
1304 pRec
->nField
= p
->iVal
+1;
1305 return &pRec
->aMem
[p
->iVal
];
1308 UNUSED_PARAMETER(p
);
1309 #endif /* defined(SQLITE_ENABLE_STAT3_OR_STAT4) */
1310 return sqlite3ValueNew(db
);
1314 ** The expression object indicated by the second argument is guaranteed
1315 ** to be a scalar SQL function. If
1317 ** * all function arguments are SQL literals,
1318 ** * one of the SQLITE_FUNC_CONSTANT or _SLOCHNG function flags is set, and
1319 ** * the SQLITE_FUNC_NEEDCOLL function flag is not set,
1321 ** then this routine attempts to invoke the SQL function. Assuming no
1322 ** error occurs, output parameter (*ppVal) is set to point to a value
1323 ** object containing the result before returning SQLITE_OK.
1325 ** Affinity aff is applied to the result of the function before returning.
1326 ** If the result is a text value, the sqlite3_value object uses encoding
1329 ** If the conditions above are not met, this function returns SQLITE_OK
1330 ** and sets (*ppVal) to NULL. Or, if an error occurs, (*ppVal) is set to
1331 ** NULL and an SQLite error code returned.
1333 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
1334 static int valueFromFunction(
1335 sqlite3
*db
, /* The database connection */
1336 Expr
*p
, /* The expression to evaluate */
1337 u8 enc
, /* Encoding to use */
1338 u8 aff
, /* Affinity to use */
1339 sqlite3_value
**ppVal
, /* Write the new value here */
1340 struct ValueNewStat4Ctx
*pCtx
/* Second argument for valueNew() */
1342 sqlite3_context ctx
; /* Context object for function invocation */
1343 sqlite3_value
**apVal
= 0; /* Function arguments */
1344 int nVal
= 0; /* Size of apVal[] array */
1345 FuncDef
*pFunc
= 0; /* Function definition */
1346 sqlite3_value
*pVal
= 0; /* New value */
1347 int rc
= SQLITE_OK
; /* Return code */
1348 ExprList
*pList
= 0; /* Function arguments */
1349 int i
; /* Iterator variable */
1352 assert( (p
->flags
& EP_TokenOnly
)==0 );
1354 if( pList
) nVal
= pList
->nExpr
;
1355 pFunc
= sqlite3FindFunction(db
, p
->u
.zToken
, nVal
, enc
, 0);
1357 if( (pFunc
->funcFlags
& (SQLITE_FUNC_CONSTANT
|SQLITE_FUNC_SLOCHNG
))==0
1358 || (pFunc
->funcFlags
& SQLITE_FUNC_NEEDCOLL
)
1364 apVal
= (sqlite3_value
**)sqlite3DbMallocZero(db
, sizeof(apVal
[0]) * nVal
);
1366 rc
= SQLITE_NOMEM_BKPT
;
1367 goto value_from_function_out
;
1369 for(i
=0; i
<nVal
; i
++){
1370 rc
= sqlite3ValueFromExpr(db
, pList
->a
[i
].pExpr
, enc
, aff
, &apVal
[i
]);
1371 if( apVal
[i
]==0 || rc
!=SQLITE_OK
) goto value_from_function_out
;
1375 pVal
= valueNew(db
, pCtx
);
1377 rc
= SQLITE_NOMEM_BKPT
;
1378 goto value_from_function_out
;
1381 assert( pCtx
->pParse
->rc
==SQLITE_OK
);
1382 memset(&ctx
, 0, sizeof(ctx
));
1385 pFunc
->xSFunc(&ctx
, nVal
, apVal
);
1388 sqlite3ErrorMsg(pCtx
->pParse
, "%s", sqlite3_value_text(pVal
));
1390 sqlite3ValueApplyAffinity(pVal
, aff
, SQLITE_UTF8
);
1391 assert( rc
==SQLITE_OK
);
1392 rc
= sqlite3VdbeChangeEncoding(pVal
, enc
);
1393 if( rc
==SQLITE_OK
&& sqlite3VdbeMemTooBig(pVal
) ){
1395 pCtx
->pParse
->nErr
++;
1398 pCtx
->pParse
->rc
= rc
;
1400 value_from_function_out
:
1401 if( rc
!=SQLITE_OK
){
1405 for(i
=0; i
<nVal
; i
++){
1406 sqlite3ValueFree(apVal
[i
]);
1408 sqlite3DbFreeNN(db
, apVal
);
1415 # define valueFromFunction(a,b,c,d,e,f) SQLITE_OK
1416 #endif /* defined(SQLITE_ENABLE_STAT3_OR_STAT4) */
1419 ** Extract a value from the supplied expression in the manner described
1420 ** above sqlite3ValueFromExpr(). Allocate the sqlite3_value object
1421 ** using valueNew().
1423 ** If pCtx is NULL and an error occurs after the sqlite3_value object
1424 ** has been allocated, it is freed before returning. Or, if pCtx is not
1425 ** NULL, it is assumed that the caller will free any allocated object
1428 static int valueFromExpr(
1429 sqlite3
*db
, /* The database connection */
1430 Expr
*pExpr
, /* The expression to evaluate */
1431 u8 enc
, /* Encoding to use */
1432 u8 affinity
, /* Affinity to use */
1433 sqlite3_value
**ppVal
, /* Write the new value here */
1434 struct ValueNewStat4Ctx
*pCtx
/* Second argument for valueNew() */
1438 sqlite3_value
*pVal
= 0;
1440 const char *zNeg
= "";
1444 while( (op
= pExpr
->op
)==TK_UPLUS
|| op
==TK_SPAN
) pExpr
= pExpr
->pLeft
;
1445 #if defined(SQLITE_ENABLE_STAT3_OR_STAT4)
1446 if( op
==TK_REGISTER
) op
= pExpr
->op2
;
1448 if( NEVER(op
==TK_REGISTER
) ) op
= pExpr
->op2
;
1451 /* Compressed expressions only appear when parsing the DEFAULT clause
1452 ** on a table column definition, and hence only when pCtx==0. This
1453 ** check ensures that an EP_TokenOnly expression is never passed down
1454 ** into valueFromFunction(). */
1455 assert( (pExpr
->flags
& EP_TokenOnly
)==0 || pCtx
==0 );
1458 u8 aff
= sqlite3AffinityType(pExpr
->u
.zToken
,0);
1459 rc
= valueFromExpr(db
, pExpr
->pLeft
, enc
, aff
, ppVal
, pCtx
);
1460 testcase( rc
!=SQLITE_OK
);
1462 sqlite3VdbeMemCast(*ppVal
, aff
, SQLITE_UTF8
);
1463 sqlite3ValueApplyAffinity(*ppVal
, affinity
, SQLITE_UTF8
);
1468 /* Handle negative integers in a single step. This is needed in the
1469 ** case when the value is -9223372036854775808.
1472 && (pExpr
->pLeft
->op
==TK_INTEGER
|| pExpr
->pLeft
->op
==TK_FLOAT
) ){
1473 pExpr
= pExpr
->pLeft
;
1479 if( op
==TK_STRING
|| op
==TK_FLOAT
|| op
==TK_INTEGER
){
1480 pVal
= valueNew(db
, pCtx
);
1481 if( pVal
==0 ) goto no_mem
;
1482 if( ExprHasProperty(pExpr
, EP_IntValue
) ){
1483 sqlite3VdbeMemSetInt64(pVal
, (i64
)pExpr
->u
.iValue
*negInt
);
1485 zVal
= sqlite3MPrintf(db
, "%s%s", zNeg
, pExpr
->u
.zToken
);
1486 if( zVal
==0 ) goto no_mem
;
1487 sqlite3ValueSetStr(pVal
, -1, zVal
, SQLITE_UTF8
, SQLITE_DYNAMIC
);
1489 if( (op
==TK_INTEGER
|| op
==TK_FLOAT
) && affinity
==SQLITE_AFF_BLOB
){
1490 sqlite3ValueApplyAffinity(pVal
, SQLITE_AFF_NUMERIC
, SQLITE_UTF8
);
1492 sqlite3ValueApplyAffinity(pVal
, affinity
, SQLITE_UTF8
);
1494 if( pVal
->flags
& (MEM_Int
|MEM_Real
) ) pVal
->flags
&= ~MEM_Str
;
1495 if( enc
!=SQLITE_UTF8
){
1496 rc
= sqlite3VdbeChangeEncoding(pVal
, enc
);
1498 }else if( op
==TK_UMINUS
) {
1499 /* This branch happens for multiple negative signs. Ex: -(-5) */
1500 if( SQLITE_OK
==valueFromExpr(db
,pExpr
->pLeft
,enc
,affinity
,&pVal
,pCtx
)
1503 sqlite3VdbeMemNumerify(pVal
);
1504 if( pVal
->flags
& MEM_Real
){
1505 pVal
->u
.r
= -pVal
->u
.r
;
1506 }else if( pVal
->u
.i
==SMALLEST_INT64
){
1507 pVal
->u
.r
= -(double)SMALLEST_INT64
;
1508 MemSetTypeFlag(pVal
, MEM_Real
);
1510 pVal
->u
.i
= -pVal
->u
.i
;
1512 sqlite3ValueApplyAffinity(pVal
, affinity
, enc
);
1514 }else if( op
==TK_NULL
){
1515 pVal
= valueNew(db
, pCtx
);
1516 if( pVal
==0 ) goto no_mem
;
1517 sqlite3VdbeMemNumerify(pVal
);
1519 #ifndef SQLITE_OMIT_BLOB_LITERAL
1520 else if( op
==TK_BLOB
){
1522 assert( pExpr
->u
.zToken
[0]=='x' || pExpr
->u
.zToken
[0]=='X' );
1523 assert( pExpr
->u
.zToken
[1]=='\'' );
1524 pVal
= valueNew(db
, pCtx
);
1525 if( !pVal
) goto no_mem
;
1526 zVal
= &pExpr
->u
.zToken
[2];
1527 nVal
= sqlite3Strlen30(zVal
)-1;
1528 assert( zVal
[nVal
]=='\'' );
1529 sqlite3VdbeMemSetStr(pVal
, sqlite3HexToBlob(db
, zVal
, nVal
), nVal
/2,
1533 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
1534 else if( op
==TK_FUNCTION
&& pCtx
!=0 ){
1535 rc
= valueFromFunction(db
, pExpr
, enc
, affinity
, &pVal
, pCtx
);
1538 else if( op
==TK_TRUEFALSE
){
1539 pVal
= valueNew(db
, pCtx
);
1540 pVal
->flags
= MEM_Int
;
1541 pVal
->u
.i
= pExpr
->u
.zToken
[4]==0;
1548 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
1549 if( pCtx
==0 || pCtx
->pParse
->nErr
==0 )
1551 sqlite3OomFault(db
);
1552 sqlite3DbFree(db
, zVal
);
1553 assert( *ppVal
==0 );
1554 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
1555 if( pCtx
==0 ) sqlite3ValueFree(pVal
);
1557 assert( pCtx
==0 ); sqlite3ValueFree(pVal
);
1559 return SQLITE_NOMEM_BKPT
;
1563 ** Create a new sqlite3_value object, containing the value of pExpr.
1565 ** This only works for very simple expressions that consist of one constant
1566 ** token (i.e. "5", "5.1", "'a string'"). If the expression can
1567 ** be converted directly into a value, then the value is allocated and
1568 ** a pointer written to *ppVal. The caller is responsible for deallocating
1569 ** the value by passing it to sqlite3ValueFree() later on. If the expression
1570 ** cannot be converted to a value, then *ppVal is set to NULL.
1572 int sqlite3ValueFromExpr(
1573 sqlite3
*db
, /* The database connection */
1574 Expr
*pExpr
, /* The expression to evaluate */
1575 u8 enc
, /* Encoding to use */
1576 u8 affinity
, /* Affinity to use */
1577 sqlite3_value
**ppVal
/* Write the new value here */
1579 return pExpr
? valueFromExpr(db
, pExpr
, enc
, affinity
, ppVal
, 0) : 0;
1582 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
1584 ** The implementation of the sqlite_record() function. This function accepts
1585 ** a single argument of any type. The return value is a formatted database
1586 ** record (a blob) containing the argument value.
1588 ** This is used to convert the value stored in the 'sample' column of the
1589 ** sqlite_stat3 table to the record format SQLite uses internally.
1591 static void recordFunc(
1592 sqlite3_context
*context
,
1594 sqlite3_value
**argv
1596 const int file_format
= 1;
1597 u32 iSerial
; /* Serial type */
1598 int nSerial
; /* Bytes of space for iSerial as varint */
1599 u32 nVal
; /* Bytes of space required for argv[0] */
1604 UNUSED_PARAMETER( argc
);
1605 iSerial
= sqlite3VdbeSerialType(argv
[0], file_format
, &nVal
);
1606 nSerial
= sqlite3VarintLen(iSerial
);
1607 db
= sqlite3_context_db_handle(context
);
1609 nRet
= 1 + nSerial
+ nVal
;
1610 aRet
= sqlite3DbMallocRawNN(db
, nRet
);
1612 sqlite3_result_error_nomem(context
);
1614 aRet
[0] = nSerial
+1;
1615 putVarint32(&aRet
[1], iSerial
);
1616 sqlite3VdbeSerialPut(&aRet
[1+nSerial
], argv
[0], iSerial
);
1617 sqlite3_result_blob(context
, aRet
, nRet
, SQLITE_TRANSIENT
);
1618 sqlite3DbFreeNN(db
, aRet
);
1623 ** Register built-in functions used to help read ANALYZE data.
1625 void sqlite3AnalyzeFunctions(void){
1626 static FuncDef aAnalyzeTableFuncs
[] = {
1627 FUNCTION(sqlite_record
, 1, 0, 0, recordFunc
),
1629 sqlite3InsertBuiltinFuncs(aAnalyzeTableFuncs
, ArraySize(aAnalyzeTableFuncs
));
1633 ** Attempt to extract a value from pExpr and use it to construct *ppVal.
1635 ** If pAlloc is not NULL, then an UnpackedRecord object is created for
1636 ** pAlloc if one does not exist and the new value is added to the
1637 ** UnpackedRecord object.
1639 ** A value is extracted in the following cases:
1641 ** * (pExpr==0). In this case the value is assumed to be an SQL NULL,
1643 ** * The expression is a bound variable, and this is a reprepare, or
1645 ** * The expression is a literal value.
1647 ** On success, *ppVal is made to point to the extracted value. The caller
1648 ** is responsible for ensuring that the value is eventually freed.
1650 static int stat4ValueFromExpr(
1651 Parse
*pParse
, /* Parse context */
1652 Expr
*pExpr
, /* The expression to extract a value from */
1653 u8 affinity
, /* Affinity to use */
1654 struct ValueNewStat4Ctx
*pAlloc
,/* How to allocate space. Or NULL */
1655 sqlite3_value
**ppVal
/* OUT: New value object (or NULL) */
1658 sqlite3_value
*pVal
= 0;
1659 sqlite3
*db
= pParse
->db
;
1661 /* Skip over any TK_COLLATE nodes */
1662 pExpr
= sqlite3ExprSkipCollate(pExpr
);
1664 assert( pExpr
==0 || pExpr
->op
!=TK_REGISTER
|| pExpr
->op2
!=TK_VARIABLE
);
1666 pVal
= valueNew(db
, pAlloc
);
1668 sqlite3VdbeMemSetNull((Mem
*)pVal
);
1670 }else if( pExpr
->op
==TK_VARIABLE
&& (db
->flags
& SQLITE_EnableQPSG
)==0 ){
1672 int iBindVar
= pExpr
->iColumn
;
1673 sqlite3VdbeSetVarmask(pParse
->pVdbe
, iBindVar
);
1674 if( (v
= pParse
->pReprepare
)!=0 ){
1675 pVal
= valueNew(db
, pAlloc
);
1677 rc
= sqlite3VdbeMemCopy((Mem
*)pVal
, &v
->aVar
[iBindVar
-1]);
1678 sqlite3ValueApplyAffinity(pVal
, affinity
, ENC(db
));
1679 pVal
->db
= pParse
->db
;
1683 rc
= valueFromExpr(db
, pExpr
, ENC(db
), affinity
, &pVal
, pAlloc
);
1686 assert( pVal
==0 || pVal
->db
==db
);
1692 ** This function is used to allocate and populate UnpackedRecord
1693 ** structures intended to be compared against sample index keys stored
1694 ** in the sqlite_stat4 table.
1696 ** A single call to this function populates zero or more fields of the
1697 ** record starting with field iVal (fields are numbered from left to
1698 ** right starting with 0). A single field is populated if:
1700 ** * (pExpr==0). In this case the value is assumed to be an SQL NULL,
1702 ** * The expression is a bound variable, and this is a reprepare, or
1704 ** * The sqlite3ValueFromExpr() function is able to extract a value
1705 ** from the expression (i.e. the expression is a literal value).
1707 ** Or, if pExpr is a TK_VECTOR, one field is populated for each of the
1708 ** vector components that match either of the two latter criteria listed
1711 ** Before any value is appended to the record, the affinity of the
1712 ** corresponding column within index pIdx is applied to it. Before
1713 ** this function returns, output parameter *pnExtract is set to the
1714 ** number of values appended to the record.
1716 ** When this function is called, *ppRec must either point to an object
1717 ** allocated by an earlier call to this function, or must be NULL. If it
1718 ** is NULL and a value can be successfully extracted, a new UnpackedRecord
1719 ** is allocated (and *ppRec set to point to it) before returning.
1721 ** Unless an error is encountered, SQLITE_OK is returned. It is not an
1722 ** error if a value cannot be extracted from pExpr. If an error does
1723 ** occur, an SQLite error code is returned.
1725 int sqlite3Stat4ProbeSetValue(
1726 Parse
*pParse
, /* Parse context */
1727 Index
*pIdx
, /* Index being probed */
1728 UnpackedRecord
**ppRec
, /* IN/OUT: Probe record */
1729 Expr
*pExpr
, /* The expression to extract a value from */
1730 int nElem
, /* Maximum number of values to append */
1731 int iVal
, /* Array element to populate */
1732 int *pnExtract
/* OUT: Values appended to the record */
1737 if( pExpr
==0 || pExpr
->op
!=TK_SELECT
){
1739 struct ValueNewStat4Ctx alloc
;
1741 alloc
.pParse
= pParse
;
1743 alloc
.ppRec
= ppRec
;
1745 for(i
=0; i
<nElem
; i
++){
1746 sqlite3_value
*pVal
= 0;
1747 Expr
*pElem
= (pExpr
? sqlite3VectorFieldSubexpr(pExpr
, i
) : 0);
1748 u8 aff
= sqlite3IndexColumnAffinity(pParse
->db
, pIdx
, iVal
+i
);
1749 alloc
.iVal
= iVal
+i
;
1750 rc
= stat4ValueFromExpr(pParse
, pElem
, aff
, &alloc
, &pVal
);
1756 *pnExtract
= nExtract
;
1761 ** Attempt to extract a value from expression pExpr using the methods
1762 ** as described for sqlite3Stat4ProbeSetValue() above.
1764 ** If successful, set *ppVal to point to a new value object and return
1765 ** SQLITE_OK. If no value can be extracted, but no other error occurs
1766 ** (e.g. OOM), return SQLITE_OK and set *ppVal to NULL. Or, if an error
1767 ** does occur, return an SQLite error code. The final value of *ppVal
1768 ** is undefined in this case.
1770 int sqlite3Stat4ValueFromExpr(
1771 Parse
*pParse
, /* Parse context */
1772 Expr
*pExpr
, /* The expression to extract a value from */
1773 u8 affinity
, /* Affinity to use */
1774 sqlite3_value
**ppVal
/* OUT: New value object (or NULL) */
1776 return stat4ValueFromExpr(pParse
, pExpr
, affinity
, 0, ppVal
);
1780 ** Extract the iCol-th column from the nRec-byte record in pRec. Write
1781 ** the column value into *ppVal. If *ppVal is initially NULL then a new
1782 ** sqlite3_value object is allocated.
1784 ** If *ppVal is initially NULL then the caller is responsible for
1785 ** ensuring that the value written into *ppVal is eventually freed.
1787 int sqlite3Stat4Column(
1788 sqlite3
*db
, /* Database handle */
1789 const void *pRec
, /* Pointer to buffer containing record */
1790 int nRec
, /* Size of buffer pRec in bytes */
1791 int iCol
, /* Column to extract */
1792 sqlite3_value
**ppVal
/* OUT: Extracted value */
1794 u32 t
; /* a column type code */
1795 int nHdr
; /* Size of the header in the record */
1796 int iHdr
; /* Next unread header byte */
1797 int iField
; /* Next unread data byte */
1798 int szField
; /* Size of the current data field */
1799 int i
; /* Column index */
1800 u8
*a
= (u8
*)pRec
; /* Typecast byte array */
1801 Mem
*pMem
= *ppVal
; /* Write result into this Mem object */
1804 iHdr
= getVarint32(a
, nHdr
);
1805 if( nHdr
>nRec
|| iHdr
>=nHdr
) return SQLITE_CORRUPT_BKPT
;
1807 for(i
=0; i
<=iCol
; i
++){
1808 iHdr
+= getVarint32(&a
[iHdr
], t
);
1809 testcase( iHdr
==nHdr
);
1810 testcase( iHdr
==nHdr
+1 );
1811 if( iHdr
>nHdr
) return SQLITE_CORRUPT_BKPT
;
1812 szField
= sqlite3VdbeSerialTypeLen(t
);
1815 testcase( iField
==nRec
);
1816 testcase( iField
==nRec
+1 );
1817 if( iField
>nRec
) return SQLITE_CORRUPT_BKPT
;
1819 pMem
= *ppVal
= sqlite3ValueNew(db
);
1820 if( pMem
==0 ) return SQLITE_NOMEM_BKPT
;
1822 sqlite3VdbeSerialGet(&a
[iField
-szField
], t
, pMem
);
1823 pMem
->enc
= ENC(db
);
1828 ** Unless it is NULL, the argument must be an UnpackedRecord object returned
1829 ** by an earlier call to sqlite3Stat4ProbeSetValue(). This call deletes
1832 void sqlite3Stat4ProbeFree(UnpackedRecord
*pRec
){
1835 int nCol
= pRec
->pKeyInfo
->nAllField
;
1836 Mem
*aMem
= pRec
->aMem
;
1837 sqlite3
*db
= aMem
[0].db
;
1838 for(i
=0; i
<nCol
; i
++){
1839 sqlite3VdbeMemRelease(&aMem
[i
]);
1841 sqlite3KeyInfoUnref(pRec
->pKeyInfo
);
1842 sqlite3DbFreeNN(db
, pRec
);
1845 #endif /* ifdef SQLITE_ENABLE_STAT4 */
1848 ** Change the string value of an sqlite3_value object
1850 void sqlite3ValueSetStr(
1851 sqlite3_value
*v
, /* Value to be set */
1852 int n
, /* Length of string z */
1853 const void *z
, /* Text of the new string */
1854 u8 enc
, /* Encoding to use */
1855 void (*xDel
)(void*) /* Destructor for the string */
1857 if( v
) sqlite3VdbeMemSetStr((Mem
*)v
, z
, n
, enc
, xDel
);
1861 ** Free an sqlite3_value object
1863 void sqlite3ValueFree(sqlite3_value
*v
){
1865 sqlite3VdbeMemRelease((Mem
*)v
);
1866 sqlite3DbFreeNN(((Mem
*)v
)->db
, v
);
1870 ** The sqlite3ValueBytes() routine returns the number of bytes in the
1871 ** sqlite3_value object assuming that it uses the encoding "enc".
1872 ** The valueBytes() routine is a helper function.
1874 static SQLITE_NOINLINE
int valueBytes(sqlite3_value
*pVal
, u8 enc
){
1875 return valueToText(pVal
, enc
)!=0 ? pVal
->n
: 0;
1877 int sqlite3ValueBytes(sqlite3_value
*pVal
, u8 enc
){
1878 Mem
*p
= (Mem
*)pVal
;
1879 assert( (p
->flags
& MEM_Null
)==0 || (p
->flags
& (MEM_Str
|MEM_Blob
))==0 );
1880 if( (p
->flags
& MEM_Str
)!=0 && pVal
->enc
==enc
){
1883 if( (p
->flags
& MEM_Blob
)!=0 ){
1884 if( p
->flags
& MEM_Zero
){
1885 return p
->n
+ p
->u
.nZero
;
1890 if( p
->flags
& MEM_Null
) return 0;
1891 return valueBytes(pVal
, enc
);