1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SQLite/vdbemem.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1044 @@
1.4 +/*
1.5 +** 2004 May 26
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +**
1.16 +** This file contains code use to manipulate "Mem" structure. A "Mem"
1.17 +** stores a single value in the VDBE. Mem is an opaque structure visible
1.18 +** only within the VDBE. Interface routines refer to a Mem using the
1.19 +** name sqlite_value
1.20 +**
1.21 +** $Id: vdbemem.c,v 1.121 2008/08/01 20:10:09 drh Exp $
1.22 +*/
1.23 +#include "sqliteInt.h"
1.24 +#include <ctype.h>
1.25 +#include "vdbeInt.h"
1.26 +
1.27 +/*
1.28 +** Call sqlite3VdbeMemExpandBlob() on the supplied value (type Mem*)
1.29 +** P if required.
1.30 +*/
1.31 +#define expandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
1.32 +
1.33 +/*
1.34 +** If pMem is an object with a valid string representation, this routine
1.35 +** ensures the internal encoding for the string representation is
1.36 +** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE.
1.37 +**
1.38 +** If pMem is not a string object, or the encoding of the string
1.39 +** representation is already stored using the requested encoding, then this
1.40 +** routine is a no-op.
1.41 +**
1.42 +** SQLITE_OK is returned if the conversion is successful (or not required).
1.43 +** SQLITE_NOMEM may be returned if a malloc() fails during conversion
1.44 +** between formats.
1.45 +*/
1.46 +int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
1.47 + int rc;
1.48 + if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
1.49 + return SQLITE_OK;
1.50 + }
1.51 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.52 +#ifdef SQLITE_OMIT_UTF16
1.53 + return SQLITE_ERROR;
1.54 +#else
1.55 +
1.56 + /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
1.57 + ** then the encoding of the value may not have changed.
1.58 + */
1.59 + rc = sqlite3VdbeMemTranslate(pMem, desiredEnc);
1.60 + assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
1.61 + assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
1.62 + assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
1.63 + return rc;
1.64 +#endif
1.65 +}
1.66 +
1.67 +/*
1.68 +** Make sure pMem->z points to a writable allocation of at least
1.69 +** n bytes.
1.70 +**
1.71 +** If the memory cell currently contains string or blob data
1.72 +** and the third argument passed to this function is true, the
1.73 +** current content of the cell is preserved. Otherwise, it may
1.74 +** be discarded.
1.75 +**
1.76 +** This function sets the MEM_Dyn flag and clears any xDel callback.
1.77 +** It also clears MEM_Ephem and MEM_Static. If the preserve flag is
1.78 +** not set, Mem.n is zeroed.
1.79 +*/
1.80 +int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve){
1.81 + assert( 1 >=
1.82 + ((pMem->zMalloc && pMem->zMalloc==pMem->z) ? 1 : 0) +
1.83 + (((pMem->flags&MEM_Dyn)&&pMem->xDel) ? 1 : 0) +
1.84 + ((pMem->flags&MEM_Ephem) ? 1 : 0) +
1.85 + ((pMem->flags&MEM_Static) ? 1 : 0)
1.86 + );
1.87 +
1.88 + if( n<32 ) n = 32;
1.89 + if( sqlite3DbMallocSize(pMem->db, pMem->zMalloc)<n ){
1.90 + if( preserve && pMem->z==pMem->zMalloc ){
1.91 + pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
1.92 + if( !pMem->z ){
1.93 + pMem->flags = MEM_Null;
1.94 + }
1.95 + preserve = 0;
1.96 + }else{
1.97 + sqlite3DbFree(pMem->db, pMem->zMalloc);
1.98 + pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
1.99 + }
1.100 + }
1.101 +
1.102 + if( preserve && pMem->z && pMem->zMalloc && pMem->z!=pMem->zMalloc ){
1.103 + memcpy(pMem->zMalloc, pMem->z, pMem->n);
1.104 + }
1.105 + if( pMem->flags&MEM_Dyn && pMem->xDel ){
1.106 + pMem->xDel((void *)(pMem->z));
1.107 + }
1.108 +
1.109 + pMem->z = pMem->zMalloc;
1.110 + pMem->flags &= ~(MEM_Ephem|MEM_Static);
1.111 + pMem->xDel = 0;
1.112 + return (pMem->z ? SQLITE_OK : SQLITE_NOMEM);
1.113 +}
1.114 +
1.115 +/*
1.116 +** Make the given Mem object MEM_Dyn. In other words, make it so
1.117 +** that any TEXT or BLOB content is stored in memory obtained from
1.118 +** malloc(). In this way, we know that the memory is safe to be
1.119 +** overwritten or altered.
1.120 +**
1.121 +** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
1.122 +*/
1.123 +int sqlite3VdbeMemMakeWriteable(Mem *pMem){
1.124 + int f;
1.125 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.126 + expandBlob(pMem);
1.127 + f = pMem->flags;
1.128 + if( (f&(MEM_Str|MEM_Blob)) && pMem->z!=pMem->zMalloc ){
1.129 + if( sqlite3VdbeMemGrow(pMem, pMem->n + 2, 1) ){
1.130 + return SQLITE_NOMEM;
1.131 + }
1.132 + pMem->z[pMem->n] = 0;
1.133 + pMem->z[pMem->n+1] = 0;
1.134 + pMem->flags |= MEM_Term;
1.135 + }
1.136 +
1.137 + return SQLITE_OK;
1.138 +}
1.139 +
1.140 +/*
1.141 +** If the given Mem* has a zero-filled tail, turn it into an ordinary
1.142 +** blob stored in dynamically allocated space.
1.143 +*/
1.144 +#ifndef SQLITE_OMIT_INCRBLOB
1.145 +int sqlite3VdbeMemExpandBlob(Mem *pMem){
1.146 + if( pMem->flags & MEM_Zero ){
1.147 + int nByte;
1.148 + assert( pMem->flags&MEM_Blob );
1.149 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.150 +
1.151 + /* Set nByte to the number of bytes required to store the expanded blob. */
1.152 + nByte = pMem->n + pMem->u.i;
1.153 + if( nByte<=0 ){
1.154 + nByte = 1;
1.155 + }
1.156 + if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
1.157 + return SQLITE_NOMEM;
1.158 + }
1.159 +
1.160 + memset(&pMem->z[pMem->n], 0, pMem->u.i);
1.161 + pMem->n += pMem->u.i;
1.162 + pMem->flags &= ~(MEM_Zero|MEM_Term);
1.163 + }
1.164 + return SQLITE_OK;
1.165 +}
1.166 +#endif
1.167 +
1.168 +
1.169 +/*
1.170 +** Make sure the given Mem is \u0000 terminated.
1.171 +*/
1.172 +int sqlite3VdbeMemNulTerminate(Mem *pMem){
1.173 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.174 + if( (pMem->flags & MEM_Term)!=0 || (pMem->flags & MEM_Str)==0 ){
1.175 + return SQLITE_OK; /* Nothing to do */
1.176 + }
1.177 + if( sqlite3VdbeMemGrow(pMem, pMem->n+2, 1) ){
1.178 + return SQLITE_NOMEM;
1.179 + }
1.180 + pMem->z[pMem->n] = 0;
1.181 + pMem->z[pMem->n+1] = 0;
1.182 + pMem->flags |= MEM_Term;
1.183 + return SQLITE_OK;
1.184 +}
1.185 +
1.186 +/*
1.187 +** Add MEM_Str to the set of representations for the given Mem. Numbers
1.188 +** are converted using sqlite3_snprintf(). Converting a BLOB to a string
1.189 +** is a no-op.
1.190 +**
1.191 +** Existing representations MEM_Int and MEM_Real are *not* invalidated.
1.192 +**
1.193 +** A MEM_Null value will never be passed to this function. This function is
1.194 +** used for converting values to text for returning to the user (i.e. via
1.195 +** sqlite3_value_text()), or for ensuring that values to be used as btree
1.196 +** keys are strings. In the former case a NULL pointer is returned the
1.197 +** user and the later is an internal programming error.
1.198 +*/
1.199 +int sqlite3VdbeMemStringify(Mem *pMem, int enc){
1.200 + int rc = SQLITE_OK;
1.201 + int fg = pMem->flags;
1.202 + const int nByte = 32;
1.203 +
1.204 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.205 + assert( !(fg&MEM_Zero) );
1.206 + assert( !(fg&(MEM_Str|MEM_Blob)) );
1.207 + assert( fg&(MEM_Int|MEM_Real) );
1.208 +
1.209 + if( sqlite3VdbeMemGrow(pMem, nByte, 0) ){
1.210 + return SQLITE_NOMEM;
1.211 + }
1.212 +
1.213 + /* For a Real or Integer, use sqlite3_mprintf() to produce the UTF-8
1.214 + ** string representation of the value. Then, if the required encoding
1.215 + ** is UTF-16le or UTF-16be do a translation.
1.216 + **
1.217 + ** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16.
1.218 + */
1.219 + if( fg & MEM_Int ){
1.220 + sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
1.221 + }else{
1.222 + assert( fg & MEM_Real );
1.223 + sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->r);
1.224 + }
1.225 + pMem->n = strlen(pMem->z);
1.226 + pMem->enc = SQLITE_UTF8;
1.227 + pMem->flags |= MEM_Str|MEM_Term;
1.228 + sqlite3VdbeChangeEncoding(pMem, enc);
1.229 + return rc;
1.230 +}
1.231 +
1.232 +/*
1.233 +** Memory cell pMem contains the context of an aggregate function.
1.234 +** This routine calls the finalize method for that function. The
1.235 +** result of the aggregate is stored back into pMem.
1.236 +**
1.237 +** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK
1.238 +** otherwise.
1.239 +*/
1.240 +int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
1.241 + int rc = SQLITE_OK;
1.242 + if( pFunc && pFunc->xFinalize ){
1.243 + sqlite3_context ctx;
1.244 + assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
1.245 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.246 + ctx.s.flags = MEM_Null;
1.247 + ctx.s.db = pMem->db;
1.248 + ctx.s.zMalloc = 0;
1.249 + ctx.pMem = pMem;
1.250 + ctx.pFunc = pFunc;
1.251 + ctx.isError = 0;
1.252 + pFunc->xFinalize(&ctx);
1.253 + assert( 0==(pMem->flags&MEM_Dyn) && !pMem->xDel );
1.254 + sqlite3DbFree(pMem->db, pMem->zMalloc);
1.255 + *pMem = ctx.s;
1.256 + rc = (ctx.isError?SQLITE_ERROR:SQLITE_OK);
1.257 + }
1.258 + return rc;
1.259 +}
1.260 +
1.261 +/*
1.262 +** If the memory cell contains a string value that must be freed by
1.263 +** invoking an external callback, free it now. Calling this function
1.264 +** does not free any Mem.zMalloc buffer.
1.265 +*/
1.266 +void sqlite3VdbeMemReleaseExternal(Mem *p){
1.267 + assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
1.268 + if( p->flags&MEM_Agg ){
1.269 + sqlite3VdbeMemFinalize(p, p->u.pDef);
1.270 + assert( (p->flags & MEM_Agg)==0 );
1.271 + sqlite3VdbeMemRelease(p);
1.272 + }else if( p->flags&MEM_Dyn && p->xDel ){
1.273 + p->xDel((void *)p->z);
1.274 + p->xDel = 0;
1.275 + }
1.276 +}
1.277 +
1.278 +/*
1.279 +** Release any memory held by the Mem. This may leave the Mem in an
1.280 +** inconsistent state, for example with (Mem.z==0) and
1.281 +** (Mem.type==SQLITE_TEXT).
1.282 +*/
1.283 +void sqlite3VdbeMemRelease(Mem *p){
1.284 + sqlite3VdbeMemReleaseExternal(p);
1.285 + sqlite3DbFree(p->db, p->zMalloc);
1.286 + p->z = 0;
1.287 + p->zMalloc = 0;
1.288 + p->xDel = 0;
1.289 +}
1.290 +
1.291 +/*
1.292 +** Convert a 64-bit IEEE double into a 64-bit signed integer.
1.293 +** If the double is too large, return 0x8000000000000000.
1.294 +**
1.295 +** Most systems appear to do this simply by assigning
1.296 +** variables and without the extra range tests. But
1.297 +** there are reports that windows throws an expection
1.298 +** if the floating point value is out of range. (See ticket #2880.)
1.299 +** Because we do not completely understand the problem, we will
1.300 +** take the conservative approach and always do range tests
1.301 +** before attempting the conversion.
1.302 +*/
1.303 +static i64 doubleToInt64(double r){
1.304 + /*
1.305 + ** Many compilers we encounter do not define constants for the
1.306 + ** minimum and maximum 64-bit integers, or they define them
1.307 + ** inconsistently. And many do not understand the "LL" notation.
1.308 + ** So we define our own static constants here using nothing
1.309 + ** larger than a 32-bit integer constant.
1.310 + */
1.311 + static const i64 maxInt = LARGEST_INT64;
1.312 + static const i64 minInt = SMALLEST_INT64;
1.313 +
1.314 + if( r<(double)minInt ){
1.315 + return minInt;
1.316 + }else if( r>(double)maxInt ){
1.317 + return minInt;
1.318 + }else{
1.319 + return (i64)r;
1.320 + }
1.321 +}
1.322 +
1.323 +/*
1.324 +** Return some kind of integer value which is the best we can do
1.325 +** at representing the value that *pMem describes as an integer.
1.326 +** If pMem is an integer, then the value is exact. If pMem is
1.327 +** a floating-point then the value returned is the integer part.
1.328 +** If pMem is a string or blob, then we make an attempt to convert
1.329 +** it into a integer and return that. If pMem is NULL, return 0.
1.330 +**
1.331 +** If pMem is a string, its encoding might be changed.
1.332 +*/
1.333 +i64 sqlite3VdbeIntValue(Mem *pMem){
1.334 + int flags;
1.335 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.336 + flags = pMem->flags;
1.337 + if( flags & MEM_Int ){
1.338 + return pMem->u.i;
1.339 + }else if( flags & MEM_Real ){
1.340 + return doubleToInt64(pMem->r);
1.341 + }else if( flags & (MEM_Str|MEM_Blob) ){
1.342 + i64 value;
1.343 + pMem->flags |= MEM_Str;
1.344 + if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8)
1.345 + || sqlite3VdbeMemNulTerminate(pMem) ){
1.346 + return 0;
1.347 + }
1.348 + assert( pMem->z );
1.349 + sqlite3Atoi64(pMem->z, &value);
1.350 + return value;
1.351 + }else{
1.352 + return 0;
1.353 + }
1.354 +}
1.355 +
1.356 +/*
1.357 +** Return the best representation of pMem that we can get into a
1.358 +** double. If pMem is already a double or an integer, return its
1.359 +** value. If it is a string or blob, try to convert it to a double.
1.360 +** If it is a NULL, return 0.0.
1.361 +*/
1.362 +double sqlite3VdbeRealValue(Mem *pMem){
1.363 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.364 + if( pMem->flags & MEM_Real ){
1.365 + return pMem->r;
1.366 + }else if( pMem->flags & MEM_Int ){
1.367 + return (double)pMem->u.i;
1.368 + }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
1.369 + double val = 0.0;
1.370 + pMem->flags |= MEM_Str;
1.371 + if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8)
1.372 + || sqlite3VdbeMemNulTerminate(pMem) ){
1.373 + return 0.0;
1.374 + }
1.375 + assert( pMem->z );
1.376 + sqlite3AtoF(pMem->z, &val);
1.377 + return val;
1.378 + }else{
1.379 + return 0.0;
1.380 + }
1.381 +}
1.382 +
1.383 +/*
1.384 +** The MEM structure is already a MEM_Real. Try to also make it a
1.385 +** MEM_Int if we can.
1.386 +*/
1.387 +void sqlite3VdbeIntegerAffinity(Mem *pMem){
1.388 + assert( pMem->flags & MEM_Real );
1.389 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.390 +
1.391 + pMem->u.i = doubleToInt64(pMem->r);
1.392 + if( pMem->r==(double)pMem->u.i ){
1.393 + pMem->flags |= MEM_Int;
1.394 + }
1.395 +}
1.396 +
1.397 +static void setTypeFlag(Mem *pMem, int f){
1.398 + MemSetTypeFlag(pMem, f);
1.399 +}
1.400 +
1.401 +/*
1.402 +** Convert pMem to type integer. Invalidate any prior representations.
1.403 +*/
1.404 +int sqlite3VdbeMemIntegerify(Mem *pMem){
1.405 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.406 + pMem->u.i = sqlite3VdbeIntValue(pMem);
1.407 + setTypeFlag(pMem, MEM_Int);
1.408 + return SQLITE_OK;
1.409 +}
1.410 +
1.411 +/*
1.412 +** Convert pMem so that it is of type MEM_Real.
1.413 +** Invalidate any prior representations.
1.414 +*/
1.415 +int sqlite3VdbeMemRealify(Mem *pMem){
1.416 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.417 + pMem->r = sqlite3VdbeRealValue(pMem);
1.418 + setTypeFlag(pMem, MEM_Real);
1.419 + return SQLITE_OK;
1.420 +}
1.421 +
1.422 +/*
1.423 +** Convert pMem so that it has types MEM_Real or MEM_Int or both.
1.424 +** Invalidate any prior representations.
1.425 +*/
1.426 +int sqlite3VdbeMemNumerify(Mem *pMem){
1.427 + double r1, r2;
1.428 + i64 i;
1.429 + assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 );
1.430 + assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
1.431 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.432 + r1 = sqlite3VdbeRealValue(pMem);
1.433 + i = doubleToInt64(r1);
1.434 + r2 = (double)i;
1.435 + if( r1==r2 ){
1.436 + sqlite3VdbeMemIntegerify(pMem);
1.437 + }else{
1.438 + pMem->r = r1;
1.439 + setTypeFlag(pMem, MEM_Real);
1.440 + }
1.441 + return SQLITE_OK;
1.442 +}
1.443 +
1.444 +/*
1.445 +** Delete any previous value and set the value stored in *pMem to NULL.
1.446 +*/
1.447 +void sqlite3VdbeMemSetNull(Mem *pMem){
1.448 + setTypeFlag(pMem, MEM_Null);
1.449 + pMem->type = SQLITE_NULL;
1.450 +}
1.451 +
1.452 +/*
1.453 +** Delete any previous value and set the value to be a BLOB of length
1.454 +** n containing all zeros.
1.455 +*/
1.456 +void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
1.457 + sqlite3VdbeMemRelease(pMem);
1.458 + setTypeFlag(pMem, MEM_Blob);
1.459 + pMem->flags = MEM_Blob|MEM_Zero;
1.460 + pMem->type = SQLITE_BLOB;
1.461 + pMem->n = 0;
1.462 + if( n<0 ) n = 0;
1.463 + pMem->u.i = n;
1.464 + pMem->enc = SQLITE_UTF8;
1.465 +}
1.466 +
1.467 +/*
1.468 +** Delete any previous value and set the value stored in *pMem to val,
1.469 +** manifest type INTEGER.
1.470 +*/
1.471 +void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
1.472 + sqlite3VdbeMemRelease(pMem);
1.473 + pMem->u.i = val;
1.474 + pMem->flags = MEM_Int;
1.475 + pMem->type = SQLITE_INTEGER;
1.476 +}
1.477 +
1.478 +/*
1.479 +** Delete any previous value and set the value stored in *pMem to val,
1.480 +** manifest type REAL.
1.481 +*/
1.482 +void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
1.483 + if( sqlite3IsNaN(val) ){
1.484 + sqlite3VdbeMemSetNull(pMem);
1.485 + }else{
1.486 + sqlite3VdbeMemRelease(pMem);
1.487 + pMem->r = val;
1.488 + pMem->flags = MEM_Real;
1.489 + pMem->type = SQLITE_FLOAT;
1.490 + }
1.491 +}
1.492 +
1.493 +/*
1.494 +** Return true if the Mem object contains a TEXT or BLOB that is
1.495 +** too large - whose size exceeds SQLITE_MAX_LENGTH.
1.496 +*/
1.497 +int sqlite3VdbeMemTooBig(Mem *p){
1.498 + assert( p->db!=0 );
1.499 + if( p->flags & (MEM_Str|MEM_Blob) ){
1.500 + int n = p->n;
1.501 + if( p->flags & MEM_Zero ){
1.502 + n += p->u.i;
1.503 + }
1.504 + return n>p->db->aLimit[SQLITE_LIMIT_LENGTH];
1.505 + }
1.506 + return 0;
1.507 +}
1.508 +
1.509 +/*
1.510 +** Size of struct Mem not including the Mem.zMalloc member.
1.511 +*/
1.512 +#define MEMCELLSIZE (size_t)(&(((Mem *)0)->zMalloc))
1.513 +
1.514 +/*
1.515 +** Make an shallow copy of pFrom into pTo. Prior contents of
1.516 +** pTo are freed. The pFrom->z field is not duplicated. If
1.517 +** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
1.518 +** and flags gets srcType (either MEM_Ephem or MEM_Static).
1.519 +*/
1.520 +void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
1.521 + sqlite3VdbeMemReleaseExternal(pTo);
1.522 + memcpy(pTo, pFrom, MEMCELLSIZE);
1.523 + pTo->xDel = 0;
1.524 + if( (pFrom->flags&MEM_Dyn)!=0 || pFrom->z==pFrom->zMalloc ){
1.525 + pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
1.526 + assert( srcType==MEM_Ephem || srcType==MEM_Static );
1.527 + pTo->flags |= srcType;
1.528 + }
1.529 +}
1.530 +
1.531 +/*
1.532 +** Make a full copy of pFrom into pTo. Prior contents of pTo are
1.533 +** freed before the copy is made.
1.534 +*/
1.535 +int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
1.536 + int rc = SQLITE_OK;
1.537 +
1.538 + sqlite3VdbeMemReleaseExternal(pTo);
1.539 + memcpy(pTo, pFrom, MEMCELLSIZE);
1.540 + pTo->flags &= ~MEM_Dyn;
1.541 +
1.542 + if( pTo->flags&(MEM_Str|MEM_Blob) ){
1.543 + if( 0==(pFrom->flags&MEM_Static) ){
1.544 + pTo->flags |= MEM_Ephem;
1.545 + rc = sqlite3VdbeMemMakeWriteable(pTo);
1.546 + }
1.547 + }
1.548 +
1.549 + return rc;
1.550 +}
1.551 +
1.552 +/*
1.553 +** Transfer the contents of pFrom to pTo. Any existing value in pTo is
1.554 +** freed. If pFrom contains ephemeral data, a copy is made.
1.555 +**
1.556 +** pFrom contains an SQL NULL when this routine returns.
1.557 +*/
1.558 +void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
1.559 + assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
1.560 + assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
1.561 + assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
1.562 +
1.563 + sqlite3VdbeMemRelease(pTo);
1.564 + memcpy(pTo, pFrom, sizeof(Mem));
1.565 + pFrom->flags = MEM_Null;
1.566 + pFrom->xDel = 0;
1.567 + pFrom->zMalloc = 0;
1.568 +}
1.569 +
1.570 +/*
1.571 +** Change the value of a Mem to be a string or a BLOB.
1.572 +**
1.573 +** The memory management strategy depends on the value of the xDel
1.574 +** parameter. If the value passed is SQLITE_TRANSIENT, then the
1.575 +** string is copied into a (possibly existing) buffer managed by the
1.576 +** Mem structure. Otherwise, any existing buffer is freed and the
1.577 +** pointer copied.
1.578 +*/
1.579 +int sqlite3VdbeMemSetStr(
1.580 + Mem *pMem, /* Memory cell to set to string value */
1.581 + const char *z, /* String pointer */
1.582 + int n, /* Bytes in string, or negative */
1.583 + u8 enc, /* Encoding of z. 0 for BLOBs */
1.584 + void (*xDel)(void*) /* Destructor function */
1.585 +){
1.586 + int nByte = n; /* New value for pMem->n */
1.587 + int iLimit; /* Maximum allowed string or blob size */
1.588 + int flags = 0; /* New value for pMem->flags */
1.589 +
1.590 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.591 +
1.592 + /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
1.593 + if( !z ){
1.594 + sqlite3VdbeMemSetNull(pMem);
1.595 + return SQLITE_OK;
1.596 + }
1.597 +
1.598 + if( pMem->db ){
1.599 + iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH];
1.600 + }else{
1.601 + iLimit = SQLITE_MAX_LENGTH;
1.602 + }
1.603 + flags = (enc==0?MEM_Blob:MEM_Str);
1.604 + if( nByte<0 ){
1.605 + assert( enc!=0 );
1.606 + if( enc==SQLITE_UTF8 ){
1.607 + for(nByte=0; nByte<=iLimit && z[nByte]; nByte++){}
1.608 + }else{
1.609 + for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
1.610 + }
1.611 + flags |= MEM_Term;
1.612 + }
1.613 + if( nByte>iLimit ){
1.614 + return SQLITE_TOOBIG;
1.615 + }
1.616 +
1.617 + /* The following block sets the new values of Mem.z and Mem.xDel. It
1.618 + ** also sets a flag in local variable "flags" to indicate the memory
1.619 + ** management (one of MEM_Dyn or MEM_Static).
1.620 + */
1.621 + if( xDel==SQLITE_TRANSIENT ){
1.622 + int nAlloc = nByte;
1.623 + if( flags&MEM_Term ){
1.624 + nAlloc += (enc==SQLITE_UTF8?1:2);
1.625 + }
1.626 + if( sqlite3VdbeMemGrow(pMem, nAlloc, 0) ){
1.627 + return SQLITE_NOMEM;
1.628 + }
1.629 + memcpy(pMem->z, z, nAlloc);
1.630 + }else if( xDel==SQLITE_DYNAMIC ){
1.631 + sqlite3VdbeMemRelease(pMem);
1.632 + pMem->zMalloc = pMem->z = (char *)z;
1.633 + pMem->xDel = 0;
1.634 + }else{
1.635 + sqlite3VdbeMemRelease(pMem);
1.636 + pMem->z = (char *)z;
1.637 + pMem->xDel = xDel;
1.638 + flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn);
1.639 + }
1.640 +
1.641 + pMem->n = nByte;
1.642 + pMem->flags = flags;
1.643 + pMem->enc = (enc==0 ? SQLITE_UTF8 : enc);
1.644 + pMem->type = (enc==0 ? SQLITE_BLOB : SQLITE_TEXT);
1.645 +
1.646 +#ifndef SQLITE_OMIT_UTF16
1.647 + if( pMem->enc!=SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
1.648 + return SQLITE_NOMEM;
1.649 + }
1.650 +#endif
1.651 +
1.652 + return SQLITE_OK;
1.653 +}
1.654 +
1.655 +/*
1.656 +** Compare the values contained by the two memory cells, returning
1.657 +** negative, zero or positive if pMem1 is less than, equal to, or greater
1.658 +** than pMem2. Sorting order is NULL's first, followed by numbers (integers
1.659 +** and reals) sorted numerically, followed by text ordered by the collating
1.660 +** sequence pColl and finally blob's ordered by memcmp().
1.661 +**
1.662 +** Two NULL values are considered equal by this function.
1.663 +*/
1.664 +int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
1.665 + int rc;
1.666 + int f1, f2;
1.667 + int combined_flags;
1.668 +
1.669 + /* Interchange pMem1 and pMem2 if the collating sequence specifies
1.670 + ** DESC order.
1.671 + */
1.672 + f1 = pMem1->flags;
1.673 + f2 = pMem2->flags;
1.674 + combined_flags = f1|f2;
1.675 +
1.676 + /* If one value is NULL, it is less than the other. If both values
1.677 + ** are NULL, return 0.
1.678 + */
1.679 + if( combined_flags&MEM_Null ){
1.680 + return (f2&MEM_Null) - (f1&MEM_Null);
1.681 + }
1.682 +
1.683 + /* If one value is a number and the other is not, the number is less.
1.684 + ** If both are numbers, compare as reals if one is a real, or as integers
1.685 + ** if both values are integers.
1.686 + */
1.687 + if( combined_flags&(MEM_Int|MEM_Real) ){
1.688 + if( !(f1&(MEM_Int|MEM_Real)) ){
1.689 + return 1;
1.690 + }
1.691 + if( !(f2&(MEM_Int|MEM_Real)) ){
1.692 + return -1;
1.693 + }
1.694 + if( (f1 & f2 & MEM_Int)==0 ){
1.695 + double r1, r2;
1.696 + if( (f1&MEM_Real)==0 ){
1.697 + r1 = pMem1->u.i;
1.698 + }else{
1.699 + r1 = pMem1->r;
1.700 + }
1.701 + if( (f2&MEM_Real)==0 ){
1.702 + r2 = pMem2->u.i;
1.703 + }else{
1.704 + r2 = pMem2->r;
1.705 + }
1.706 + if( r1<r2 ) return -1;
1.707 + if( r1>r2 ) return 1;
1.708 + return 0;
1.709 + }else{
1.710 + assert( f1&MEM_Int );
1.711 + assert( f2&MEM_Int );
1.712 + if( pMem1->u.i < pMem2->u.i ) return -1;
1.713 + if( pMem1->u.i > pMem2->u.i ) return 1;
1.714 + return 0;
1.715 + }
1.716 + }
1.717 +
1.718 + /* If one value is a string and the other is a blob, the string is less.
1.719 + ** If both are strings, compare using the collating functions.
1.720 + */
1.721 + if( combined_flags&MEM_Str ){
1.722 + if( (f1 & MEM_Str)==0 ){
1.723 + return 1;
1.724 + }
1.725 + if( (f2 & MEM_Str)==0 ){
1.726 + return -1;
1.727 + }
1.728 +
1.729 + assert( pMem1->enc==pMem2->enc );
1.730 + assert( pMem1->enc==SQLITE_UTF8 ||
1.731 + pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
1.732 +
1.733 + /* The collation sequence must be defined at this point, even if
1.734 + ** the user deletes the collation sequence after the vdbe program is
1.735 + ** compiled (this was not always the case).
1.736 + */
1.737 + assert( !pColl || pColl->xCmp );
1.738 +
1.739 + if( pColl ){
1.740 + if( pMem1->enc==pColl->enc ){
1.741 + /* The strings are already in the correct encoding. Call the
1.742 + ** comparison function directly */
1.743 + return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
1.744 + }else{
1.745 + u8 origEnc = pMem1->enc;
1.746 + const void *v1, *v2;
1.747 + int n1, n2;
1.748 + /* Convert the strings into the encoding that the comparison
1.749 + ** function expects */
1.750 + v1 = sqlite3ValueText((sqlite3_value*)pMem1, pColl->enc);
1.751 + n1 = v1==0 ? 0 : pMem1->n;
1.752 + assert( n1==sqlite3ValueBytes((sqlite3_value*)pMem1, pColl->enc) );
1.753 + v2 = sqlite3ValueText((sqlite3_value*)pMem2, pColl->enc);
1.754 + n2 = v2==0 ? 0 : pMem2->n;
1.755 + assert( n2==sqlite3ValueBytes((sqlite3_value*)pMem2, pColl->enc) );
1.756 + /* Do the comparison */
1.757 + rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2);
1.758 + /* Convert the strings back into the database encoding */
1.759 + sqlite3ValueText((sqlite3_value*)pMem1, origEnc);
1.760 + sqlite3ValueText((sqlite3_value*)pMem2, origEnc);
1.761 + return rc;
1.762 + }
1.763 + }
1.764 + /* If a NULL pointer was passed as the collate function, fall through
1.765 + ** to the blob case and use memcmp(). */
1.766 + }
1.767 +
1.768 + /* Both values must be blobs. Compare using memcmp(). */
1.769 + rc = memcmp(pMem1->z, pMem2->z, (pMem1->n>pMem2->n)?pMem2->n:pMem1->n);
1.770 + if( rc==0 ){
1.771 + rc = pMem1->n - pMem2->n;
1.772 + }
1.773 + return rc;
1.774 +}
1.775 +
1.776 +/*
1.777 +** Move data out of a btree key or data field and into a Mem structure.
1.778 +** The data or key is taken from the entry that pCur is currently pointing
1.779 +** to. offset and amt determine what portion of the data or key to retrieve.
1.780 +** key is true to get the key or false to get data. The result is written
1.781 +** into the pMem element.
1.782 +**
1.783 +** The pMem structure is assumed to be uninitialized. Any prior content
1.784 +** is overwritten without being freed.
1.785 +**
1.786 +** If this routine fails for any reason (malloc returns NULL or unable
1.787 +** to read from the disk) then the pMem is left in an inconsistent state.
1.788 +*/
1.789 +int sqlite3VdbeMemFromBtree(
1.790 + BtCursor *pCur, /* Cursor pointing at record to retrieve. */
1.791 + int offset, /* Offset from the start of data to return bytes from. */
1.792 + int amt, /* Number of bytes to return. */
1.793 + int key, /* If true, retrieve from the btree key, not data. */
1.794 + Mem *pMem /* OUT: Return data in this Mem structure. */
1.795 +){
1.796 + char *zData; /* Data from the btree layer */
1.797 + int available = 0; /* Number of bytes available on the local btree page */
1.798 + sqlite3 *db; /* Database connection */
1.799 + int rc = SQLITE_OK;
1.800 +
1.801 + db = sqlite3BtreeCursorDb(pCur);
1.802 + assert( sqlite3_mutex_held(db->mutex) );
1.803 + if( key ){
1.804 + zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
1.805 + }else{
1.806 + zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
1.807 + }
1.808 + assert( zData!=0 );
1.809 +
1.810 + if( offset+amt<=available && ((pMem->flags&MEM_Dyn)==0 || pMem->xDel) ){
1.811 + sqlite3VdbeMemRelease(pMem);
1.812 + pMem->z = &zData[offset];
1.813 + pMem->flags = MEM_Blob|MEM_Ephem;
1.814 + }else if( SQLITE_OK==(rc = sqlite3VdbeMemGrow(pMem, amt+2, 0)) ){
1.815 + pMem->flags = MEM_Blob|MEM_Dyn|MEM_Term;
1.816 + pMem->enc = 0;
1.817 + pMem->type = SQLITE_BLOB;
1.818 + if( key ){
1.819 + rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
1.820 + }else{
1.821 + rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
1.822 + }
1.823 + pMem->z[amt] = 0;
1.824 + pMem->z[amt+1] = 0;
1.825 + if( rc!=SQLITE_OK ){
1.826 + sqlite3VdbeMemRelease(pMem);
1.827 + }
1.828 + }
1.829 + pMem->n = amt;
1.830 +
1.831 + return rc;
1.832 +}
1.833 +
1.834 +#if 0
1.835 +/*
1.836 +** Perform various checks on the memory cell pMem. An assert() will
1.837 +** fail if pMem is internally inconsistent.
1.838 +*/
1.839 +void sqlite3VdbeMemSanity(Mem *pMem){
1.840 + int flags = pMem->flags;
1.841 + assert( flags!=0 ); /* Must define some type */
1.842 + if( flags & (MEM_Str|MEM_Blob) ){
1.843 + int x = flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short);
1.844 + assert( x!=0 ); /* Strings must define a string subtype */
1.845 + assert( (x & (x-1))==0 ); /* Only one string subtype can be defined */
1.846 + assert( pMem->z!=0 ); /* Strings must have a value */
1.847 + /* Mem.z points to Mem.zShort iff the subtype is MEM_Short */
1.848 + assert( (x & MEM_Short)==0 || pMem->z==pMem->zShort );
1.849 + assert( (x & MEM_Short)!=0 || pMem->z!=pMem->zShort );
1.850 + /* No destructor unless there is MEM_Dyn */
1.851 + assert( pMem->xDel==0 || (pMem->flags & MEM_Dyn)!=0 );
1.852 +
1.853 + if( (flags & MEM_Str) ){
1.854 + assert( pMem->enc==SQLITE_UTF8 ||
1.855 + pMem->enc==SQLITE_UTF16BE ||
1.856 + pMem->enc==SQLITE_UTF16LE
1.857 + );
1.858 + /* If the string is UTF-8 encoded and nul terminated, then pMem->n
1.859 + ** must be the length of the string. (Later:) If the database file
1.860 + ** has been corrupted, '\000' characters might have been inserted
1.861 + ** into the middle of the string. In that case, the strlen() might
1.862 + ** be less.
1.863 + */
1.864 + if( pMem->enc==SQLITE_UTF8 && (flags & MEM_Term) ){
1.865 + assert( strlen(pMem->z)<=pMem->n );
1.866 + assert( pMem->z[pMem->n]==0 );
1.867 + }
1.868 + }
1.869 + }else{
1.870 + /* Cannot define a string subtype for non-string objects */
1.871 + assert( (pMem->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short))==0 );
1.872 + assert( pMem->xDel==0 );
1.873 + }
1.874 + /* MEM_Null excludes all other types */
1.875 + assert( (pMem->flags&(MEM_Str|MEM_Int|MEM_Real|MEM_Blob))==0
1.876 + || (pMem->flags&MEM_Null)==0 );
1.877 + /* If the MEM is both real and integer, the values are equal */
1.878 + assert( (pMem->flags & (MEM_Int|MEM_Real))!=(MEM_Int|MEM_Real)
1.879 + || pMem->r==pMem->u.i );
1.880 +}
1.881 +#endif
1.882 +
1.883 +/* This function is only available internally, it is not part of the
1.884 +** external API. It works in a similar way to sqlite3_value_text(),
1.885 +** except the data returned is in the encoding specified by the second
1.886 +** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
1.887 +** SQLITE_UTF8.
1.888 +**
1.889 +** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
1.890 +** If that is the case, then the result must be aligned on an even byte
1.891 +** boundary.
1.892 +*/
1.893 +const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
1.894 + if( !pVal ) return 0;
1.895 +
1.896 + assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
1.897 + assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
1.898 +
1.899 + if( pVal->flags&MEM_Null ){
1.900 + return 0;
1.901 + }
1.902 + assert( (MEM_Blob>>3) == MEM_Str );
1.903 + pVal->flags |= (pVal->flags & MEM_Blob)>>3;
1.904 + expandBlob(pVal);
1.905 + if( pVal->flags&MEM_Str ){
1.906 + sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
1.907 + if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
1.908 + assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
1.909 + if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
1.910 + return 0;
1.911 + }
1.912 + }
1.913 + sqlite3VdbeMemNulTerminate(pVal);
1.914 + }else{
1.915 + assert( (pVal->flags&MEM_Blob)==0 );
1.916 + sqlite3VdbeMemStringify(pVal, enc);
1.917 + assert( 0==(1&(int)pVal->z) );
1.918 + }
1.919 + assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
1.920 + || pVal->db->mallocFailed );
1.921 + if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
1.922 + return pVal->z;
1.923 + }else{
1.924 + return 0;
1.925 + }
1.926 +}
1.927 +
1.928 +/*
1.929 +** Create a new sqlite3_value object.
1.930 +*/
1.931 +sqlite3_value *sqlite3ValueNew(sqlite3 *db){
1.932 + Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
1.933 + if( p ){
1.934 + p->flags = MEM_Null;
1.935 + p->type = SQLITE_NULL;
1.936 + p->db = db;
1.937 + }
1.938 + return p;
1.939 +}
1.940 +
1.941 +/*
1.942 +** Create a new sqlite3_value object, containing the value of pExpr.
1.943 +**
1.944 +** This only works for very simple expressions that consist of one constant
1.945 +** token (i.e. "5", "5.1", "'a string'"). If the expression can
1.946 +** be converted directly into a value, then the value is allocated and
1.947 +** a pointer written to *ppVal. The caller is responsible for deallocating
1.948 +** the value by passing it to sqlite3ValueFree() later on. If the expression
1.949 +** cannot be converted to a value, then *ppVal is set to NULL.
1.950 +*/
1.951 +int sqlite3ValueFromExpr(
1.952 + sqlite3 *db, /* The database connection */
1.953 + Expr *pExpr, /* The expression to evaluate */
1.954 + u8 enc, /* Encoding to use */
1.955 + u8 affinity, /* Affinity to use */
1.956 + sqlite3_value **ppVal /* Write the new value here */
1.957 +){
1.958 + int op;
1.959 + char *zVal = 0;
1.960 + sqlite3_value *pVal = 0;
1.961 +
1.962 + if( !pExpr ){
1.963 + *ppVal = 0;
1.964 + return SQLITE_OK;
1.965 + }
1.966 + op = pExpr->op;
1.967 +
1.968 + if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
1.969 + zVal = sqlite3DbStrNDup(db, (char*)pExpr->token.z, pExpr->token.n);
1.970 + pVal = sqlite3ValueNew(db);
1.971 + if( !zVal || !pVal ) goto no_mem;
1.972 + sqlite3Dequote(zVal);
1.973 + sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
1.974 + if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
1.975 + sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, enc);
1.976 + }else{
1.977 + sqlite3ValueApplyAffinity(pVal, affinity, enc);
1.978 + }
1.979 + }else if( op==TK_UMINUS ) {
1.980 + if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){
1.981 + pVal->u.i = -1 * pVal->u.i;
1.982 + pVal->r = -1.0 * pVal->r;
1.983 + }
1.984 + }
1.985 +#ifndef SQLITE_OMIT_BLOB_LITERAL
1.986 + else if( op==TK_BLOB ){
1.987 + int nVal;
1.988 + assert( pExpr->token.n>=3 );
1.989 + assert( pExpr->token.z[0]=='x' || pExpr->token.z[0]=='X' );
1.990 + assert( pExpr->token.z[1]=='\'' );
1.991 + assert( pExpr->token.z[pExpr->token.n-1]=='\'' );
1.992 + pVal = sqlite3ValueNew(db);
1.993 + nVal = pExpr->token.n - 3;
1.994 + zVal = (char*)pExpr->token.z + 2;
1.995 + sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
1.996 + 0, SQLITE_DYNAMIC);
1.997 + }
1.998 +#endif
1.999 +
1.1000 + *ppVal = pVal;
1.1001 + return SQLITE_OK;
1.1002 +
1.1003 +no_mem:
1.1004 + db->mallocFailed = 1;
1.1005 + sqlite3DbFree(db, zVal);
1.1006 + sqlite3ValueFree(pVal);
1.1007 + *ppVal = 0;
1.1008 + return SQLITE_NOMEM;
1.1009 +}
1.1010 +
1.1011 +/*
1.1012 +** Change the string value of an sqlite3_value object
1.1013 +*/
1.1014 +void sqlite3ValueSetStr(
1.1015 + sqlite3_value *v, /* Value to be set */
1.1016 + int n, /* Length of string z */
1.1017 + const void *z, /* Text of the new string */
1.1018 + u8 enc, /* Encoding to use */
1.1019 + void (*xDel)(void*) /* Destructor for the string */
1.1020 +){
1.1021 + if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
1.1022 +}
1.1023 +
1.1024 +/*
1.1025 +** Free an sqlite3_value object
1.1026 +*/
1.1027 +void sqlite3ValueFree(sqlite3_value *v){
1.1028 + if( !v ) return;
1.1029 + sqlite3VdbeMemRelease((Mem *)v);
1.1030 + sqlite3DbFree(((Mem*)v)->db, v);
1.1031 +}
1.1032 +
1.1033 +/*
1.1034 +** Return the number of bytes in the sqlite3_value object assuming
1.1035 +** that it uses the encoding "enc"
1.1036 +*/
1.1037 +int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
1.1038 + Mem *p = (Mem*)pVal;
1.1039 + if( (p->flags & MEM_Blob)!=0 || sqlite3ValueText(pVal, enc) ){
1.1040 + if( p->flags & MEM_Zero ){
1.1041 + return p->n+p->u.i;
1.1042 + }else{
1.1043 + return p->n;
1.1044 + }
1.1045 + }
1.1046 + return 0;
1.1047 +}