1 /*
2 ** 2004 May 26
3 **
4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
6 **
7 ** May you do good and not evil.
8 ** May you find forgiveness for yourself and forgive others.
9 ** May you share freely, never taking more than you give.
10 **
11 *************************************************************************
12 **
13 ** This file contains code use to manipulate "Mem" structure. A "Mem"
14 ** stores a single value in the VDBE. Mem is an opaque structure visible
15 ** only within the VDBE. Interface routines refer to a Mem using the
16 ** name sqlite_value
17 */
18 #include "sqliteInt.h"
19 #include "vdbeInt.h"
20
21 #ifdef SQLITE_DEBUG
22 /*
23 ** Check invariants on a Mem object.
24 **
25 ** This routine is intended for use inside of assert() statements, like
26 ** this: assert( sqlite3VdbeCheckMemInvariants(pMem) );
27 */
sqlite3VdbeCheckMemInvariants(Mem * p)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.
31 */
32 assert( (p->flags & MEM_Dyn)==0 || p->xDel!=0 );
33
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 );
39
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) );
42
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|MEM_Zero))==0 );
47
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
51 ** set.
52 */
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 );
59
60 /* No other bits set */
61 assert( (p->flags & ~(MEM_Null|MEM_Term|MEM_Subtype
62 |MEM_Dyn|MEM_Ephem|MEM_Static))==0 );
63 }else{
64 /* A pure NULL might have other flags, such as MEM_Static, MEM_Dyn,
65 ** MEM_Ephem, MEM_Cleared, or MEM_Subtype */
66 }
67 }else{
68 /* The MEM_Cleared bit is only allowed on NULLs */
69 assert( (p->flags & MEM_Cleared)==0 );
70 }
71
72 /* The szMalloc field holds the correct memory allocation size */
73 assert( p->szMalloc==0
74 || p->szMalloc==sqlite3DbMallocSize(p->db,p->zMalloc) );
75
76 /* If p holds a string or blob, the Mem.z must point to exactly
77 ** one of the following:
78 **
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
83 */
84 if( (p->flags & (MEM_Str|MEM_Blob)) && p->n>0 ){
85 assert(
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
90 );
91 }
92 return 1;
93 }
94 #endif
95
96
97 /*
98 ** If pMem is an object with a valid string representation, this routine
99 ** ensures the internal encoding for the string representation is
100 ** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE.
101 **
102 ** If pMem is not a string object, or the encoding of the string
103 ** representation is already stored using the requested encoding, then this
104 ** routine is a no-op.
105 **
106 ** SQLITE_OK is returned if the conversion is successful (or not required).
107 ** SQLITE_NOMEM may be returned if a malloc() fails during conversion
108 ** between formats.
109 */
sqlite3VdbeChangeEncoding(Mem * pMem,int desiredEnc)110 int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
111 #ifndef SQLITE_OMIT_UTF16
112 int rc;
113 #endif
114 assert( (pMem->flags&MEM_RowSet)==0 );
115 assert( desiredEnc==SQLITE_UTF8 || desiredEnc==SQLITE_UTF16LE
116 || desiredEnc==SQLITE_UTF16BE );
117 if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
118 return SQLITE_OK;
119 }
120 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
121 #ifdef SQLITE_OMIT_UTF16
122 return SQLITE_ERROR;
123 #else
124
125 /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
126 ** then the encoding of the value may not have changed.
127 */
128 rc = sqlite3VdbeMemTranslate(pMem, (u8)desiredEnc);
129 assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
130 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
131 assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
132 return rc;
133 #endif
134 }
135
136 /*
137 ** Make sure pMem->z points to a writable allocation of at least
138 ** min(n,32) bytes.
139 **
140 ** If the bPreserve argument is true, then copy of the content of
141 ** pMem->z into the new allocation. pMem must be either a string or
142 ** blob if bPreserve is true. If bPreserve is false, any prior content
143 ** in pMem->z is discarded.
144 */
sqlite3VdbeMemGrow(Mem * pMem,int n,int bPreserve)145 SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){
146 assert( sqlite3VdbeCheckMemInvariants(pMem) );
147 assert( (pMem->flags&MEM_RowSet)==0 );
148 testcase( pMem->db==0 );
149
150 /* If the bPreserve flag is set to true, then the memory cell must already
151 ** contain a valid string or blob value. */
152 assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
153 testcase( bPreserve && pMem->z==0 );
154
155 assert( pMem->szMalloc==0
156 || pMem->szMalloc==sqlite3DbMallocSize(pMem->db, pMem->zMalloc) );
157 if( n<32 ) n = 32;
158 if( bPreserve && pMem->szMalloc>0 && pMem->z==pMem->zMalloc ){
159 pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
160 bPreserve = 0;
161 }else{
162 if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
163 pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
164 }
165 if( pMem->zMalloc==0 ){
166 sqlite3VdbeMemSetNull(pMem);
167 pMem->z = 0;
168 pMem->szMalloc = 0;
169 return SQLITE_NOMEM_BKPT;
170 }else{
171 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
172 }
173
174 if( bPreserve && pMem->z && ALWAYS(pMem->z!=pMem->zMalloc) ){
175 memcpy(pMem->zMalloc, pMem->z, pMem->n);
176 }
177 if( (pMem->flags&MEM_Dyn)!=0 ){
178 assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC );
179 pMem->xDel((void *)(pMem->z));
180 }
181
182 pMem->z = pMem->zMalloc;
183 pMem->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Static);
184 return SQLITE_OK;
185 }
186
187 /*
188 ** Change the pMem->zMalloc allocation to be at least szNew bytes.
189 ** If pMem->zMalloc already meets or exceeds the requested size, this
190 ** routine is a no-op.
191 **
192 ** Any prior string or blob content in the pMem object may be discarded.
193 ** The pMem->xDel destructor is called, if it exists. Though MEM_Str
194 ** and MEM_Blob values may be discarded, MEM_Int, MEM_Real, and MEM_Null
195 ** values are preserved.
196 **
197 ** Return SQLITE_OK on success or an error code (probably SQLITE_NOMEM)
198 ** if unable to complete the resizing.
199 */
sqlite3VdbeMemClearAndResize(Mem * pMem,int szNew)200 int sqlite3VdbeMemClearAndResize(Mem *pMem, int szNew){
201 assert( szNew>0 );
202 assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 );
203 if( pMem->szMalloc<szNew ){
204 return sqlite3VdbeMemGrow(pMem, szNew, 0);
205 }
206 assert( (pMem->flags & MEM_Dyn)==0 );
207 pMem->z = pMem->zMalloc;
208 pMem->flags &= (MEM_Null|MEM_Int|MEM_Real);
209 return SQLITE_OK;
210 }
211
212 /*
213 ** Change pMem so that its MEM_Str or MEM_Blob value is stored in
214 ** MEM.zMalloc, where it can be safely written.
215 **
216 ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
217 */
sqlite3VdbeMemMakeWriteable(Mem * pMem)218 int sqlite3VdbeMemMakeWriteable(Mem *pMem){
219 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
220 assert( (pMem->flags&MEM_RowSet)==0 );
221 if( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ){
222 if( ExpandBlob(pMem) ) return SQLITE_NOMEM;
223 if( pMem->szMalloc==0 || pMem->z!=pMem->zMalloc ){
224 if( sqlite3VdbeMemGrow(pMem, pMem->n + 2, 1) ){
225 return SQLITE_NOMEM_BKPT;
226 }
227 pMem->z[pMem->n] = 0;
228 pMem->z[pMem->n+1] = 0;
229 pMem->flags |= MEM_Term;
230 }
231 }
232 pMem->flags &= ~MEM_Ephem;
233 #ifdef SQLITE_DEBUG
234 pMem->pScopyFrom = 0;
235 #endif
236
237 return SQLITE_OK;
238 }
239
240 /*
241 ** If the given Mem* has a zero-filled tail, turn it into an ordinary
242 ** blob stored in dynamically allocated space.
243 */
244 #ifndef SQLITE_OMIT_INCRBLOB
sqlite3VdbeMemExpandBlob(Mem * pMem)245 int sqlite3VdbeMemExpandBlob(Mem *pMem){
246 int nByte;
247 assert( pMem->flags & MEM_Zero );
248 assert( pMem->flags&MEM_Blob );
249 assert( (pMem->flags&MEM_RowSet)==0 );
250 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
251
252 /* Set nByte to the number of bytes required to store the expanded blob. */
253 nByte = pMem->n + pMem->u.nZero;
254 if( nByte<=0 ){
255 nByte = 1;
256 }
257 if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
258 return SQLITE_NOMEM_BKPT;
259 }
260
261 memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
262 pMem->n += pMem->u.nZero;
263 pMem->flags &= ~(MEM_Zero|MEM_Term);
264 return SQLITE_OK;
265 }
266 #endif
267
268 /*
269 ** It is already known that pMem contains an unterminated string.
270 ** Add the zero terminator.
271 */
vdbeMemAddTerminator(Mem * pMem)272 static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){
273 if( sqlite3VdbeMemGrow(pMem, pMem->n+2, 1) ){
274 return SQLITE_NOMEM_BKPT;
275 }
276 pMem->z[pMem->n] = 0;
277 pMem->z[pMem->n+1] = 0;
278 pMem->flags |= MEM_Term;
279 return SQLITE_OK;
280 }
281
282 /*
283 ** Make sure the given Mem is \u0000 terminated.
284 */
sqlite3VdbeMemNulTerminate(Mem * pMem)285 int sqlite3VdbeMemNulTerminate(Mem *pMem){
286 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
287 testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) );
288 testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 );
289 if( (pMem->flags & (MEM_Term|MEM_Str))!=MEM_Str ){
290 return SQLITE_OK; /* Nothing to do */
291 }else{
292 return vdbeMemAddTerminator(pMem);
293 }
294 }
295
296 /*
297 ** Add MEM_Str to the set of representations for the given Mem. Numbers
298 ** are converted using sqlite3_snprintf(). Converting a BLOB to a string
299 ** is a no-op.
300 **
301 ** Existing representations MEM_Int and MEM_Real are invalidated if
302 ** bForce is true but are retained if bForce is false.
303 **
304 ** A MEM_Null value will never be passed to this function. This function is
305 ** used for converting values to text for returning to the user (i.e. via
306 ** sqlite3_value_text()), or for ensuring that values to be used as btree
307 ** keys are strings. In the former case a NULL pointer is returned the
308 ** user and the latter is an internal programming error.
309 */
sqlite3VdbeMemStringify(Mem * pMem,u8 enc,u8 bForce)310 int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){
311 int fg = pMem->flags;
312 const int nByte = 32;
313
314 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
315 assert( !(fg&MEM_Zero) );
316 assert( !(fg&(MEM_Str|MEM_Blob)) );
317 assert( fg&(MEM_Int|MEM_Real) );
318 assert( (pMem->flags&MEM_RowSet)==0 );
319 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
320
321
322 if( sqlite3VdbeMemClearAndResize(pMem, nByte) ){
323 pMem->enc = 0;
324 return SQLITE_NOMEM_BKPT;
325 }
326
327 /* For a Real or Integer, use sqlite3_snprintf() to produce the UTF-8
328 ** string representation of the value. Then, if the required encoding
329 ** is UTF-16le or UTF-16be do a translation.
330 **
331 ** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16.
332 */
333 if( fg & MEM_Int ){
334 sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
335 }else{
336 assert( fg & MEM_Real );
337 sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->u.r);
338 }
339 pMem->n = sqlite3Strlen30(pMem->z);
340 pMem->enc = SQLITE_UTF8;
341 pMem->flags |= MEM_Str|MEM_Term;
342 if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real);
343 sqlite3VdbeChangeEncoding(pMem, enc);
344 return SQLITE_OK;
345 }
346
347 /*
348 ** Memory cell pMem contains the context of an aggregate function.
349 ** This routine calls the finalize method for that function. The
350 ** result of the aggregate is stored back into pMem.
351 **
352 ** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK
353 ** otherwise.
354 */
sqlite3VdbeMemFinalize(Mem * pMem,FuncDef * pFunc)355 int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
356 int rc = SQLITE_OK;
357 if( ALWAYS(pFunc && pFunc->xFinalize) ){
358 sqlite3_context ctx;
359 Mem t;
360 assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
361 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
362 memset(&ctx, 0, sizeof(ctx));
363 memset(&t, 0, sizeof(t));
364 t.flags = MEM_Null;
365 t.db = pMem->db;
366 ctx.pOut = &t;
367 ctx.pMem = pMem;
368 ctx.pFunc = pFunc;
369 pFunc->xFinalize(&ctx); /* IMP: R-24505-23230 */
370 assert( (pMem->flags & MEM_Dyn)==0 );
371 if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
372 memcpy(pMem, &t, sizeof(t));
373 rc = ctx.isError;
374 }
375 return rc;
376 }
377
378 /*
379 ** If the memory cell contains a value that must be freed by
380 ** invoking the external callback in Mem.xDel, then this routine
381 ** will free that value. It also sets Mem.flags to MEM_Null.
382 **
383 ** This is a helper routine for sqlite3VdbeMemSetNull() and
384 ** for sqlite3VdbeMemRelease(). Use those other routines as the
385 ** entry point for releasing Mem resources.
386 */
vdbeMemClearExternAndSetNull(Mem * p)387 static SQLITE_NOINLINE void vdbeMemClearExternAndSetNull(Mem *p){
388 assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
389 assert( VdbeMemDynamic(p) );
390 if( p->flags&MEM_Agg ){
391 sqlite3VdbeMemFinalize(p, p->u.pDef);
392 assert( (p->flags & MEM_Agg)==0 );
393 testcase( p->flags & MEM_Dyn );
394 }
395 if( p->flags&MEM_Dyn ){
396 assert( (p->flags&MEM_RowSet)==0 );
397 assert( p->xDel!=SQLITE_DYNAMIC && p->xDel!=0 );
398 p->xDel((void *)p->z);
399 }else if( p->flags&MEM_RowSet ){
400 sqlite3RowSetClear(p->u.pRowSet);
401 }else if( p->flags&MEM_Frame ){
402 VdbeFrame *pFrame = p->u.pFrame;
403 pFrame->pParent = pFrame->v->pDelFrame;
404 pFrame->v->pDelFrame = pFrame;
405 }
406 p->flags = MEM_Null;
407 }
408
409 /*
410 ** Release memory held by the Mem p, both external memory cleared
411 ** by p->xDel and memory in p->zMalloc.
412 **
413 ** This is a helper routine invoked by sqlite3VdbeMemRelease() in
414 ** the unusual case where there really is memory in p that needs
415 ** to be freed.
416 */
vdbeMemClear(Mem * p)417 static SQLITE_NOINLINE void vdbeMemClear(Mem *p){
418 if( VdbeMemDynamic(p) ){
419 vdbeMemClearExternAndSetNull(p);
420 }
421 if( p->szMalloc ){
422 sqlite3DbFreeNN(p->db, p->zMalloc);
423 p->szMalloc = 0;
424 }
425 p->z = 0;
426 }
427
428 /*
429 ** Release any memory resources held by the Mem. Both the memory that is
430 ** free by Mem.xDel and the Mem.zMalloc allocation are freed.
431 **
432 ** Use this routine prior to clean up prior to abandoning a Mem, or to
433 ** reset a Mem back to its minimum memory utilization.
434 **
435 ** Use sqlite3VdbeMemSetNull() to release just the Mem.xDel space
436 ** prior to inserting new content into the Mem.
437 */
sqlite3VdbeMemRelease(Mem * p)438 void sqlite3VdbeMemRelease(Mem *p){
439 assert( sqlite3VdbeCheckMemInvariants(p) );
440 if( VdbeMemDynamic(p) || p->szMalloc ){
441 vdbeMemClear(p);
442 }
443 }
444
445 /*
446 ** Convert a 64-bit IEEE double into a 64-bit signed integer.
447 ** If the double is out of range of a 64-bit signed integer then
448 ** return the closest available 64-bit signed integer.
449 */
doubleToInt64(double r)450 static SQLITE_NOINLINE i64 doubleToInt64(double r){
451 #ifdef SQLITE_OMIT_FLOATING_POINT
452 /* When floating-point is omitted, double and int64 are the same thing */
453 return r;
454 #else
455 /*
456 ** Many compilers we encounter do not define constants for the
457 ** minimum and maximum 64-bit integers, or they define them
458 ** inconsistently. And many do not understand the "LL" notation.
459 ** So we define our own static constants here using nothing
460 ** larger than a 32-bit integer constant.
461 */
462 static const i64 maxInt = LARGEST_INT64;
463 static const i64 minInt = SMALLEST_INT64;
464
465 if( r<=(double)minInt ){
466 return minInt;
467 }else if( r>=(double)maxInt ){
468 return maxInt;
469 }else{
470 return (i64)r;
471 }
472 #endif
473 }
474
475 /*
476 ** Return some kind of integer value which is the best we can do
477 ** at representing the value that *pMem describes as an integer.
478 ** If pMem is an integer, then the value is exact. If pMem is
479 ** a floating-point then the value returned is the integer part.
480 ** If pMem is a string or blob, then we make an attempt to convert
481 ** it into an integer and return that. If pMem represents an
482 ** an SQL-NULL value, return 0.
483 **
484 ** If pMem represents a string value, its encoding might be changed.
485 */
memIntValue(Mem * pMem)486 static SQLITE_NOINLINE i64 memIntValue(Mem *pMem){
487 i64 value = 0;
488 sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
489 return value;
490 }
sqlite3VdbeIntValue(Mem * pMem)491 i64 sqlite3VdbeIntValue(Mem *pMem){
492 int flags;
493 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
494 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
495 flags = pMem->flags;
496 if( flags & MEM_Int ){
497 return pMem->u.i;
498 }else if( flags & MEM_Real ){
499 return doubleToInt64(pMem->u.r);
500 }else if( flags & (MEM_Str|MEM_Blob) ){
501 assert( pMem->z || pMem->n==0 );
502 return memIntValue(pMem);
503 }else{
504 return 0;
505 }
506 }
507
508 /*
509 ** Return the best representation of pMem that we can get into a
510 ** double. If pMem is already a double or an integer, return its
511 ** value. If it is a string or blob, try to convert it to a double.
512 ** If it is a NULL, return 0.0.
513 */
memRealValue(Mem * pMem)514 static SQLITE_NOINLINE double memRealValue(Mem *pMem){
515 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
516 double val = (double)0;
517 sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc);
518 return val;
519 }
sqlite3VdbeRealValue(Mem * pMem)520 double sqlite3VdbeRealValue(Mem *pMem){
521 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
522 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
523 if( pMem->flags & MEM_Real ){
524 return pMem->u.r;
525 }else if( pMem->flags & MEM_Int ){
526 return (double)pMem->u.i;
527 }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
528 return memRealValue(pMem);
529 }else{
530 /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
531 return (double)0;
532 }
533 }
534
535 /*
536 ** The MEM structure is already a MEM_Real. Try to also make it a
537 ** MEM_Int if we can.
538 */
sqlite3VdbeIntegerAffinity(Mem * pMem)539 void sqlite3VdbeIntegerAffinity(Mem *pMem){
540 i64 ix;
541 assert( pMem->flags & MEM_Real );
542 assert( (pMem->flags & MEM_RowSet)==0 );
543 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
544 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
545
546 ix = doubleToInt64(pMem->u.r);
547
548 /* Only mark the value as an integer if
549 **
550 ** (1) the round-trip conversion real->int->real is a no-op, and
551 ** (2) The integer is neither the largest nor the smallest
552 ** possible integer (ticket #3922)
553 **
554 ** The second and third terms in the following conditional enforces
555 ** the second condition under the assumption that addition overflow causes
556 ** values to wrap around.
557 */
558 if( pMem->u.r==ix && ix>SMALLEST_INT64 && ix<LARGEST_INT64 ){
559 pMem->u.i = ix;
560 MemSetTypeFlag(pMem, MEM_Int);
561 }
562 }
563
564 /*
565 ** Convert pMem to type integer. Invalidate any prior representations.
566 */
sqlite3VdbeMemIntegerify(Mem * pMem)567 int sqlite3VdbeMemIntegerify(Mem *pMem){
568 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
569 assert( (pMem->flags & MEM_RowSet)==0 );
570 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
571
572 pMem->u.i = sqlite3VdbeIntValue(pMem);
573 MemSetTypeFlag(pMem, MEM_Int);
574 return SQLITE_OK;
575 }
576
577 /*
578 ** Convert pMem so that it is of type MEM_Real.
579 ** Invalidate any prior representations.
580 */
sqlite3VdbeMemRealify(Mem * pMem)581 int sqlite3VdbeMemRealify(Mem *pMem){
582 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
583 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
584
585 pMem->u.r = sqlite3VdbeRealValue(pMem);
586 MemSetTypeFlag(pMem, MEM_Real);
587 return SQLITE_OK;
588 }
589
590 /*
591 ** Convert pMem so that it has types MEM_Real or MEM_Int or both.
592 ** Invalidate any prior representations.
593 **
594 ** Every effort is made to force the conversion, even if the input
595 ** is a string that does not look completely like a number. Convert
596 ** as much of the string as we can and ignore the rest.
597 */
sqlite3VdbeMemNumerify(Mem * pMem)598 int sqlite3VdbeMemNumerify(Mem *pMem){
599 if( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 ){
600 assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
601 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
602 if( 0==sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc) ){
603 MemSetTypeFlag(pMem, MEM_Int);
604 }else{
605 pMem->u.r = sqlite3VdbeRealValue(pMem);
606 MemSetTypeFlag(pMem, MEM_Real);
607 sqlite3VdbeIntegerAffinity(pMem);
608 }
609 }
610 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))!=0 );
611 pMem->flags &= ~(MEM_Str|MEM_Blob|MEM_Zero);
612 return SQLITE_OK;
613 }
614
615 /*
616 ** Cast the datatype of the value in pMem according to the affinity
617 ** "aff". Casting is different from applying affinity in that a cast
618 ** is forced. In other words, the value is converted into the desired
619 ** affinity even if that results in loss of data. This routine is
620 ** used (for example) to implement the SQL "cast()" operator.
621 */
sqlite3VdbeMemCast(Mem * pMem,u8 aff,u8 encoding)622 void sqlite3VdbeMemCast(Mem *pMem, u8 aff, u8 encoding){
623 if( pMem->flags & MEM_Null ) return;
624 switch( aff ){
625 case SQLITE_AFF_BLOB: { /* Really a cast to BLOB */
626 if( (pMem->flags & MEM_Blob)==0 ){
627 sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding);
628 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
629 if( pMem->flags & MEM_Str ) MemSetTypeFlag(pMem, MEM_Blob);
630 }else{
631 pMem->flags &= ~(MEM_TypeMask&~MEM_Blob);
632 }
633 break;
634 }
635 case SQLITE_AFF_NUMERIC: {
636 sqlite3VdbeMemNumerify(pMem);
637 break;
638 }
639 case SQLITE_AFF_INTEGER: {
640 sqlite3VdbeMemIntegerify(pMem);
641 break;
642 }
643 case SQLITE_AFF_REAL: {
644 sqlite3VdbeMemRealify(pMem);
645 break;
646 }
647 default: {
648 assert( aff==SQLITE_AFF_TEXT );
649 assert( MEM_Str==(MEM_Blob>>3) );
650 pMem->flags |= (pMem->flags&MEM_Blob)>>3;
651 sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding);
652 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
653 pMem->flags &= ~(MEM_Int|MEM_Real|MEM_Blob|MEM_Zero);
654 break;
655 }
656 }
657 }
658
659 /*
660 ** Initialize bulk memory to be a consistent Mem object.
661 **
662 ** The minimum amount of initialization feasible is performed.
663 */
sqlite3VdbeMemInit(Mem * pMem,sqlite3 * db,u16 flags)664 void sqlite3VdbeMemInit(Mem *pMem, sqlite3 *db, u16 flags){
665 assert( (flags & ~MEM_TypeMask)==0 );
666 pMem->flags = flags;
667 pMem->db = db;
668 pMem->szMalloc = 0;
669 }
670
671
672 /*
673 ** Delete any previous value and set the value stored in *pMem to NULL.
674 **
675 ** This routine calls the Mem.xDel destructor to dispose of values that
676 ** require the destructor. But it preserves the Mem.zMalloc memory allocation.
677 ** To free all resources, use sqlite3VdbeMemRelease(), which both calls this
678 ** routine to invoke the destructor and deallocates Mem.zMalloc.
679 **
680 ** Use this routine to reset the Mem prior to insert a new value.
681 **
682 ** Use sqlite3VdbeMemRelease() to complete erase the Mem prior to abandoning it.
683 */
sqlite3VdbeMemSetNull(Mem * pMem)684 void sqlite3VdbeMemSetNull(Mem *pMem){
685 if( VdbeMemDynamic(pMem) ){
686 vdbeMemClearExternAndSetNull(pMem);
687 }else{
688 pMem->flags = MEM_Null;
689 }
690 }
sqlite3ValueSetNull(sqlite3_value * p)691 void sqlite3ValueSetNull(sqlite3_value *p){
692 sqlite3VdbeMemSetNull((Mem*)p);
693 }
694
695 /*
696 ** Delete any previous value and set the value to be a BLOB of length
697 ** n containing all zeros.
698 */
sqlite3VdbeMemSetZeroBlob(Mem * pMem,int n)699 void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
700 sqlite3VdbeMemRelease(pMem);
701 pMem->flags = MEM_Blob|MEM_Zero;
702 pMem->n = 0;
703 if( n<0 ) n = 0;
704 pMem->u.nZero = n;
705 pMem->enc = SQLITE_UTF8;
706 pMem->z = 0;
707 }
708
709 /*
710 ** The pMem is known to contain content that needs to be destroyed prior
711 ** to a value change. So invoke the destructor, then set the value to
712 ** a 64-bit integer.
713 */
vdbeReleaseAndSetInt64(Mem * pMem,i64 val)714 static SQLITE_NOINLINE void vdbeReleaseAndSetInt64(Mem *pMem, i64 val){
715 sqlite3VdbeMemSetNull(pMem);
716 pMem->u.i = val;
717 pMem->flags = MEM_Int;
718 }
719
720 /*
721 ** Delete any previous value and set the value stored in *pMem to val,
722 ** manifest type INTEGER.
723 */
sqlite3VdbeMemSetInt64(Mem * pMem,i64 val)724 void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
725 if( VdbeMemDynamic(pMem) ){
726 vdbeReleaseAndSetInt64(pMem, val);
727 }else{
728 pMem->u.i = val;
729 pMem->flags = MEM_Int;
730 }
731 }
732
733 /* A no-op destructor */
sqlite3NoopDestructor(void * p)734 static void sqlite3NoopDestructor(void *p){ UNUSED_PARAMETER(p); }
735
736 /*
737 ** Set the value stored in *pMem should already be a NULL.
738 ** Also store a pointer to go with it.
739 */
sqlite3VdbeMemSetPointer(Mem * pMem,void * pPtr,const char * zPType,void (* xDestructor)(void *))740 void sqlite3VdbeMemSetPointer(
741 Mem *pMem,
742 void *pPtr,
743 const char *zPType,
744 void (*xDestructor)(void*)
745 ){
746 assert( pMem->flags==MEM_Null );
747 pMem->u.zPType = zPType ? zPType : "";
748 pMem->z = pPtr;
749 pMem->flags = MEM_Null|MEM_Dyn|MEM_Subtype|MEM_Term;
750 pMem->eSubtype = 'p';
751 pMem->xDel = xDestructor ? xDestructor : sqlite3NoopDestructor;
752 }
753
754 #ifndef SQLITE_OMIT_FLOATING_POINT
755 /*
756 ** Delete any previous value and set the value stored in *pMem to val,
757 ** manifest type REAL.
758 */
sqlite3VdbeMemSetDouble(Mem * pMem,double val)759 void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
760 sqlite3VdbeMemSetNull(pMem);
761 if( !sqlite3IsNaN(val) ){
762 pMem->u.r = val;
763 pMem->flags = MEM_Real;
764 }
765 }
766 #endif
767
768 /*
769 ** Delete any previous value and set the value of pMem to be an
770 ** empty boolean index.
771 */
sqlite3VdbeMemSetRowSet(Mem * pMem)772 void sqlite3VdbeMemSetRowSet(Mem *pMem){
773 sqlite3 *db = pMem->db;
774 assert( db!=0 );
775 assert( (pMem->flags & MEM_RowSet)==0 );
776 sqlite3VdbeMemRelease(pMem);
777 pMem->zMalloc = sqlite3DbMallocRawNN(db, 64);
778 if( db->mallocFailed ){
779 pMem->flags = MEM_Null;
780 pMem->szMalloc = 0;
781 }else{
782 assert( pMem->zMalloc );
783 pMem->szMalloc = sqlite3DbMallocSize(db, pMem->zMalloc);
784 pMem->u.pRowSet = sqlite3RowSetInit(db, pMem->zMalloc, pMem->szMalloc);
785 assert( pMem->u.pRowSet!=0 );
786 pMem->flags = MEM_RowSet;
787 }
788 }
789
790 /*
791 ** Return true if the Mem object contains a TEXT or BLOB that is
792 ** too large - whose size exceeds SQLITE_MAX_LENGTH.
793 */
sqlite3VdbeMemTooBig(Mem * p)794 int sqlite3VdbeMemTooBig(Mem *p){
795 assert( p->db!=0 );
796 if( p->flags & (MEM_Str|MEM_Blob) ){
797 int n = p->n;
798 if( p->flags & MEM_Zero ){
799 n += p->u.nZero;
800 }
801 return n>p->db->aLimit[SQLITE_LIMIT_LENGTH];
802 }
803 return 0;
804 }
805
806 #ifdef SQLITE_DEBUG
807 /*
808 ** This routine prepares a memory cell for modification by breaking
809 ** its link to a shallow copy and by marking any current shallow
810 ** copies of this cell as invalid.
811 **
812 ** This is used for testing and debugging only - to make sure shallow
813 ** copies are not misused.
814 */
sqlite3VdbeMemAboutToChange(Vdbe * pVdbe,Mem * pMem)815 void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
816 int i;
817 Mem *pX;
818 for(i=0, pX=pVdbe->aMem; i<pVdbe->nMem; i++, pX++){
819 if( pX->pScopyFrom==pMem ){
820 pX->flags |= MEM_Undefined;
821 pX->pScopyFrom = 0;
822 }
823 }
824 pMem->pScopyFrom = 0;
825 }
826 #endif /* SQLITE_DEBUG */
827
828
829 /*
830 ** Make an shallow copy of pFrom into pTo. Prior contents of
831 ** pTo are freed. The pFrom->z field is not duplicated. If
832 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
833 ** and flags gets srcType (either MEM_Ephem or MEM_Static).
834 */
vdbeClrCopy(Mem * pTo,const Mem * pFrom,int eType)835 static SQLITE_NOINLINE void vdbeClrCopy(Mem *pTo, const Mem *pFrom, int eType){
836 vdbeMemClearExternAndSetNull(pTo);
837 assert( !VdbeMemDynamic(pTo) );
838 sqlite3VdbeMemShallowCopy(pTo, pFrom, eType);
839 }
sqlite3VdbeMemShallowCopy(Mem * pTo,const Mem * pFrom,int srcType)840 void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
841 assert( (pFrom->flags & MEM_RowSet)==0 );
842 assert( pTo->db==pFrom->db );
843 if( VdbeMemDynamic(pTo) ){ vdbeClrCopy(pTo,pFrom,srcType); return; }
844 memcpy(pTo, pFrom, MEMCELLSIZE);
845 if( (pFrom->flags&MEM_Static)==0 ){
846 pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
847 assert( srcType==MEM_Ephem || srcType==MEM_Static );
848 pTo->flags |= srcType;
849 }
850 }
851
852 /*
853 ** Make a full copy of pFrom into pTo. Prior contents of pTo are
854 ** freed before the copy is made.
855 */
sqlite3VdbeMemCopy(Mem * pTo,const Mem * pFrom)856 int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
857 int rc = SQLITE_OK;
858
859 assert( (pFrom->flags & MEM_RowSet)==0 );
860 if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(pTo);
861 memcpy(pTo, pFrom, MEMCELLSIZE);
862 pTo->flags &= ~MEM_Dyn;
863 if( pTo->flags&(MEM_Str|MEM_Blob) ){
864 if( 0==(pFrom->flags&MEM_Static) ){
865 pTo->flags |= MEM_Ephem;
866 rc = sqlite3VdbeMemMakeWriteable(pTo);
867 }
868 }
869
870 return rc;
871 }
872
873 /*
874 ** Transfer the contents of pFrom to pTo. Any existing value in pTo is
875 ** freed. If pFrom contains ephemeral data, a copy is made.
876 **
877 ** pFrom contains an SQL NULL when this routine returns.
878 */
sqlite3VdbeMemMove(Mem * pTo,Mem * pFrom)879 void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
880 assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
881 assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
882 assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
883
884 sqlite3VdbeMemRelease(pTo);
885 memcpy(pTo, pFrom, sizeof(Mem));
886 pFrom->flags = MEM_Null;
887 pFrom->szMalloc = 0;
888 }
889
890 /*
891 ** Change the value of a Mem to be a string or a BLOB.
892 **
893 ** The memory management strategy depends on the value of the xDel
894 ** parameter. If the value passed is SQLITE_TRANSIENT, then the
895 ** string is copied into a (possibly existing) buffer managed by the
896 ** Mem structure. Otherwise, any existing buffer is freed and the
897 ** pointer copied.
898 **
899 ** If the string is too large (if it exceeds the SQLITE_LIMIT_LENGTH
900 ** size limit) then no memory allocation occurs. If the string can be
901 ** stored without allocating memory, then it is. If a memory allocation
902 ** is required to store the string, then value of pMem is unchanged. In
903 ** either case, SQLITE_TOOBIG is returned.
904 */
sqlite3VdbeMemSetStr(Mem * pMem,const char * z,int n,u8 enc,void (* xDel)(void *))905 int sqlite3VdbeMemSetStr(
906 Mem *pMem, /* Memory cell to set to string value */
907 const char *z, /* String pointer */
908 int n, /* Bytes in string, or negative */
909 u8 enc, /* Encoding of z. 0 for BLOBs */
910 void (*xDel)(void*) /* Destructor function */
911 ){
912 int nByte = n; /* New value for pMem->n */
913 int iLimit; /* Maximum allowed string or blob size */
914 u16 flags = 0; /* New value for pMem->flags */
915
916 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
917 assert( (pMem->flags & MEM_RowSet)==0 );
918
919 /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
920 if( !z ){
921 sqlite3VdbeMemSetNull(pMem);
922 return SQLITE_OK;
923 }
924
925 if( pMem->db ){
926 iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH];
927 }else{
928 iLimit = SQLITE_MAX_LENGTH;
929 }
930 flags = (enc==0?MEM_Blob:MEM_Str);
931 if( nByte<0 ){
932 assert( enc!=0 );
933 if( enc==SQLITE_UTF8 ){
934 nByte = sqlite3Strlen30(z);
935 if( nByte>iLimit ) nByte = iLimit+1;
936 }else{
937 for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
938 }
939 flags |= MEM_Term;
940 }
941
942 /* The following block sets the new values of Mem.z and Mem.xDel. It
943 ** also sets a flag in local variable "flags" to indicate the memory
944 ** management (one of MEM_Dyn or MEM_Static).
945 */
946 if( xDel==SQLITE_TRANSIENT ){
947 int nAlloc = nByte;
948 if( flags&MEM_Term ){
949 nAlloc += (enc==SQLITE_UTF8?1:2);
950 }
951 if( nByte>iLimit ){
952 return SQLITE_TOOBIG;
953 }
954 testcase( nAlloc==0 );
955 testcase( nAlloc==31 );
956 testcase( nAlloc==32 );
957 if( sqlite3VdbeMemClearAndResize(pMem, MAX(nAlloc,32)) ){
958 return SQLITE_NOMEM_BKPT;
959 }
960 memcpy(pMem->z, z, nAlloc);
961 }else if( xDel==SQLITE_DYNAMIC ){
962 sqlite3VdbeMemRelease(pMem);
963 pMem->zMalloc = pMem->z = (char *)z;
964 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
965 }else{
966 sqlite3VdbeMemRelease(pMem);
967 pMem->z = (char *)z;
968 pMem->xDel = xDel;
969 flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn);
970 }
971
972 pMem->n = nByte;
973 pMem->flags = flags;
974 pMem->enc = (enc==0 ? SQLITE_UTF8 : enc);
975
976 #ifndef SQLITE_OMIT_UTF16
977 if( pMem->enc!=SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
978 return SQLITE_NOMEM_BKPT;
979 }
980 #endif
981
982 if( nByte>iLimit ){
983 return SQLITE_TOOBIG;
984 }
985
986 return SQLITE_OK;
987 }
988
989 /*
990 ** Move data out of a btree key or data field and into a Mem structure.
991 ** The data is payload from the entry that pCur is currently pointing
992 ** to. offset and amt determine what portion of the data or key to retrieve.
993 ** The result is written into the pMem element.
994 **
995 ** The pMem object must have been initialized. This routine will use
996 ** pMem->zMalloc to hold the content from the btree, if possible. New
997 ** pMem->zMalloc space will be allocated if necessary. The calling routine
998 ** is responsible for making sure that the pMem object is eventually
999 ** destroyed.
1000 **
1001 ** If this routine fails for any reason (malloc returns NULL or unable
1002 ** to read from the disk) then the pMem is left in an inconsistent state.
1003 */
vdbeMemFromBtreeResize(BtCursor * pCur,u32 offset,u32 amt,Mem * pMem)1004 static SQLITE_NOINLINE int vdbeMemFromBtreeResize(
1005 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
1006 u32 offset, /* Offset from the start of data to return bytes from. */
1007 u32 amt, /* Number of bytes to return. */
1008 Mem *pMem /* OUT: Return data in this Mem structure. */
1009 ){
1010 int rc;
1011 pMem->flags = MEM_Null;
1012 if( SQLITE_OK==(rc = sqlite3VdbeMemClearAndResize(pMem, amt+2)) ){
1013 rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
1014 if( rc==SQLITE_OK ){
1015 pMem->z[amt] = 0;
1016 pMem->z[amt+1] = 0;
1017 pMem->flags = MEM_Blob|MEM_Term;
1018 pMem->n = (int)amt;
1019 }else{
1020 sqlite3VdbeMemRelease(pMem);
1021 }
1022 }
1023 return rc;
1024 }
sqlite3VdbeMemFromBtree(BtCursor * pCur,u32 offset,u32 amt,Mem * pMem)1025 int sqlite3VdbeMemFromBtree(
1026 BtCursor *pCur, /* Cursor pointing at record to retrieve. */
1027 u32 offset, /* Offset from the start of data to return bytes from. */
1028 u32 amt, /* Number of bytes to return. */
1029 Mem *pMem /* OUT: Return data in this Mem structure. */
1030 ){
1031 char *zData; /* Data from the btree layer */
1032 u32 available = 0; /* Number of bytes available on the local btree page */
1033 int rc = SQLITE_OK; /* Return code */
1034
1035 assert( sqlite3BtreeCursorIsValid(pCur) );
1036 assert( !VdbeMemDynamic(pMem) );
1037
1038 /* Note: the calls to BtreeKeyFetch() and DataFetch() below assert()
1039 ** that both the BtShared and database handle mutexes are held. */
1040 assert( (pMem->flags & MEM_RowSet)==0 );
1041 zData = (char *)sqlite3BtreePayloadFetch(pCur, &available);
1042 assert( zData!=0 );
1043
1044 if( offset+amt<=available ){
1045 pMem->z = &zData[offset];
1046 pMem->flags = MEM_Blob|MEM_Ephem;
1047 pMem->n = (int)amt;
1048 }else{
1049 rc = vdbeMemFromBtreeResize(pCur, offset, amt, pMem);
1050 }
1051
1052 return rc;
1053 }
1054
1055 /*
1056 ** The pVal argument is known to be a value other than NULL.
1057 ** Convert it into a string with encoding enc and return a pointer
1058 ** to a zero-terminated version of that string.
1059 */
valueToText(sqlite3_value * pVal,u8 enc)1060 static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){
1061 assert( pVal!=0 );
1062 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
1063 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
1064 assert( (pVal->flags & MEM_RowSet)==0 );
1065 assert( (pVal->flags & (MEM_Null))==0 );
1066 if( pVal->flags & (MEM_Blob|MEM_Str) ){
1067 if( ExpandBlob(pVal) ) return 0;
1068 pVal->flags |= MEM_Str;
1069 if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){
1070 sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
1071 }
1072 if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
1073 assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
1074 if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
1075 return 0;
1076 }
1077 }
1078 sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */
1079 }else{
1080 sqlite3VdbeMemStringify(pVal, enc, 0);
1081 assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
1082 }
1083 assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
1084 || pVal->db->mallocFailed );
1085 if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
1086 return pVal->z;
1087 }else{
1088 return 0;
1089 }
1090 }
1091
1092 /* This function is only available internally, it is not part of the
1093 ** external API. It works in a similar way to sqlite3_value_text(),
1094 ** except the data returned is in the encoding specified by the second
1095 ** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
1096 ** SQLITE_UTF8.
1097 **
1098 ** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
1099 ** If that is the case, then the result must be aligned on an even byte
1100 ** boundary.
1101 */
sqlite3ValueText(sqlite3_value * pVal,u8 enc)1102 const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
1103 if( !pVal ) return 0;
1104 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
1105 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
1106 assert( (pVal->flags & MEM_RowSet)==0 );
1107 if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
1108 return pVal->z;
1109 }
1110 if( pVal->flags&MEM_Null ){
1111 return 0;
1112 }
1113 return valueToText(pVal, enc);
1114 }
1115
1116 /*
1117 ** Create a new sqlite3_value object.
1118 */
sqlite3ValueNew(sqlite3 * db)1119 sqlite3_value *sqlite3ValueNew(sqlite3 *db){
1120 Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
1121 if( p ){
1122 p->flags = MEM_Null;
1123 p->db = db;
1124 }
1125 return p;
1126 }
1127
1128 /*
1129 ** Context object passed by sqlite3Stat4ProbeSetValue() through to
1130 ** valueNew(). See comments above valueNew() for details.
1131 */
1132 struct ValueNewStat4Ctx {
1133 Parse *pParse;
1134 Index *pIdx;
1135 UnpackedRecord **ppRec;
1136 int iVal;
1137 };
1138
1139 /*
1140 ** Allocate and return a pointer to a new sqlite3_value object. If
1141 ** the second argument to this function is NULL, the object is allocated
1142 ** by calling sqlite3ValueNew().
1143 **
1144 ** Otherwise, if the second argument is non-zero, then this function is
1145 ** being called indirectly by sqlite3Stat4ProbeSetValue(). If it has not
1146 ** already been allocated, allocate the UnpackedRecord structure that
1147 ** that function will return to its caller here. Then return a pointer to
1148 ** an sqlite3_value within the UnpackedRecord.a[] array.
1149 */
valueNew(sqlite3 * db,struct ValueNewStat4Ctx * p)1150 static sqlite3_value *valueNew(sqlite3 *db, struct ValueNewStat4Ctx *p){
1151 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
1152 if( p ){
1153 UnpackedRecord *pRec = p->ppRec[0];
1154
1155 if( pRec==0 ){
1156 Index *pIdx = p->pIdx; /* Index being probed */
1157 int nByte; /* Bytes of space to allocate */
1158 int i; /* Counter variable */
1159 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
1160
1161 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
1162 pRec = (UnpackedRecord*)sqlite3DbMallocZero(db, nByte);
1163 if( pRec ){
1164 pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx);
1165 if( pRec->pKeyInfo ){
1166 assert( pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField==nCol );
1167 assert( pRec->pKeyInfo->enc==ENC(db) );
1168 pRec->aMem = (Mem *)((u8*)pRec + ROUND8(sizeof(UnpackedRecord)));
1169 for(i=0; i<nCol; i++){
1170 pRec->aMem[i].flags = MEM_Null;
1171 pRec->aMem[i].db = db;
1172 }
1173 }else{
1174 sqlite3DbFreeNN(db, pRec);
1175 pRec = 0;
1176 }
1177 }
1178 if( pRec==0 ) return 0;
1179 p->ppRec[0] = pRec;
1180 }
1181
1182 pRec->nField = p->iVal+1;
1183 return &pRec->aMem[p->iVal];
1184 }
1185 #else
1186 UNUSED_PARAMETER(p);
1187 #endif /* defined(SQLITE_ENABLE_STAT3_OR_STAT4) */
1188 return sqlite3ValueNew(db);
1189 }
1190
1191 /*
1192 ** The expression object indicated by the second argument is guaranteed
1193 ** to be a scalar SQL function. If
1194 **
1195 ** * all function arguments are SQL literals,
1196 ** * one of the SQLITE_FUNC_CONSTANT or _SLOCHNG function flags is set, and
1197 ** * the SQLITE_FUNC_NEEDCOLL function flag is not set,
1198 **
1199 ** then this routine attempts to invoke the SQL function. Assuming no
1200 ** error occurs, output parameter (*ppVal) is set to point to a value
1201 ** object containing the result before returning SQLITE_OK.
1202 **
1203 ** Affinity aff is applied to the result of the function before returning.
1204 ** If the result is a text value, the sqlite3_value object uses encoding
1205 ** enc.
1206 **
1207 ** If the conditions above are not met, this function returns SQLITE_OK
1208 ** and sets (*ppVal) to NULL. Or, if an error occurs, (*ppVal) is set to
1209 ** NULL and an SQLite error code returned.
1210 */
1211 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
valueFromFunction(sqlite3 * db,Expr * p,u8 enc,u8 aff,sqlite3_value ** ppVal,struct ValueNewStat4Ctx * pCtx)1212 static int valueFromFunction(
1213 sqlite3 *db, /* The database connection */
1214 Expr *p, /* The expression to evaluate */
1215 u8 enc, /* Encoding to use */
1216 u8 aff, /* Affinity to use */
1217 sqlite3_value **ppVal, /* Write the new value here */
1218 struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */
1219 ){
1220 sqlite3_context ctx; /* Context object for function invocation */
1221 sqlite3_value **apVal = 0; /* Function arguments */
1222 int nVal = 0; /* Size of apVal[] array */
1223 FuncDef *pFunc = 0; /* Function definition */
1224 sqlite3_value *pVal = 0; /* New value */
1225 int rc = SQLITE_OK; /* Return code */
1226 ExprList *pList = 0; /* Function arguments */
1227 int i; /* Iterator variable */
1228
1229 assert( pCtx!=0 );
1230 assert( (p->flags & EP_TokenOnly)==0 );
1231 pList = p->x.pList;
1232 if( pList ) nVal = pList->nExpr;
1233 pFunc = sqlite3FindFunction(db, p->u.zToken, nVal, enc, 0);
1234 assert( pFunc );
1235 if( (pFunc->funcFlags & (SQLITE_FUNC_CONSTANT|SQLITE_FUNC_SLOCHNG))==0
1236 || (pFunc->funcFlags & SQLITE_FUNC_NEEDCOLL)
1237 ){
1238 return SQLITE_OK;
1239 }
1240
1241 if( pList ){
1242 apVal = (sqlite3_value**)sqlite3DbMallocZero(db, sizeof(apVal[0]) * nVal);
1243 if( apVal==0 ){
1244 rc = SQLITE_NOMEM_BKPT;
1245 goto value_from_function_out;
1246 }
1247 for(i=0; i<nVal; i++){
1248 rc = sqlite3ValueFromExpr(db, pList->a[i].pExpr, enc, aff, &apVal[i]);
1249 if( apVal[i]==0 || rc!=SQLITE_OK ) goto value_from_function_out;
1250 }
1251 }
1252
1253 pVal = valueNew(db, pCtx);
1254 if( pVal==0 ){
1255 rc = SQLITE_NOMEM_BKPT;
1256 goto value_from_function_out;
1257 }
1258
1259 assert( pCtx->pParse->rc==SQLITE_OK );
1260 memset(&ctx, 0, sizeof(ctx));
1261 ctx.pOut = pVal;
1262 ctx.pFunc = pFunc;
1263 pFunc->xSFunc(&ctx, nVal, apVal);
1264 if( ctx.isError ){
1265 rc = ctx.isError;
1266 sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal));
1267 }else{
1268 sqlite3ValueApplyAffinity(pVal, aff, SQLITE_UTF8);
1269 assert( rc==SQLITE_OK );
1270 rc = sqlite3VdbeChangeEncoding(pVal, enc);
1271 if( rc==SQLITE_OK && sqlite3VdbeMemTooBig(pVal) ){
1272 rc = SQLITE_TOOBIG;
1273 pCtx->pParse->nErr++;
1274 }
1275 }
1276 pCtx->pParse->rc = rc;
1277
1278 value_from_function_out:
1279 if( rc!=SQLITE_OK ){
1280 pVal = 0;
1281 }
1282 if( apVal ){
1283 for(i=0; i<nVal; i++){
1284 sqlite3ValueFree(apVal[i]);
1285 }
1286 sqlite3DbFreeNN(db, apVal);
1287 }
1288
1289 *ppVal = pVal;
1290 return rc;
1291 }
1292 #else
1293 # define valueFromFunction(a,b,c,d,e,f) SQLITE_OK
1294 #endif /* defined(SQLITE_ENABLE_STAT3_OR_STAT4) */
1295
1296 /*
1297 ** Extract a value from the supplied expression in the manner described
1298 ** above sqlite3ValueFromExpr(). Allocate the sqlite3_value object
1299 ** using valueNew().
1300 **
1301 ** If pCtx is NULL and an error occurs after the sqlite3_value object
1302 ** has been allocated, it is freed before returning. Or, if pCtx is not
1303 ** NULL, it is assumed that the caller will free any allocated object
1304 ** in all cases.
1305 */
valueFromExpr(sqlite3 * db,Expr * pExpr,u8 enc,u8 affinity,sqlite3_value ** ppVal,struct ValueNewStat4Ctx * pCtx)1306 static int valueFromExpr(
1307 sqlite3 *db, /* The database connection */
1308 Expr *pExpr, /* The expression to evaluate */
1309 u8 enc, /* Encoding to use */
1310 u8 affinity, /* Affinity to use */
1311 sqlite3_value **ppVal, /* Write the new value here */
1312 struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */
1313 ){
1314 int op;
1315 char *zVal = 0;
1316 sqlite3_value *pVal = 0;
1317 int negInt = 1;
1318 const char *zNeg = "";
1319 int rc = SQLITE_OK;
1320
1321 assert( pExpr!=0 );
1322 while( (op = pExpr->op)==TK_UPLUS || op==TK_SPAN ) pExpr = pExpr->pLeft;
1323 if( NEVER(op==TK_REGISTER) ) op = pExpr->op2;
1324
1325 /* Compressed expressions only appear when parsing the DEFAULT clause
1326 ** on a table column definition, and hence only when pCtx==0. This
1327 ** check ensures that an EP_TokenOnly expression is never passed down
1328 ** into valueFromFunction(). */
1329 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
1330
1331 if( op==TK_CAST ){
1332 u8 aff = sqlite3AffinityType(pExpr->u.zToken,0);
1333 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
1334 testcase( rc!=SQLITE_OK );
1335 if( *ppVal ){
1336 sqlite3VdbeMemCast(*ppVal, aff, SQLITE_UTF8);
1337 sqlite3ValueApplyAffinity(*ppVal, affinity, SQLITE_UTF8);
1338 }
1339 return rc;
1340 }
1341
1342 /* Handle negative integers in a single step. This is needed in the
1343 ** case when the value is -9223372036854775808.
1344 */
1345 if( op==TK_UMINUS
1346 && (pExpr->pLeft->op==TK_INTEGER || pExpr->pLeft->op==TK_FLOAT) ){
1347 pExpr = pExpr->pLeft;
1348 op = pExpr->op;
1349 negInt = -1;
1350 zNeg = "-";
1351 }
1352
1353 if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
1354 pVal = valueNew(db, pCtx);
1355 if( pVal==0 ) goto no_mem;
1356 if( ExprHasProperty(pExpr, EP_IntValue) ){
1357 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
1358 }else{
1359 zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr->u.zToken);
1360 if( zVal==0 ) goto no_mem;
1361 sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
1362 }
1363 if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_BLOB ){
1364 sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);
1365 }else{
1366 sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
1367 }
1368 if( pVal->flags & (MEM_Int|MEM_Real) ) pVal->flags &= ~MEM_Str;
1369 if( enc!=SQLITE_UTF8 ){
1370 rc = sqlite3VdbeChangeEncoding(pVal, enc);
1371 }
1372 }else if( op==TK_UMINUS ) {
1373 /* This branch happens for multiple negative signs. Ex: -(-5) */
1374 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
1375 && pVal!=0
1376 ){
1377 sqlite3VdbeMemNumerify(pVal);
1378 if( pVal->flags & MEM_Real ){
1379 pVal->u.r = -pVal->u.r;
1380 }else if( pVal->u.i==SMALLEST_INT64 ){
1381 pVal->u.r = -(double)SMALLEST_INT64;
1382 MemSetTypeFlag(pVal, MEM_Real);
1383 }else{
1384 pVal->u.i = -pVal->u.i;
1385 }
1386 sqlite3ValueApplyAffinity(pVal, affinity, enc);
1387 }
1388 }else if( op==TK_NULL ){
1389 pVal = valueNew(db, pCtx);
1390 if( pVal==0 ) goto no_mem;
1391 sqlite3VdbeMemNumerify(pVal);
1392 }
1393 #ifndef SQLITE_OMIT_BLOB_LITERAL
1394 else if( op==TK_BLOB ){
1395 int nVal;
1396 assert( pExpr->u.zToken[0]=='x' || pExpr->u.zToken[0]=='X' );
1397 assert( pExpr->u.zToken[1]=='\'' );
1398 pVal = valueNew(db, pCtx);
1399 if( !pVal ) goto no_mem;
1400 zVal = &pExpr->u.zToken[2];
1401 nVal = sqlite3Strlen30(zVal)-1;
1402 assert( zVal[nVal]=='\'' );
1403 sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
1404 0, SQLITE_DYNAMIC);
1405 }
1406 #endif
1407
1408 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
1409 else if( op==TK_FUNCTION && pCtx!=0 ){
1410 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
1411 }
1412 #endif
1413
1414 *ppVal = pVal;
1415 return rc;
1416
1417 no_mem:
1418 sqlite3OomFault(db);
1419 sqlite3DbFree(db, zVal);
1420 assert( *ppVal==0 );
1421 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
1422 if( pCtx==0 ) sqlite3ValueFree(pVal);
1423 #else
1424 assert( pCtx==0 ); sqlite3ValueFree(pVal);
1425 #endif
1426 return SQLITE_NOMEM_BKPT;
1427 }
1428
1429 /*
1430 ** Create a new sqlite3_value object, containing the value of pExpr.
1431 **
1432 ** This only works for very simple expressions that consist of one constant
1433 ** token (i.e. "5", "5.1", "'a string'"). If the expression can
1434 ** be converted directly into a value, then the value is allocated and
1435 ** a pointer written to *ppVal. The caller is responsible for deallocating
1436 ** the value by passing it to sqlite3ValueFree() later on. If the expression
1437 ** cannot be converted to a value, then *ppVal is set to NULL.
1438 */
sqlite3ValueFromExpr(sqlite3 * db,Expr * pExpr,u8 enc,u8 affinity,sqlite3_value ** ppVal)1439 int sqlite3ValueFromExpr(
1440 sqlite3 *db, /* The database connection */
1441 Expr *pExpr, /* The expression to evaluate */
1442 u8 enc, /* Encoding to use */
1443 u8 affinity, /* Affinity to use */
1444 sqlite3_value **ppVal /* Write the new value here */
1445 ){
1446 return pExpr ? valueFromExpr(db, pExpr, enc, affinity, ppVal, 0) : 0;
1447 }
1448
1449 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
1450 /*
1451 ** The implementation of the sqlite_record() function. This function accepts
1452 ** a single argument of any type. The return value is a formatted database
1453 ** record (a blob) containing the argument value.
1454 **
1455 ** This is used to convert the value stored in the 'sample' column of the
1456 ** sqlite_stat3 table to the record format SQLite uses internally.
1457 */
recordFunc(sqlite3_context * context,int argc,sqlite3_value ** argv)1458 static void recordFunc(
1459 sqlite3_context *context,
1460 int argc,
1461 sqlite3_value **argv
1462 ){
1463 const int file_format = 1;
1464 u32 iSerial; /* Serial type */
1465 int nSerial; /* Bytes of space for iSerial as varint */
1466 u32 nVal; /* Bytes of space required for argv[0] */
1467 int nRet;
1468 sqlite3 *db;
1469 u8 *aRet;
1470
1471 UNUSED_PARAMETER( argc );
1472 iSerial = sqlite3VdbeSerialType(argv[0], file_format, &nVal);
1473 nSerial = sqlite3VarintLen(iSerial);
1474 db = sqlite3_context_db_handle(context);
1475
1476 nRet = 1 + nSerial + nVal;
1477 aRet = sqlite3DbMallocRawNN(db, nRet);
1478 if( aRet==0 ){
1479 sqlite3_result_error_nomem(context);
1480 }else{
1481 aRet[0] = nSerial+1;
1482 putVarint32(&aRet[1], iSerial);
1483 sqlite3VdbeSerialPut(&aRet[1+nSerial], argv[0], iSerial);
1484 sqlite3_result_blob(context, aRet, nRet, SQLITE_TRANSIENT);
1485 sqlite3DbFreeNN(db, aRet);
1486 }
1487 }
1488
1489 /*
1490 ** Register built-in functions used to help read ANALYZE data.
1491 */
sqlite3AnalyzeFunctions(void)1492 void sqlite3AnalyzeFunctions(void){
1493 static FuncDef aAnalyzeTableFuncs[] = {
1494 FUNCTION(sqlite_record, 1, 0, 0, recordFunc),
1495 };
1496 sqlite3InsertBuiltinFuncs(aAnalyzeTableFuncs, ArraySize(aAnalyzeTableFuncs));
1497 }
1498
1499 /*
1500 ** Attempt to extract a value from pExpr and use it to construct *ppVal.
1501 **
1502 ** If pAlloc is not NULL, then an UnpackedRecord object is created for
1503 ** pAlloc if one does not exist and the new value is added to the
1504 ** UnpackedRecord object.
1505 **
1506 ** A value is extracted in the following cases:
1507 **
1508 ** * (pExpr==0). In this case the value is assumed to be an SQL NULL,
1509 **
1510 ** * The expression is a bound variable, and this is a reprepare, or
1511 **
1512 ** * The expression is a literal value.
1513 **
1514 ** On success, *ppVal is made to point to the extracted value. The caller
1515 ** is responsible for ensuring that the value is eventually freed.
1516 */
stat4ValueFromExpr(Parse * pParse,Expr * pExpr,u8 affinity,struct ValueNewStat4Ctx * pAlloc,sqlite3_value ** ppVal)1517 static int stat4ValueFromExpr(
1518 Parse *pParse, /* Parse context */
1519 Expr *pExpr, /* The expression to extract a value from */
1520 u8 affinity, /* Affinity to use */
1521 struct ValueNewStat4Ctx *pAlloc,/* How to allocate space. Or NULL */
1522 sqlite3_value **ppVal /* OUT: New value object (or NULL) */
1523 ){
1524 int rc = SQLITE_OK;
1525 sqlite3_value *pVal = 0;
1526 sqlite3 *db = pParse->db;
1527
1528 /* Skip over any TK_COLLATE nodes */
1529 pExpr = sqlite3ExprSkipCollate(pExpr);
1530
1531 assert( pExpr==0 || pExpr->op!=TK_REGISTER || pExpr->op2!=TK_VARIABLE );
1532 if( !pExpr ){
1533 pVal = valueNew(db, pAlloc);
1534 if( pVal ){
1535 sqlite3VdbeMemSetNull((Mem*)pVal);
1536 }
1537 }else if( pExpr->op==TK_VARIABLE && (db->flags & SQLITE_EnableQPSG)==0 ){
1538 Vdbe *v;
1539 int iBindVar = pExpr->iColumn;
1540 sqlite3VdbeSetVarmask(pParse->pVdbe, iBindVar);
1541 if( (v = pParse->pReprepare)!=0 ){
1542 pVal = valueNew(db, pAlloc);
1543 if( pVal ){
1544 rc = sqlite3VdbeMemCopy((Mem*)pVal, &v->aVar[iBindVar-1]);
1545 sqlite3ValueApplyAffinity(pVal, affinity, ENC(db));
1546 pVal->db = pParse->db;
1547 }
1548 }
1549 }else{
1550 rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc);
1551 }
1552
1553 assert( pVal==0 || pVal->db==db );
1554 *ppVal = pVal;
1555 return rc;
1556 }
1557
1558 /*
1559 ** This function is used to allocate and populate UnpackedRecord
1560 ** structures intended to be compared against sample index keys stored
1561 ** in the sqlite_stat4 table.
1562 **
1563 ** A single call to this function populates zero or more fields of the
1564 ** record starting with field iVal (fields are numbered from left to
1565 ** right starting with 0). A single field is populated if:
1566 **
1567 ** * (pExpr==0). In this case the value is assumed to be an SQL NULL,
1568 **
1569 ** * The expression is a bound variable, and this is a reprepare, or
1570 **
1571 ** * The sqlite3ValueFromExpr() function is able to extract a value
1572 ** from the expression (i.e. the expression is a literal value).
1573 **
1574 ** Or, if pExpr is a TK_VECTOR, one field is populated for each of the
1575 ** vector components that match either of the two latter criteria listed
1576 ** above.
1577 **
1578 ** Before any value is appended to the record, the affinity of the
1579 ** corresponding column within index pIdx is applied to it. Before
1580 ** this function returns, output parameter *pnExtract is set to the
1581 ** number of values appended to the record.
1582 **
1583 ** When this function is called, *ppRec must either point to an object
1584 ** allocated by an earlier call to this function, or must be NULL. If it
1585 ** is NULL and a value can be successfully extracted, a new UnpackedRecord
1586 ** is allocated (and *ppRec set to point to it) before returning.
1587 **
1588 ** Unless an error is encountered, SQLITE_OK is returned. It is not an
1589 ** error if a value cannot be extracted from pExpr. If an error does
1590 ** occur, an SQLite error code is returned.
1591 */
sqlite3Stat4ProbeSetValue(Parse * pParse,Index * pIdx,UnpackedRecord ** ppRec,Expr * pExpr,int nElem,int iVal,int * pnExtract)1592 int sqlite3Stat4ProbeSetValue(
1593 Parse *pParse, /* Parse context */
1594 Index *pIdx, /* Index being probed */
1595 UnpackedRecord **ppRec, /* IN/OUT: Probe record */
1596 Expr *pExpr, /* The expression to extract a value from */
1597 int nElem, /* Maximum number of values to append */
1598 int iVal, /* Array element to populate */
1599 int *pnExtract /* OUT: Values appended to the record */
1600 ){
1601 int rc = SQLITE_OK;
1602 int nExtract = 0;
1603
1604 if( pExpr==0 || pExpr->op!=TK_SELECT ){
1605 int i;
1606 struct ValueNewStat4Ctx alloc;
1607
1608 alloc.pParse = pParse;
1609 alloc.pIdx = pIdx;
1610 alloc.ppRec = ppRec;
1611
1612 for(i=0; i<nElem; i++){
1613 sqlite3_value *pVal = 0;
1614 Expr *pElem = (pExpr ? sqlite3VectorFieldSubexpr(pExpr, i) : 0);
1615 u8 aff = sqlite3IndexColumnAffinity(pParse->db, pIdx, iVal+i);
1616 alloc.iVal = iVal+i;
1617 rc = stat4ValueFromExpr(pParse, pElem, aff, &alloc, &pVal);
1618 if( !pVal ) break;
1619 nExtract++;
1620 }
1621 }
1622
1623 *pnExtract = nExtract;
1624 return rc;
1625 }
1626
1627 /*
1628 ** Attempt to extract a value from expression pExpr using the methods
1629 ** as described for sqlite3Stat4ProbeSetValue() above.
1630 **
1631 ** If successful, set *ppVal to point to a new value object and return
1632 ** SQLITE_OK. If no value can be extracted, but no other error occurs
1633 ** (e.g. OOM), return SQLITE_OK and set *ppVal to NULL. Or, if an error
1634 ** does occur, return an SQLite error code. The final value of *ppVal
1635 ** is undefined in this case.
1636 */
sqlite3Stat4ValueFromExpr(Parse * pParse,Expr * pExpr,u8 affinity,sqlite3_value ** ppVal)1637 int sqlite3Stat4ValueFromExpr(
1638 Parse *pParse, /* Parse context */
1639 Expr *pExpr, /* The expression to extract a value from */
1640 u8 affinity, /* Affinity to use */
1641 sqlite3_value **ppVal /* OUT: New value object (or NULL) */
1642 ){
1643 return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal);
1644 }
1645
1646 /*
1647 ** Extract the iCol-th column from the nRec-byte record in pRec. Write
1648 ** the column value into *ppVal. If *ppVal is initially NULL then a new
1649 ** sqlite3_value object is allocated.
1650 **
1651 ** If *ppVal is initially NULL then the caller is responsible for
1652 ** ensuring that the value written into *ppVal is eventually freed.
1653 */
sqlite3Stat4Column(sqlite3 * db,const void * pRec,int nRec,int iCol,sqlite3_value ** ppVal)1654 int sqlite3Stat4Column(
1655 sqlite3 *db, /* Database handle */
1656 const void *pRec, /* Pointer to buffer containing record */
1657 int nRec, /* Size of buffer pRec in bytes */
1658 int iCol, /* Column to extract */
1659 sqlite3_value **ppVal /* OUT: Extracted value */
1660 ){
1661 u32 t; /* a column type code */
1662 int nHdr; /* Size of the header in the record */
1663 int iHdr; /* Next unread header byte */
1664 int iField; /* Next unread data byte */
1665 int szField; /* Size of the current data field */
1666 int i; /* Column index */
1667 u8 *a = (u8*)pRec; /* Typecast byte array */
1668 Mem *pMem = *ppVal; /* Write result into this Mem object */
1669
1670 assert( iCol>0 );
1671 iHdr = getVarint32(a, nHdr);
1672 if( nHdr>nRec || iHdr>=nHdr ) return SQLITE_CORRUPT_BKPT;
1673 iField = nHdr;
1674 for(i=0; i<=iCol; i++){
1675 iHdr += getVarint32(&a[iHdr], t);
1676 testcase( iHdr==nHdr );
1677 testcase( iHdr==nHdr+1 );
1678 if( iHdr>nHdr ) return SQLITE_CORRUPT_BKPT;
1679 szField = sqlite3VdbeSerialTypeLen(t);
1680 iField += szField;
1681 }
1682 testcase( iField==nRec );
1683 testcase( iField==nRec+1 );
1684 if( iField>nRec ) return SQLITE_CORRUPT_BKPT;
1685 if( pMem==0 ){
1686 pMem = *ppVal = sqlite3ValueNew(db);
1687 if( pMem==0 ) return SQLITE_NOMEM_BKPT;
1688 }
1689 sqlite3VdbeSerialGet(&a[iField-szField], t, pMem);
1690 pMem->enc = ENC(db);
1691 return SQLITE_OK;
1692 }
1693
1694 /*
1695 ** Unless it is NULL, the argument must be an UnpackedRecord object returned
1696 ** by an earlier call to sqlite3Stat4ProbeSetValue(). This call deletes
1697 ** the object.
1698 */
sqlite3Stat4ProbeFree(UnpackedRecord * pRec)1699 void sqlite3Stat4ProbeFree(UnpackedRecord *pRec){
1700 if( pRec ){
1701 int i;
1702 int nCol = pRec->pKeyInfo->nField+pRec->pKeyInfo->nXField;
1703 Mem *aMem = pRec->aMem;
1704 sqlite3 *db = aMem[0].db;
1705 for(i=0; i<nCol; i++){
1706 sqlite3VdbeMemRelease(&aMem[i]);
1707 }
1708 sqlite3KeyInfoUnref(pRec->pKeyInfo);
1709 sqlite3DbFreeNN(db, pRec);
1710 }
1711 }
1712 #endif /* ifdef SQLITE_ENABLE_STAT4 */
1713
1714 /*
1715 ** Change the string value of an sqlite3_value object
1716 */
sqlite3ValueSetStr(sqlite3_value * v,int n,const void * z,u8 enc,void (* xDel)(void *))1717 void sqlite3ValueSetStr(
1718 sqlite3_value *v, /* Value to be set */
1719 int n, /* Length of string z */
1720 const void *z, /* Text of the new string */
1721 u8 enc, /* Encoding to use */
1722 void (*xDel)(void*) /* Destructor for the string */
1723 ){
1724 if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
1725 }
1726
1727 /*
1728 ** Free an sqlite3_value object
1729 */
sqlite3ValueFree(sqlite3_value * v)1730 void sqlite3ValueFree(sqlite3_value *v){
1731 if( !v ) return;
1732 sqlite3VdbeMemRelease((Mem *)v);
1733 sqlite3DbFreeNN(((Mem*)v)->db, v);
1734 }
1735
1736 /*
1737 ** The sqlite3ValueBytes() routine returns the number of bytes in the
1738 ** sqlite3_value object assuming that it uses the encoding "enc".
1739 ** The valueBytes() routine is a helper function.
1740 */
valueBytes(sqlite3_value * pVal,u8 enc)1741 static SQLITE_NOINLINE int valueBytes(sqlite3_value *pVal, u8 enc){
1742 return valueToText(pVal, enc)!=0 ? pVal->n : 0;
1743 }
sqlite3ValueBytes(sqlite3_value * pVal,u8 enc)1744 int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
1745 Mem *p = (Mem*)pVal;
1746 assert( (p->flags & MEM_Null)==0 || (p->flags & (MEM_Str|MEM_Blob))==0 );
1747 if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){
1748 return p->n;
1749 }
1750 if( (p->flags & MEM_Blob)!=0 ){
1751 if( p->flags & MEM_Zero ){
1752 return p->n + p->u.nZero;
1753 }else{
1754 return p->n;
1755 }
1756 }
1757 if( p->flags & MEM_Null ) return 0;
1758 return valueBytes(pVal, enc);
1759 }
1760