1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sqlite3api/SQLite/vdbemem.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1042 @@
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.123 2008/09/16 12:06:08 danielk1977 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 + memset(&ctx, 0, sizeof(ctx));
1.247 + ctx.s.flags = MEM_Null;
1.248 + ctx.s.db = pMem->db;
1.249 + ctx.pMem = pMem;
1.250 + ctx.pFunc = pFunc;
1.251 + pFunc->xFinalize(&ctx);
1.252 + assert( 0==(pMem->flags&MEM_Dyn) && !pMem->xDel );
1.253 + sqlite3DbFree(pMem->db, pMem->zMalloc);
1.254 + *pMem = ctx.s;
1.255 + rc = (ctx.isError?SQLITE_ERROR:SQLITE_OK);
1.256 + }
1.257 + return rc;
1.258 +}
1.259 +
1.260 +/*
1.261 +** If the memory cell contains a string value that must be freed by
1.262 +** invoking an external callback, free it now. Calling this function
1.263 +** does not free any Mem.zMalloc buffer.
1.264 +*/
1.265 +void sqlite3VdbeMemReleaseExternal(Mem *p){
1.266 + assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
1.267 + if( p->flags&MEM_Agg ){
1.268 + sqlite3VdbeMemFinalize(p, p->u.pDef);
1.269 + assert( (p->flags & MEM_Agg)==0 );
1.270 + sqlite3VdbeMemRelease(p);
1.271 + }else if( p->flags&MEM_Dyn && p->xDel ){
1.272 + p->xDel((void *)p->z);
1.273 + p->xDel = 0;
1.274 + }
1.275 +}
1.276 +
1.277 +/*
1.278 +** Release any memory held by the Mem. This may leave the Mem in an
1.279 +** inconsistent state, for example with (Mem.z==0) and
1.280 +** (Mem.type==SQLITE_TEXT).
1.281 +*/
1.282 +void sqlite3VdbeMemRelease(Mem *p){
1.283 + sqlite3VdbeMemReleaseExternal(p);
1.284 + sqlite3DbFree(p->db, p->zMalloc);
1.285 + p->z = 0;
1.286 + p->zMalloc = 0;
1.287 + p->xDel = 0;
1.288 +}
1.289 +
1.290 +/*
1.291 +** Convert a 64-bit IEEE double into a 64-bit signed integer.
1.292 +** If the double is too large, return 0x8000000000000000.
1.293 +**
1.294 +** Most systems appear to do this simply by assigning
1.295 +** variables and without the extra range tests. But
1.296 +** there are reports that windows throws an expection
1.297 +** if the floating point value is out of range. (See ticket #2880.)
1.298 +** Because we do not completely understand the problem, we will
1.299 +** take the conservative approach and always do range tests
1.300 +** before attempting the conversion.
1.301 +*/
1.302 +static i64 doubleToInt64(double r){
1.303 + /*
1.304 + ** Many compilers we encounter do not define constants for the
1.305 + ** minimum and maximum 64-bit integers, or they define them
1.306 + ** inconsistently. And many do not understand the "LL" notation.
1.307 + ** So we define our own static constants here using nothing
1.308 + ** larger than a 32-bit integer constant.
1.309 + */
1.310 + static const i64 maxInt = LARGEST_INT64;
1.311 + static const i64 minInt = SMALLEST_INT64;
1.312 +
1.313 + if( r<(double)minInt ){
1.314 + return minInt;
1.315 + }else if( r>(double)maxInt ){
1.316 + return minInt;
1.317 + }else{
1.318 + return (i64)r;
1.319 + }
1.320 +}
1.321 +
1.322 +/*
1.323 +** Return some kind of integer value which is the best we can do
1.324 +** at representing the value that *pMem describes as an integer.
1.325 +** If pMem is an integer, then the value is exact. If pMem is
1.326 +** a floating-point then the value returned is the integer part.
1.327 +** If pMem is a string or blob, then we make an attempt to convert
1.328 +** it into a integer and return that. If pMem is NULL, return 0.
1.329 +**
1.330 +** If pMem is a string, its encoding might be changed.
1.331 +*/
1.332 +i64 sqlite3VdbeIntValue(Mem *pMem){
1.333 + int flags;
1.334 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.335 + flags = pMem->flags;
1.336 + if( flags & MEM_Int ){
1.337 + return pMem->u.i;
1.338 + }else if( flags & MEM_Real ){
1.339 + return doubleToInt64(pMem->r);
1.340 + }else if( flags & (MEM_Str|MEM_Blob) ){
1.341 + i64 value;
1.342 + pMem->flags |= MEM_Str;
1.343 + if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8)
1.344 + || sqlite3VdbeMemNulTerminate(pMem) ){
1.345 + return 0;
1.346 + }
1.347 + assert( pMem->z );
1.348 + sqlite3Atoi64(pMem->z, &value);
1.349 + return value;
1.350 + }else{
1.351 + return 0;
1.352 + }
1.353 +}
1.354 +
1.355 +/*
1.356 +** Return the best representation of pMem that we can get into a
1.357 +** double. If pMem is already a double or an integer, return its
1.358 +** value. If it is a string or blob, try to convert it to a double.
1.359 +** If it is a NULL, return 0.0.
1.360 +*/
1.361 +double sqlite3VdbeRealValue(Mem *pMem){
1.362 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.363 + if( pMem->flags & MEM_Real ){
1.364 + return pMem->r;
1.365 + }else if( pMem->flags & MEM_Int ){
1.366 + return (double)pMem->u.i;
1.367 + }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
1.368 + double val = 0.0;
1.369 + pMem->flags |= MEM_Str;
1.370 + if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8)
1.371 + || sqlite3VdbeMemNulTerminate(pMem) ){
1.372 + return 0.0;
1.373 + }
1.374 + assert( pMem->z );
1.375 + sqlite3AtoF(pMem->z, &val);
1.376 + return val;
1.377 + }else{
1.378 + return 0.0;
1.379 + }
1.380 +}
1.381 +
1.382 +/*
1.383 +** The MEM structure is already a MEM_Real. Try to also make it a
1.384 +** MEM_Int if we can.
1.385 +*/
1.386 +void sqlite3VdbeIntegerAffinity(Mem *pMem){
1.387 + assert( pMem->flags & MEM_Real );
1.388 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.389 +
1.390 + pMem->u.i = doubleToInt64(pMem->r);
1.391 + if( pMem->r==(double)pMem->u.i ){
1.392 + pMem->flags |= MEM_Int;
1.393 + }
1.394 +}
1.395 +
1.396 +static void setTypeFlag(Mem *pMem, int f){
1.397 + MemSetTypeFlag(pMem, f);
1.398 +}
1.399 +
1.400 +/*
1.401 +** Convert pMem to type integer. Invalidate any prior representations.
1.402 +*/
1.403 +int sqlite3VdbeMemIntegerify(Mem *pMem){
1.404 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.405 + pMem->u.i = sqlite3VdbeIntValue(pMem);
1.406 + setTypeFlag(pMem, MEM_Int);
1.407 + return SQLITE_OK;
1.408 +}
1.409 +
1.410 +/*
1.411 +** Convert pMem so that it is of type MEM_Real.
1.412 +** Invalidate any prior representations.
1.413 +*/
1.414 +int sqlite3VdbeMemRealify(Mem *pMem){
1.415 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.416 + pMem->r = sqlite3VdbeRealValue(pMem);
1.417 + setTypeFlag(pMem, MEM_Real);
1.418 + return SQLITE_OK;
1.419 +}
1.420 +
1.421 +/*
1.422 +** Convert pMem so that it has types MEM_Real or MEM_Int or both.
1.423 +** Invalidate any prior representations.
1.424 +*/
1.425 +int sqlite3VdbeMemNumerify(Mem *pMem){
1.426 + double r1, r2;
1.427 + i64 i;
1.428 + assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 );
1.429 + assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
1.430 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.431 + r1 = sqlite3VdbeRealValue(pMem);
1.432 + i = doubleToInt64(r1);
1.433 + r2 = (double)i;
1.434 + if( r1==r2 ){
1.435 + sqlite3VdbeMemIntegerify(pMem);
1.436 + }else{
1.437 + pMem->r = r1;
1.438 + setTypeFlag(pMem, MEM_Real);
1.439 + }
1.440 + return SQLITE_OK;
1.441 +}
1.442 +
1.443 +/*
1.444 +** Delete any previous value and set the value stored in *pMem to NULL.
1.445 +*/
1.446 +void sqlite3VdbeMemSetNull(Mem *pMem){
1.447 + setTypeFlag(pMem, MEM_Null);
1.448 + pMem->type = SQLITE_NULL;
1.449 +}
1.450 +
1.451 +/*
1.452 +** Delete any previous value and set the value to be a BLOB of length
1.453 +** n containing all zeros.
1.454 +*/
1.455 +void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
1.456 + sqlite3VdbeMemRelease(pMem);
1.457 + setTypeFlag(pMem, MEM_Blob);
1.458 + pMem->flags = MEM_Blob|MEM_Zero;
1.459 + pMem->type = SQLITE_BLOB;
1.460 + pMem->n = 0;
1.461 + if( n<0 ) n = 0;
1.462 + pMem->u.i = n;
1.463 + pMem->enc = SQLITE_UTF8;
1.464 +}
1.465 +
1.466 +/*
1.467 +** Delete any previous value and set the value stored in *pMem to val,
1.468 +** manifest type INTEGER.
1.469 +*/
1.470 +void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
1.471 + sqlite3VdbeMemRelease(pMem);
1.472 + pMem->u.i = val;
1.473 + pMem->flags = MEM_Int;
1.474 + pMem->type = SQLITE_INTEGER;
1.475 +}
1.476 +
1.477 +/*
1.478 +** Delete any previous value and set the value stored in *pMem to val,
1.479 +** manifest type REAL.
1.480 +*/
1.481 +void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
1.482 + if( sqlite3IsNaN(val) ){
1.483 + sqlite3VdbeMemSetNull(pMem);
1.484 + }else{
1.485 + sqlite3VdbeMemRelease(pMem);
1.486 + pMem->r = val;
1.487 + pMem->flags = MEM_Real;
1.488 + pMem->type = SQLITE_FLOAT;
1.489 + }
1.490 +}
1.491 +
1.492 +/*
1.493 +** Return true if the Mem object contains a TEXT or BLOB that is
1.494 +** too large - whose size exceeds SQLITE_MAX_LENGTH.
1.495 +*/
1.496 +int sqlite3VdbeMemTooBig(Mem *p){
1.497 + assert( p->db!=0 );
1.498 + if( p->flags & (MEM_Str|MEM_Blob) ){
1.499 + int n = p->n;
1.500 + if( p->flags & MEM_Zero ){
1.501 + n += p->u.i;
1.502 + }
1.503 + return n>p->db->aLimit[SQLITE_LIMIT_LENGTH];
1.504 + }
1.505 + return 0;
1.506 +}
1.507 +
1.508 +/*
1.509 +** Size of struct Mem not including the Mem.zMalloc member.
1.510 +*/
1.511 +#define MEMCELLSIZE (size_t)(&(((Mem *)0)->zMalloc))
1.512 +
1.513 +/*
1.514 +** Make an shallow copy of pFrom into pTo. Prior contents of
1.515 +** pTo are freed. The pFrom->z field is not duplicated. If
1.516 +** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
1.517 +** and flags gets srcType (either MEM_Ephem or MEM_Static).
1.518 +*/
1.519 +void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
1.520 + sqlite3VdbeMemReleaseExternal(pTo);
1.521 + memcpy(pTo, pFrom, MEMCELLSIZE);
1.522 + pTo->xDel = 0;
1.523 + if( (pFrom->flags&MEM_Dyn)!=0 || pFrom->z==pFrom->zMalloc ){
1.524 + pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
1.525 + assert( srcType==MEM_Ephem || srcType==MEM_Static );
1.526 + pTo->flags |= srcType;
1.527 + }
1.528 +}
1.529 +
1.530 +/*
1.531 +** Make a full copy of pFrom into pTo. Prior contents of pTo are
1.532 +** freed before the copy is made.
1.533 +*/
1.534 +int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
1.535 + int rc = SQLITE_OK;
1.536 +
1.537 + sqlite3VdbeMemReleaseExternal(pTo);
1.538 + memcpy(pTo, pFrom, MEMCELLSIZE);
1.539 + pTo->flags &= ~MEM_Dyn;
1.540 +
1.541 + if( pTo->flags&(MEM_Str|MEM_Blob) ){
1.542 + if( 0==(pFrom->flags&MEM_Static) ){
1.543 + pTo->flags |= MEM_Ephem;
1.544 + rc = sqlite3VdbeMemMakeWriteable(pTo);
1.545 + }
1.546 + }
1.547 +
1.548 + return rc;
1.549 +}
1.550 +
1.551 +/*
1.552 +** Transfer the contents of pFrom to pTo. Any existing value in pTo is
1.553 +** freed. If pFrom contains ephemeral data, a copy is made.
1.554 +**
1.555 +** pFrom contains an SQL NULL when this routine returns.
1.556 +*/
1.557 +void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
1.558 + assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
1.559 + assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
1.560 + assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
1.561 +
1.562 + sqlite3VdbeMemRelease(pTo);
1.563 + memcpy(pTo, pFrom, sizeof(Mem));
1.564 + pFrom->flags = MEM_Null;
1.565 + pFrom->xDel = 0;
1.566 + pFrom->zMalloc = 0;
1.567 +}
1.568 +
1.569 +/*
1.570 +** Change the value of a Mem to be a string or a BLOB.
1.571 +**
1.572 +** The memory management strategy depends on the value of the xDel
1.573 +** parameter. If the value passed is SQLITE_TRANSIENT, then the
1.574 +** string is copied into a (possibly existing) buffer managed by the
1.575 +** Mem structure. Otherwise, any existing buffer is freed and the
1.576 +** pointer copied.
1.577 +*/
1.578 +int sqlite3VdbeMemSetStr(
1.579 + Mem *pMem, /* Memory cell to set to string value */
1.580 + const char *z, /* String pointer */
1.581 + int n, /* Bytes in string, or negative */
1.582 + u8 enc, /* Encoding of z. 0 for BLOBs */
1.583 + void (*xDel)(void*) /* Destructor function */
1.584 +){
1.585 + int nByte = n; /* New value for pMem->n */
1.586 + int iLimit; /* Maximum allowed string or blob size */
1.587 + int flags = 0; /* New value for pMem->flags */
1.588 +
1.589 + assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
1.590 +
1.591 + /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
1.592 + if( !z ){
1.593 + sqlite3VdbeMemSetNull(pMem);
1.594 + return SQLITE_OK;
1.595 + }
1.596 +
1.597 + if( pMem->db ){
1.598 + iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH];
1.599 + }else{
1.600 + iLimit = SQLITE_MAX_LENGTH;
1.601 + }
1.602 + flags = (enc==0?MEM_Blob:MEM_Str);
1.603 + if( nByte<0 ){
1.604 + assert( enc!=0 );
1.605 + if( enc==SQLITE_UTF8 ){
1.606 + for(nByte=0; nByte<=iLimit && z[nByte]; nByte++){}
1.607 + }else{
1.608 + for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
1.609 + }
1.610 + flags |= MEM_Term;
1.611 + }
1.612 + if( nByte>iLimit ){
1.613 + return SQLITE_TOOBIG;
1.614 + }
1.615 +
1.616 + /* The following block sets the new values of Mem.z and Mem.xDel. It
1.617 + ** also sets a flag in local variable "flags" to indicate the memory
1.618 + ** management (one of MEM_Dyn or MEM_Static).
1.619 + */
1.620 + if( xDel==SQLITE_TRANSIENT ){
1.621 + int nAlloc = nByte;
1.622 + if( flags&MEM_Term ){
1.623 + nAlloc += (enc==SQLITE_UTF8?1:2);
1.624 + }
1.625 + if( sqlite3VdbeMemGrow(pMem, nAlloc, 0) ){
1.626 + return SQLITE_NOMEM;
1.627 + }
1.628 + memcpy(pMem->z, z, nAlloc);
1.629 + }else if( xDel==SQLITE_DYNAMIC ){
1.630 + sqlite3VdbeMemRelease(pMem);
1.631 + pMem->zMalloc = pMem->z = (char *)z;
1.632 + pMem->xDel = 0;
1.633 + }else{
1.634 + sqlite3VdbeMemRelease(pMem);
1.635 + pMem->z = (char *)z;
1.636 + pMem->xDel = xDel;
1.637 + flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn);
1.638 + }
1.639 +
1.640 + pMem->n = nByte;
1.641 + pMem->flags = flags;
1.642 + pMem->enc = (enc==0 ? SQLITE_UTF8 : enc);
1.643 + pMem->type = (enc==0 ? SQLITE_BLOB : SQLITE_TEXT);
1.644 +
1.645 +#ifndef SQLITE_OMIT_UTF16
1.646 + if( pMem->enc!=SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
1.647 + return SQLITE_NOMEM;
1.648 + }
1.649 +#endif
1.650 +
1.651 + return SQLITE_OK;
1.652 +}
1.653 +
1.654 +/*
1.655 +** Compare the values contained by the two memory cells, returning
1.656 +** negative, zero or positive if pMem1 is less than, equal to, or greater
1.657 +** than pMem2. Sorting order is NULL's first, followed by numbers (integers
1.658 +** and reals) sorted numerically, followed by text ordered by the collating
1.659 +** sequence pColl and finally blob's ordered by memcmp().
1.660 +**
1.661 +** Two NULL values are considered equal by this function.
1.662 +*/
1.663 +int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
1.664 + int rc;
1.665 + int f1, f2;
1.666 + int combined_flags;
1.667 +
1.668 + /* Interchange pMem1 and pMem2 if the collating sequence specifies
1.669 + ** DESC order.
1.670 + */
1.671 + f1 = pMem1->flags;
1.672 + f2 = pMem2->flags;
1.673 + combined_flags = f1|f2;
1.674 +
1.675 + /* If one value is NULL, it is less than the other. If both values
1.676 + ** are NULL, return 0.
1.677 + */
1.678 + if( combined_flags&MEM_Null ){
1.679 + return (f2&MEM_Null) - (f1&MEM_Null);
1.680 + }
1.681 +
1.682 + /* If one value is a number and the other is not, the number is less.
1.683 + ** If both are numbers, compare as reals if one is a real, or as integers
1.684 + ** if both values are integers.
1.685 + */
1.686 + if( combined_flags&(MEM_Int|MEM_Real) ){
1.687 + if( !(f1&(MEM_Int|MEM_Real)) ){
1.688 + return 1;
1.689 + }
1.690 + if( !(f2&(MEM_Int|MEM_Real)) ){
1.691 + return -1;
1.692 + }
1.693 + if( (f1 & f2 & MEM_Int)==0 ){
1.694 + double r1, r2;
1.695 + if( (f1&MEM_Real)==0 ){
1.696 + r1 = pMem1->u.i;
1.697 + }else{
1.698 + r1 = pMem1->r;
1.699 + }
1.700 + if( (f2&MEM_Real)==0 ){
1.701 + r2 = pMem2->u.i;
1.702 + }else{
1.703 + r2 = pMem2->r;
1.704 + }
1.705 + if( r1<r2 ) return -1;
1.706 + if( r1>r2 ) return 1;
1.707 + return 0;
1.708 + }else{
1.709 + assert( f1&MEM_Int );
1.710 + assert( f2&MEM_Int );
1.711 + if( pMem1->u.i < pMem2->u.i ) return -1;
1.712 + if( pMem1->u.i > pMem2->u.i ) return 1;
1.713 + return 0;
1.714 + }
1.715 + }
1.716 +
1.717 + /* If one value is a string and the other is a blob, the string is less.
1.718 + ** If both are strings, compare using the collating functions.
1.719 + */
1.720 + if( combined_flags&MEM_Str ){
1.721 + if( (f1 & MEM_Str)==0 ){
1.722 + return 1;
1.723 + }
1.724 + if( (f2 & MEM_Str)==0 ){
1.725 + return -1;
1.726 + }
1.727 +
1.728 + assert( pMem1->enc==pMem2->enc );
1.729 + assert( pMem1->enc==SQLITE_UTF8 ||
1.730 + pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
1.731 +
1.732 + /* The collation sequence must be defined at this point, even if
1.733 + ** the user deletes the collation sequence after the vdbe program is
1.734 + ** compiled (this was not always the case).
1.735 + */
1.736 + assert( !pColl || pColl->xCmp );
1.737 +
1.738 + if( pColl ){
1.739 + if( pMem1->enc==pColl->enc ){
1.740 + /* The strings are already in the correct encoding. Call the
1.741 + ** comparison function directly */
1.742 + return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
1.743 + }else{
1.744 + const void *v1, *v2;
1.745 + int n1, n2;
1.746 + Mem c1;
1.747 + Mem c2;
1.748 + memset(&c1, 0, sizeof(c1));
1.749 + memset(&c2, 0, sizeof(c2));
1.750 + sqlite3VdbeMemShallowCopy(&c1, pMem1, MEM_Ephem);
1.751 + sqlite3VdbeMemShallowCopy(&c2, pMem2, MEM_Ephem);
1.752 + v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc);
1.753 + n1 = v1==0 ? 0 : c1.n;
1.754 + v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
1.755 + n2 = v2==0 ? 0 : c2.n;
1.756 + rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2);
1.757 + sqlite3VdbeMemRelease(&c1);
1.758 + sqlite3VdbeMemRelease(&c2);
1.759 + return rc;
1.760 + }
1.761 + }
1.762 + /* If a NULL pointer was passed as the collate function, fall through
1.763 + ** to the blob case and use memcmp(). */
1.764 + }
1.765 +
1.766 + /* Both values must be blobs. Compare using memcmp(). */
1.767 + rc = memcmp(pMem1->z, pMem2->z, (pMem1->n>pMem2->n)?pMem2->n:pMem1->n);
1.768 + if( rc==0 ){
1.769 + rc = pMem1->n - pMem2->n;
1.770 + }
1.771 + return rc;
1.772 +}
1.773 +
1.774 +/*
1.775 +** Move data out of a btree key or data field and into a Mem structure.
1.776 +** The data or key is taken from the entry that pCur is currently pointing
1.777 +** to. offset and amt determine what portion of the data or key to retrieve.
1.778 +** key is true to get the key or false to get data. The result is written
1.779 +** into the pMem element.
1.780 +**
1.781 +** The pMem structure is assumed to be uninitialized. Any prior content
1.782 +** is overwritten without being freed.
1.783 +**
1.784 +** If this routine fails for any reason (malloc returns NULL or unable
1.785 +** to read from the disk) then the pMem is left in an inconsistent state.
1.786 +*/
1.787 +int sqlite3VdbeMemFromBtree(
1.788 + BtCursor *pCur, /* Cursor pointing at record to retrieve. */
1.789 + int offset, /* Offset from the start of data to return bytes from. */
1.790 + int amt, /* Number of bytes to return. */
1.791 + int key, /* If true, retrieve from the btree key, not data. */
1.792 + Mem *pMem /* OUT: Return data in this Mem structure. */
1.793 +){
1.794 + char *zData; /* Data from the btree layer */
1.795 + int available = 0; /* Number of bytes available on the local btree page */
1.796 + sqlite3 *db; /* Database connection */
1.797 + int rc = SQLITE_OK;
1.798 +
1.799 + db = sqlite3BtreeCursorDb(pCur);
1.800 + assert( sqlite3_mutex_held(db->mutex) );
1.801 + if( key ){
1.802 + zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
1.803 + }else{
1.804 + zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
1.805 + }
1.806 + assert( zData!=0 );
1.807 +
1.808 + if( offset+amt<=available && ((pMem->flags&MEM_Dyn)==0 || pMem->xDel) ){
1.809 + sqlite3VdbeMemRelease(pMem);
1.810 + pMem->z = &zData[offset];
1.811 + pMem->flags = MEM_Blob|MEM_Ephem;
1.812 + }else if( SQLITE_OK==(rc = sqlite3VdbeMemGrow(pMem, amt+2, 0)) ){
1.813 + pMem->flags = MEM_Blob|MEM_Dyn|MEM_Term;
1.814 + pMem->enc = 0;
1.815 + pMem->type = SQLITE_BLOB;
1.816 + if( key ){
1.817 + rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
1.818 + }else{
1.819 + rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
1.820 + }
1.821 + pMem->z[amt] = 0;
1.822 + pMem->z[amt+1] = 0;
1.823 + if( rc!=SQLITE_OK ){
1.824 + sqlite3VdbeMemRelease(pMem);
1.825 + }
1.826 + }
1.827 + pMem->n = amt;
1.828 +
1.829 + return rc;
1.830 +}
1.831 +
1.832 +#if 0
1.833 +/*
1.834 +** Perform various checks on the memory cell pMem. An assert() will
1.835 +** fail if pMem is internally inconsistent.
1.836 +*/
1.837 +void sqlite3VdbeMemSanity(Mem *pMem){
1.838 + int flags = pMem->flags;
1.839 + assert( flags!=0 ); /* Must define some type */
1.840 + if( flags & (MEM_Str|MEM_Blob) ){
1.841 + int x = flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short);
1.842 + assert( x!=0 ); /* Strings must define a string subtype */
1.843 + assert( (x & (x-1))==0 ); /* Only one string subtype can be defined */
1.844 + assert( pMem->z!=0 ); /* Strings must have a value */
1.845 + /* Mem.z points to Mem.zShort iff the subtype is MEM_Short */
1.846 + assert( (x & MEM_Short)==0 || pMem->z==pMem->zShort );
1.847 + assert( (x & MEM_Short)!=0 || pMem->z!=pMem->zShort );
1.848 + /* No destructor unless there is MEM_Dyn */
1.849 + assert( pMem->xDel==0 || (pMem->flags & MEM_Dyn)!=0 );
1.850 +
1.851 + if( (flags & MEM_Str) ){
1.852 + assert( pMem->enc==SQLITE_UTF8 ||
1.853 + pMem->enc==SQLITE_UTF16BE ||
1.854 + pMem->enc==SQLITE_UTF16LE
1.855 + );
1.856 + /* If the string is UTF-8 encoded and nul terminated, then pMem->n
1.857 + ** must be the length of the string. (Later:) If the database file
1.858 + ** has been corrupted, '\000' characters might have been inserted
1.859 + ** into the middle of the string. In that case, the strlen() might
1.860 + ** be less.
1.861 + */
1.862 + if( pMem->enc==SQLITE_UTF8 && (flags & MEM_Term) ){
1.863 + assert( strlen(pMem->z)<=pMem->n );
1.864 + assert( pMem->z[pMem->n]==0 );
1.865 + }
1.866 + }
1.867 + }else{
1.868 + /* Cannot define a string subtype for non-string objects */
1.869 + assert( (pMem->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short))==0 );
1.870 + assert( pMem->xDel==0 );
1.871 + }
1.872 + /* MEM_Null excludes all other types */
1.873 + assert( (pMem->flags&(MEM_Str|MEM_Int|MEM_Real|MEM_Blob))==0
1.874 + || (pMem->flags&MEM_Null)==0 );
1.875 + /* If the MEM is both real and integer, the values are equal */
1.876 + assert( (pMem->flags & (MEM_Int|MEM_Real))!=(MEM_Int|MEM_Real)
1.877 + || pMem->r==pMem->u.i );
1.878 +}
1.879 +#endif
1.880 +
1.881 +/* This function is only available internally, it is not part of the
1.882 +** external API. It works in a similar way to sqlite3_value_text(),
1.883 +** except the data returned is in the encoding specified by the second
1.884 +** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
1.885 +** SQLITE_UTF8.
1.886 +**
1.887 +** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
1.888 +** If that is the case, then the result must be aligned on an even byte
1.889 +** boundary.
1.890 +*/
1.891 +const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
1.892 + if( !pVal ) return 0;
1.893 +
1.894 + assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
1.895 + assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
1.896 +
1.897 + if( pVal->flags&MEM_Null ){
1.898 + return 0;
1.899 + }
1.900 + assert( (MEM_Blob>>3) == MEM_Str );
1.901 + pVal->flags |= (pVal->flags & MEM_Blob)>>3;
1.902 + expandBlob(pVal);
1.903 + if( pVal->flags&MEM_Str ){
1.904 + sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
1.905 + if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
1.906 + assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
1.907 + if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
1.908 + return 0;
1.909 + }
1.910 + }
1.911 + sqlite3VdbeMemNulTerminate(pVal);
1.912 + }else{
1.913 + assert( (pVal->flags&MEM_Blob)==0 );
1.914 + sqlite3VdbeMemStringify(pVal, enc);
1.915 + assert( 0==(1&(int)pVal->z) );
1.916 + }
1.917 + assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
1.918 + || pVal->db->mallocFailed );
1.919 + if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
1.920 + return pVal->z;
1.921 + }else{
1.922 + return 0;
1.923 + }
1.924 +}
1.925 +
1.926 +/*
1.927 +** Create a new sqlite3_value object.
1.928 +*/
1.929 +sqlite3_value *sqlite3ValueNew(sqlite3 *db){
1.930 + Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
1.931 + if( p ){
1.932 + p->flags = MEM_Null;
1.933 + p->type = SQLITE_NULL;
1.934 + p->db = db;
1.935 + }
1.936 + return p;
1.937 +}
1.938 +
1.939 +/*
1.940 +** Create a new sqlite3_value object, containing the value of pExpr.
1.941 +**
1.942 +** This only works for very simple expressions that consist of one constant
1.943 +** token (i.e. "5", "5.1", "'a string'"). If the expression can
1.944 +** be converted directly into a value, then the value is allocated and
1.945 +** a pointer written to *ppVal. The caller is responsible for deallocating
1.946 +** the value by passing it to sqlite3ValueFree() later on. If the expression
1.947 +** cannot be converted to a value, then *ppVal is set to NULL.
1.948 +*/
1.949 +int sqlite3ValueFromExpr(
1.950 + sqlite3 *db, /* The database connection */
1.951 + Expr *pExpr, /* The expression to evaluate */
1.952 + u8 enc, /* Encoding to use */
1.953 + u8 affinity, /* Affinity to use */
1.954 + sqlite3_value **ppVal /* Write the new value here */
1.955 +){
1.956 + int op;
1.957 + char *zVal = 0;
1.958 + sqlite3_value *pVal = 0;
1.959 +
1.960 + if( !pExpr ){
1.961 + *ppVal = 0;
1.962 + return SQLITE_OK;
1.963 + }
1.964 + op = pExpr->op;
1.965 +
1.966 + if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
1.967 + zVal = sqlite3DbStrNDup(db, (char*)pExpr->token.z, pExpr->token.n);
1.968 + pVal = sqlite3ValueNew(db);
1.969 + if( !zVal || !pVal ) goto no_mem;
1.970 + sqlite3Dequote(zVal);
1.971 + sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
1.972 + if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
1.973 + sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, enc);
1.974 + }else{
1.975 + sqlite3ValueApplyAffinity(pVal, affinity, enc);
1.976 + }
1.977 + }else if( op==TK_UMINUS ) {
1.978 + if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){
1.979 + pVal->u.i = -1 * pVal->u.i;
1.980 + pVal->r = -1.0 * pVal->r;
1.981 + }
1.982 + }
1.983 +#ifndef SQLITE_OMIT_BLOB_LITERAL
1.984 + else if( op==TK_BLOB ){
1.985 + int nVal;
1.986 + assert( pExpr->token.n>=3 );
1.987 + assert( pExpr->token.z[0]=='x' || pExpr->token.z[0]=='X' );
1.988 + assert( pExpr->token.z[1]=='\'' );
1.989 + assert( pExpr->token.z[pExpr->token.n-1]=='\'' );
1.990 + pVal = sqlite3ValueNew(db);
1.991 + nVal = pExpr->token.n - 3;
1.992 + zVal = (char*)pExpr->token.z + 2;
1.993 + sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
1.994 + 0, SQLITE_DYNAMIC);
1.995 + }
1.996 +#endif
1.997 +
1.998 + *ppVal = pVal;
1.999 + return SQLITE_OK;
1.1000 +
1.1001 +no_mem:
1.1002 + db->mallocFailed = 1;
1.1003 + sqlite3DbFree(db, zVal);
1.1004 + sqlite3ValueFree(pVal);
1.1005 + *ppVal = 0;
1.1006 + return SQLITE_NOMEM;
1.1007 +}
1.1008 +
1.1009 +/*
1.1010 +** Change the string value of an sqlite3_value object
1.1011 +*/
1.1012 +void sqlite3ValueSetStr(
1.1013 + sqlite3_value *v, /* Value to be set */
1.1014 + int n, /* Length of string z */
1.1015 + const void *z, /* Text of the new string */
1.1016 + u8 enc, /* Encoding to use */
1.1017 + void (*xDel)(void*) /* Destructor for the string */
1.1018 +){
1.1019 + if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
1.1020 +}
1.1021 +
1.1022 +/*
1.1023 +** Free an sqlite3_value object
1.1024 +*/
1.1025 +void sqlite3ValueFree(sqlite3_value *v){
1.1026 + if( !v ) return;
1.1027 + sqlite3VdbeMemRelease((Mem *)v);
1.1028 + sqlite3DbFree(((Mem*)v)->db, v);
1.1029 +}
1.1030 +
1.1031 +/*
1.1032 +** Return the number of bytes in the sqlite3_value object assuming
1.1033 +** that it uses the encoding "enc"
1.1034 +*/
1.1035 +int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
1.1036 + Mem *p = (Mem*)pVal;
1.1037 + if( (p->flags & MEM_Blob)!=0 || sqlite3ValueText(pVal, enc) ){
1.1038 + if( p->flags & MEM_Zero ){
1.1039 + return p->n+p->u.i;
1.1040 + }else{
1.1041 + return p->n;
1.1042 + }
1.1043 + }
1.1044 + return 0;
1.1045 +}