vdbemem.c.svn-base
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:31k
源码类别:

数据库系统

开发平台:

C/C++

  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 <ctype.h>
  20. #include "vdbeInt.h"
  21. /*
  22. ** Call sqlite3VdbeMemExpandBlob() on the supplied value (type Mem*)
  23. ** P if required.
  24. */
  25. #define expandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
  26. /*
  27. ** If pMem is an object with a valid string representation, this routine
  28. ** ensures the internal encoding for the string representation is
  29. ** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE.
  30. **
  31. ** If pMem is not a string object, or the encoding of the string
  32. ** representation is already stored using the requested encoding, then this
  33. ** routine is a no-op.
  34. **
  35. ** SQLITE_OK is returned if the conversion is successful (or not required).
  36. ** SQLITE_NOMEM may be returned if a malloc() fails during conversion
  37. ** between formats.
  38. */
  39. int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
  40.   int rc;
  41.   if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
  42.     return SQLITE_OK;
  43.   }
  44.   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  45. #ifdef SQLITE_OMIT_UTF16
  46.   return SQLITE_ERROR;
  47. #else
  48.   /* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
  49.   ** then the encoding of the value may not have changed.
  50.   */
  51.   rc = sqlite3VdbeMemTranslate(pMem, desiredEnc);
  52.   assert(rc==SQLITE_OK    || rc==SQLITE_NOMEM);
  53.   assert(rc==SQLITE_OK    || pMem->enc!=desiredEnc);
  54.   assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
  55.   return rc;
  56. #endif
  57. }
  58. /*
  59. ** Make sure pMem->z points to a writable allocation of at least 
  60. ** n bytes.
  61. **
  62. ** If the memory cell currently contains string or blob data
  63. ** and the third argument passed to this function is true, the 
  64. ** current content of the cell is preserved. Otherwise, it may
  65. ** be discarded.  
  66. **
  67. ** This function sets the MEM_Dyn flag and clears any xDel callback.
  68. ** It also clears MEM_Ephem and MEM_Static. If the preserve flag is 
  69. ** not set, Mem.n is zeroed.
  70. */
  71. int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve){
  72.   assert( 1 >=
  73.     ((pMem->zMalloc && pMem->zMalloc==pMem->z) ? 1 : 0) +
  74.     (((pMem->flags&MEM_Dyn)&&pMem->xDel) ? 1 : 0) + 
  75.     ((pMem->flags&MEM_Ephem) ? 1 : 0) + 
  76.     ((pMem->flags&MEM_Static) ? 1 : 0)
  77.   );
  78.   if( !pMem->zMalloc || sqlite3MallocSize(pMem->zMalloc)<n ){
  79.     n = (n>32?n:32);
  80.     if( preserve && pMem->z==pMem->zMalloc ){
  81.       pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
  82.       if( !pMem->z ){
  83.         pMem->flags = MEM_Null;
  84.       }
  85.       preserve = 0;
  86.     }else{
  87.       sqlite3_free(pMem->zMalloc);
  88.       pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
  89.     }
  90.   }
  91.   if( preserve && pMem->z && pMem->zMalloc && pMem->z!=pMem->zMalloc ){
  92.     memcpy(pMem->zMalloc, pMem->z, pMem->n);
  93.   }
  94.   if( pMem->flags&MEM_Dyn && pMem->xDel ){
  95.     pMem->xDel((void *)(pMem->z));
  96.   }
  97.   pMem->z = pMem->zMalloc;
  98.   pMem->flags &= ~(MEM_Ephem|MEM_Static);
  99.   pMem->xDel = 0;
  100.   return (pMem->z ? SQLITE_OK : SQLITE_NOMEM);
  101. }
  102. /*
  103. ** Make the given Mem object MEM_Dyn.
  104. **
  105. ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
  106. */
  107. int sqlite3VdbeMemDynamicify(Mem *pMem){
  108.   int f;
  109.   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  110.   expandBlob(pMem);
  111.   f = pMem->flags;
  112.   if( (f&(MEM_Str|MEM_Blob)) && pMem->z!=pMem->zMalloc ){
  113.     if( sqlite3VdbeMemGrow(pMem, pMem->n + 2, 1) ){
  114.       return SQLITE_NOMEM;
  115.     }
  116.     pMem->z[pMem->n] = 0;
  117.     pMem->z[pMem->n+1] = 0;
  118.     pMem->flags |= MEM_Term;
  119.   }
  120.   return SQLITE_OK;
  121. }
  122. /*
  123. ** If the given Mem* has a zero-filled tail, turn it into an ordinary
  124. ** blob stored in dynamically allocated space.
  125. */
  126. #ifndef SQLITE_OMIT_INCRBLOB
  127. int sqlite3VdbeMemExpandBlob(Mem *pMem){
  128.   if( pMem->flags & MEM_Zero ){
  129.     int nByte;
  130.     assert( pMem->flags&MEM_Blob );
  131.     assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  132.     /* Set nByte to the number of bytes required to store the expanded blob. */
  133.     nByte = pMem->n + pMem->u.i;
  134.     if( nByte<=0 ){
  135.       nByte = 1;
  136.     }
  137.     if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
  138.       return SQLITE_NOMEM;
  139.     }
  140.     memset(&pMem->z[pMem->n], 0, pMem->u.i);
  141.     pMem->n += pMem->u.i;
  142.     pMem->flags &= ~(MEM_Zero|MEM_Term);
  143.   }
  144.   return SQLITE_OK;
  145. }
  146. #endif
  147. /*
  148. ** Make the given Mem object either MEM_Short or MEM_Dyn so that bytes
  149. ** of the Mem.z[] array can be modified.
  150. **
  151. ** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
  152. */
  153. int sqlite3VdbeMemMakeWriteable(Mem *pMem){
  154.   return sqlite3VdbeMemDynamicify(pMem);
  155. }
  156. /*
  157. ** Make sure the given Mem is u0000 terminated.
  158. */
  159. int sqlite3VdbeMemNulTerminate(Mem *pMem){
  160.   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  161.   if( (pMem->flags & MEM_Term)!=0 || (pMem->flags & MEM_Str)==0 ){
  162.     return SQLITE_OK;   /* Nothing to do */
  163.   }
  164.   if( sqlite3VdbeMemGrow(pMem, pMem->n+2, 1) ){
  165.     return SQLITE_NOMEM;
  166.   }
  167.   pMem->z[pMem->n] = 0;
  168.   pMem->z[pMem->n+1] = 0;
  169.   pMem->flags |= MEM_Term;
  170.   return SQLITE_OK;
  171. }
  172. /*
  173. ** Add MEM_Str to the set of representations for the given Mem.  Numbers
  174. ** are converted using sqlite3_snprintf().  Converting a BLOB to a string
  175. ** is a no-op.
  176. **
  177. ** Existing representations MEM_Int and MEM_Real are *not* invalidated.
  178. **
  179. ** A MEM_Null value will never be passed to this function. This function is
  180. ** used for converting values to text for returning to the user (i.e. via
  181. ** sqlite3_value_text()), or for ensuring that values to be used as btree
  182. ** keys are strings. In the former case a NULL pointer is returned the
  183. ** user and the later is an internal programming error.
  184. */
  185. int sqlite3VdbeMemStringify(Mem *pMem, int enc){
  186.   int rc = SQLITE_OK;
  187.   int fg = pMem->flags;
  188.   const int nByte = 32;
  189.   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  190.   assert( !(fg&MEM_Zero) );
  191.   assert( !(fg&(MEM_Str|MEM_Blob)) );
  192.   assert( fg&(MEM_Int|MEM_Real) );
  193.   if( sqlite3VdbeMemGrow(pMem, nByte, 0) ){
  194.     return SQLITE_NOMEM;
  195.   }
  196.   /* For a Real or Integer, use sqlite3_mprintf() to produce the UTF-8
  197.   ** string representation of the value. Then, if the required encoding
  198.   ** is UTF-16le or UTF-16be do a translation.
  199.   ** 
  200.   ** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16.
  201.   */
  202.   if( fg & MEM_Int ){
  203.     sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
  204.   }else{
  205.     assert( fg & MEM_Real );
  206.     sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->r);
  207.   }
  208.   pMem->n = strlen(pMem->z);
  209.   pMem->enc = SQLITE_UTF8;
  210.   pMem->flags |= MEM_Str|MEM_Term;
  211.   sqlite3VdbeChangeEncoding(pMem, enc);
  212.   return rc;
  213. }
  214. /*
  215. ** Memory cell pMem contains the context of an aggregate function.
  216. ** This routine calls the finalize method for that function.  The
  217. ** result of the aggregate is stored back into pMem.
  218. **
  219. ** Return SQLITE_ERROR if the finalizer reports an error.  SQLITE_OK
  220. ** otherwise.
  221. */
  222. int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
  223.   int rc = SQLITE_OK;
  224.   if( pFunc && pFunc->xFinalize ){
  225.     sqlite3_context ctx;
  226.     assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
  227.     assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  228.     ctx.s.flags = MEM_Null;
  229.     ctx.s.db = pMem->db;
  230.     ctx.s.zMalloc = 0;
  231.     ctx.pMem = pMem;
  232.     ctx.pFunc = pFunc;
  233.     ctx.isError = 0;
  234.     pFunc->xFinalize(&ctx);
  235.     assert( 0==(pMem->flags&MEM_Dyn) && !pMem->xDel );
  236.     sqlite3_free(pMem->zMalloc);
  237.     *pMem = ctx.s;
  238.     rc = (ctx.isError?SQLITE_ERROR:SQLITE_OK);
  239.   }
  240.   return rc;
  241. }
  242. /*
  243. ** If the memory cell contains a string value that must be freed by
  244. ** invoking an external callback, free it now. Calling this function
  245. ** does not free any Mem.zMalloc buffer.
  246. */
  247. void sqlite3VdbeMemReleaseExternal(Mem *p){
  248.   assert( p->db==0 || sqlite3_mutex_held(p->db->mutex) );
  249.   if( p->flags&MEM_Agg ){
  250.     sqlite3VdbeMemFinalize(p, p->u.pDef);
  251.     assert( (p->flags & MEM_Agg)==0 );
  252.     sqlite3VdbeMemRelease(p);
  253.   }else if( p->flags&MEM_Dyn && p->xDel ){
  254.     p->xDel((void *)p->z);
  255.     p->xDel = 0;
  256.   }
  257. }
  258. /*
  259. ** Release any memory held by the Mem. This may leave the Mem in an
  260. ** inconsistent state, for example with (Mem.z==0) and
  261. ** (Mem.type==SQLITE_TEXT).
  262. */
  263. void sqlite3VdbeMemRelease(Mem *p){
  264.   sqlite3VdbeMemReleaseExternal(p);
  265.   sqlite3_free(p->zMalloc);
  266.   p->z = 0;
  267.   p->zMalloc = 0;
  268.   p->xDel = 0;
  269. }
  270. /*
  271. ** Convert a 64-bit IEEE double into a 64-bit signed integer.
  272. ** If the double is too large, return 0x8000000000000000.
  273. **
  274. ** Most systems appear to do this simply by assigning
  275. ** variables and without the extra range tests.  But
  276. ** there are reports that windows throws an expection
  277. ** if the floating point value is out of range. (See ticket #2880.)
  278. ** Because we do not completely understand the problem, we will
  279. ** take the conservative approach and always do range tests
  280. ** before attempting the conversion.
  281. */
  282. static i64 doubleToInt64(double r){
  283.   /*
  284.   ** Many compilers we encounter do not define constants for the
  285.   ** minimum and maximum 64-bit integers, or they define them
  286.   ** inconsistently.  And many do not understand the "LL" notation.
  287.   ** So we define our own static constants here using nothing
  288.   ** larger than a 32-bit integer constant.
  289.   */
  290.   static const i64 maxInt = (((i64)0x7fffffff)<<32)|0xffffffff;
  291.   static const i64 minInt = ((i64)0x80000000)<<32;
  292.   if( r<(double)minInt ){
  293.     return minInt;
  294.   }else if( r>(double)maxInt ){
  295.     return minInt;
  296.   }else{
  297.     return (i64)r;
  298.   }
  299. }
  300. /*
  301. ** Return some kind of integer value which is the best we can do
  302. ** at representing the value that *pMem describes as an integer.
  303. ** If pMem is an integer, then the value is exact.  If pMem is
  304. ** a floating-point then the value returned is the integer part.
  305. ** If pMem is a string or blob, then we make an attempt to convert
  306. ** it into a integer and return that.  If pMem is NULL, return 0.
  307. **
  308. ** If pMem is a string, its encoding might be changed.
  309. */
  310. i64 sqlite3VdbeIntValue(Mem *pMem){
  311.   int flags;
  312.   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  313.   flags = pMem->flags;
  314.   if( flags & MEM_Int ){
  315.     return pMem->u.i;
  316.   }else if( flags & MEM_Real ){
  317.     return doubleToInt64(pMem->r);
  318.   }else if( flags & (MEM_Str|MEM_Blob) ){
  319.     i64 value;
  320.     pMem->flags |= MEM_Str;
  321.     if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8)
  322.        || sqlite3VdbeMemNulTerminate(pMem) ){
  323.       return 0;
  324.     }
  325.     assert( pMem->z );
  326.     sqlite3Atoi64(pMem->z, &value);
  327.     return value;
  328.   }else{
  329.     return 0;
  330.   }
  331. }
  332. /*
  333. ** Return the best representation of pMem that we can get into a
  334. ** double.  If pMem is already a double or an integer, return its
  335. ** value.  If it is a string or blob, try to convert it to a double.
  336. ** If it is a NULL, return 0.0.
  337. */
  338. double sqlite3VdbeRealValue(Mem *pMem){
  339.   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  340.   if( pMem->flags & MEM_Real ){
  341.     return pMem->r;
  342.   }else if( pMem->flags & MEM_Int ){
  343.     return (double)pMem->u.i;
  344.   }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
  345.     double val = 0.0;
  346.     pMem->flags |= MEM_Str;
  347.     if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8)
  348.        || sqlite3VdbeMemNulTerminate(pMem) ){
  349.       return 0.0;
  350.     }
  351.     assert( pMem->z );
  352.     sqlite3AtoF(pMem->z, &val);
  353.     return val;
  354.   }else{
  355.     return 0.0;
  356.   }
  357. }
  358. /*
  359. ** The MEM structure is already a MEM_Real.  Try to also make it a
  360. ** MEM_Int if we can.
  361. */
  362. void sqlite3VdbeIntegerAffinity(Mem *pMem){
  363.   assert( pMem->flags & MEM_Real );
  364.   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  365.   pMem->u.i = doubleToInt64(pMem->r);
  366.   if( pMem->r==(double)pMem->u.i ){
  367.     pMem->flags |= MEM_Int;
  368.   }
  369. }
  370. static void setTypeFlag(Mem *pMem, int f){
  371.   MemSetTypeFlag(pMem, f);
  372. }
  373. /*
  374. ** Convert pMem to type integer.  Invalidate any prior representations.
  375. */
  376. int sqlite3VdbeMemIntegerify(Mem *pMem){
  377.   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  378.   pMem->u.i = sqlite3VdbeIntValue(pMem);
  379.   setTypeFlag(pMem, MEM_Int);
  380.   return SQLITE_OK;
  381. }
  382. /*
  383. ** Convert pMem so that it is of type MEM_Real.
  384. ** Invalidate any prior representations.
  385. */
  386. int sqlite3VdbeMemRealify(Mem *pMem){
  387.   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  388.   pMem->r = sqlite3VdbeRealValue(pMem);
  389.   setTypeFlag(pMem, MEM_Real);
  390.   return SQLITE_OK;
  391. }
  392. /*
  393. ** Convert pMem so that it has types MEM_Real or MEM_Int or both.
  394. ** Invalidate any prior representations.
  395. */
  396. int sqlite3VdbeMemNumerify(Mem *pMem){
  397.   double r1, r2;
  398.   i64 i;
  399.   assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_Null))==0 );
  400.   assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
  401.   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  402.   r1 = sqlite3VdbeRealValue(pMem);
  403.   i = doubleToInt64(r1);
  404.   r2 = (double)i;
  405.   if( r1==r2 ){
  406.     sqlite3VdbeMemIntegerify(pMem);
  407.   }else{
  408.     pMem->r = r1;
  409.     setTypeFlag(pMem, MEM_Real);
  410.   }
  411.   return SQLITE_OK;
  412. }
  413. /*
  414. ** Delete any previous value and set the value stored in *pMem to NULL.
  415. */
  416. void sqlite3VdbeMemSetNull(Mem *pMem){
  417.   setTypeFlag(pMem, MEM_Null);
  418.   pMem->type = SQLITE_NULL;
  419. }
  420. /*
  421. ** Delete any previous value and set the value to be a BLOB of length
  422. ** n containing all zeros.
  423. */
  424. void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
  425.   sqlite3VdbeMemRelease(pMem);
  426.   setTypeFlag(pMem, MEM_Blob);
  427.   pMem->flags = MEM_Blob|MEM_Zero;
  428.   pMem->type = SQLITE_BLOB;
  429.   pMem->n = 0;
  430.   if( n<0 ) n = 0;
  431.   pMem->u.i = n;
  432.   pMem->enc = SQLITE_UTF8;
  433. }
  434. /*
  435. ** Delete any previous value and set the value stored in *pMem to val,
  436. ** manifest type INTEGER.
  437. */
  438. void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
  439.   sqlite3VdbeMemRelease(pMem);
  440.   pMem->u.i = val;
  441.   pMem->flags = MEM_Int;
  442.   pMem->type = SQLITE_INTEGER;
  443. }
  444. /*
  445. ** Delete any previous value and set the value stored in *pMem to val,
  446. ** manifest type REAL.
  447. */
  448. void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
  449.   if( sqlite3_isnan(val) ){
  450.     sqlite3VdbeMemSetNull(pMem);
  451.   }else{
  452.     sqlite3VdbeMemRelease(pMem);
  453.     pMem->r = val;
  454.     pMem->flags = MEM_Real;
  455.     pMem->type = SQLITE_FLOAT;
  456.   }
  457. }
  458. /*
  459. ** Return true if the Mem object contains a TEXT or BLOB that is
  460. ** too large - whose size exceeds SQLITE_MAX_LENGTH.
  461. */
  462. int sqlite3VdbeMemTooBig(Mem *p){
  463.   assert( p->db!=0 );
  464.   if( p->flags & (MEM_Str|MEM_Blob) ){
  465.     int n = p->n;
  466.     if( p->flags & MEM_Zero ){
  467.       n += p->u.i;
  468.     }
  469.     return n>p->db->aLimit[SQLITE_LIMIT_LENGTH];
  470.   }
  471.   return 0; 
  472. }
  473. /*
  474. ** Size of struct Mem not including the Mem.zMalloc member.
  475. */
  476. #define MEMCELLSIZE (size_t)(&(((Mem *)0)->zMalloc))
  477. /*
  478. ** Make an shallow copy of pFrom into pTo.  Prior contents of
  479. ** pTo are freed.  The pFrom->z field is not duplicated.  If
  480. ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
  481. ** and flags gets srcType (either MEM_Ephem or MEM_Static).
  482. */
  483. void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
  484.   sqlite3VdbeMemReleaseExternal(pTo);
  485.   memcpy(pTo, pFrom, MEMCELLSIZE);
  486.   pTo->xDel = 0;
  487.   if( (pFrom->flags&MEM_Dyn)!=0 || pFrom->z==pFrom->zMalloc ){
  488.     pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
  489.     assert( srcType==MEM_Ephem || srcType==MEM_Static );
  490.     pTo->flags |= srcType;
  491.   }
  492. }
  493. /*
  494. ** Make a full copy of pFrom into pTo.  Prior contents of pTo are
  495. ** freed before the copy is made.
  496. */
  497. int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
  498.   int rc = SQLITE_OK;
  499.   sqlite3VdbeMemReleaseExternal(pTo);
  500.   memcpy(pTo, pFrom, MEMCELLSIZE);
  501.   pTo->flags &= ~MEM_Dyn;
  502.   if( pTo->flags&(MEM_Str|MEM_Blob) ){
  503.     if( 0==(pFrom->flags&MEM_Static) ){
  504.       pTo->flags |= MEM_Ephem;
  505.       rc = sqlite3VdbeMemMakeWriteable(pTo);
  506.     }
  507.   }
  508.   return rc;
  509. }
  510. /*
  511. ** Transfer the contents of pFrom to pTo. Any existing value in pTo is
  512. ** freed. If pFrom contains ephemeral data, a copy is made.
  513. **
  514. ** pFrom contains an SQL NULL when this routine returns.
  515. */
  516. void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
  517.   assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
  518.   assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
  519.   assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
  520.   sqlite3VdbeMemRelease(pTo);
  521.   memcpy(pTo, pFrom, sizeof(Mem));
  522.   pFrom->flags = MEM_Null;
  523.   pFrom->xDel = 0;
  524.   pFrom->zMalloc = 0;
  525. }
  526. /*
  527. ** Change the value of a Mem to be a string or a BLOB.
  528. **
  529. ** The memory management strategy depends on the value of the xDel
  530. ** parameter. If the value passed is SQLITE_TRANSIENT, then the 
  531. ** string is copied into a (possibly existing) buffer managed by the 
  532. ** Mem structure. Otherwise, any existing buffer is freed and the
  533. ** pointer copied.
  534. */
  535. int sqlite3VdbeMemSetStr(
  536.   Mem *pMem,          /* Memory cell to set to string value */
  537.   const char *z,      /* String pointer */
  538.   int n,              /* Bytes in string, or negative */
  539.   u8 enc,             /* Encoding of z.  0 for BLOBs */
  540.   void (*xDel)(void*) /* Destructor function */
  541. ){
  542.   int nByte = n;      /* New value for pMem->n */
  543.   int flags = 0;      /* New value for pMem->flags */
  544.   assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
  545.   /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
  546.   if( !z ){
  547.     sqlite3VdbeMemSetNull(pMem);
  548.     return SQLITE_OK;
  549.   }
  550.   flags = (enc==0?MEM_Blob:MEM_Str);
  551.   if( nByte<0 ){
  552.     assert( enc!=0 );
  553.     if( enc==SQLITE_UTF8 ){
  554.       for(nByte=0; z[nByte]; nByte++){}
  555.     }else{
  556.       for(nByte=0; z[nByte] | z[nByte+1]; nByte+=2){}
  557.     }
  558.     flags |= MEM_Term;
  559.   }
  560.   /* The following block sets the new values of Mem.z and Mem.xDel. It
  561.   ** also sets a flag in local variable "flags" to indicate the memory
  562.   ** management (one of MEM_Dyn or MEM_Static).
  563.   */
  564.   if( xDel==SQLITE_TRANSIENT ){
  565.     int nAlloc = nByte;
  566.     if( flags&MEM_Term ){
  567.       nAlloc += (enc==SQLITE_UTF8?1:2);
  568.     }
  569.     if( sqlite3VdbeMemGrow(pMem, nAlloc, 0) ){
  570.       return SQLITE_NOMEM;
  571.     }
  572.     memcpy(pMem->z, z, nAlloc);
  573.   }else{
  574.     sqlite3VdbeMemRelease(pMem);
  575.     pMem->z = (char *)z;
  576.     pMem->xDel = xDel;
  577.     flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn);
  578.   }
  579.   pMem->n = nByte;
  580.   pMem->flags = flags;
  581.   pMem->enc = (enc==0 ? SQLITE_UTF8 : enc);
  582.   pMem->type = (enc==0 ? SQLITE_BLOB : SQLITE_TEXT);
  583. #ifndef SQLITE_OMIT_UTF16
  584.   if( pMem->enc!=SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
  585.     return SQLITE_NOMEM;
  586.   }
  587. #endif
  588.   return SQLITE_OK;
  589. }
  590. /*
  591. ** Compare the values contained by the two memory cells, returning
  592. ** negative, zero or positive if pMem1 is less than, equal to, or greater
  593. ** than pMem2. Sorting order is NULL's first, followed by numbers (integers
  594. ** and reals) sorted numerically, followed by text ordered by the collating
  595. ** sequence pColl and finally blob's ordered by memcmp().
  596. **
  597. ** Two NULL values are considered equal by this function.
  598. */
  599. int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
  600.   int rc;
  601.   int f1, f2;
  602.   int combined_flags;
  603.   /* Interchange pMem1 and pMem2 if the collating sequence specifies
  604.   ** DESC order.
  605.   */
  606.   f1 = pMem1->flags;
  607.   f2 = pMem2->flags;
  608.   combined_flags = f1|f2;
  609.  
  610.   /* If one value is NULL, it is less than the other. If both values
  611.   ** are NULL, return 0.
  612.   */
  613.   if( combined_flags&MEM_Null ){
  614.     return (f2&MEM_Null) - (f1&MEM_Null);
  615.   }
  616.   /* If one value is a number and the other is not, the number is less.
  617.   ** If both are numbers, compare as reals if one is a real, or as integers
  618.   ** if both values are integers.
  619.   */
  620.   if( combined_flags&(MEM_Int|MEM_Real) ){
  621.     if( !(f1&(MEM_Int|MEM_Real)) ){
  622.       return 1;
  623.     }
  624.     if( !(f2&(MEM_Int|MEM_Real)) ){
  625.       return -1;
  626.     }
  627.     if( (f1 & f2 & MEM_Int)==0 ){
  628.       double r1, r2;
  629.       if( (f1&MEM_Real)==0 ){
  630.         r1 = pMem1->u.i;
  631.       }else{
  632.         r1 = pMem1->r;
  633.       }
  634.       if( (f2&MEM_Real)==0 ){
  635.         r2 = pMem2->u.i;
  636.       }else{
  637.         r2 = pMem2->r;
  638.       }
  639.       if( r1<r2 ) return -1;
  640.       if( r1>r2 ) return 1;
  641.       return 0;
  642.     }else{
  643.       assert( f1&MEM_Int );
  644.       assert( f2&MEM_Int );
  645.       if( pMem1->u.i < pMem2->u.i ) return -1;
  646.       if( pMem1->u.i > pMem2->u.i ) return 1;
  647.       return 0;
  648.     }
  649.   }
  650.   /* If one value is a string and the other is a blob, the string is less.
  651.   ** If both are strings, compare using the collating functions.
  652.   */
  653.   if( combined_flags&MEM_Str ){
  654.     if( (f1 & MEM_Str)==0 ){
  655.       return 1;
  656.     }
  657.     if( (f2 & MEM_Str)==0 ){
  658.       return -1;
  659.     }
  660.     assert( pMem1->enc==pMem2->enc );
  661.     assert( pMem1->enc==SQLITE_UTF8 || 
  662.             pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
  663.     /* The collation sequence must be defined at this point, even if
  664.     ** the user deletes the collation sequence after the vdbe program is
  665.     ** compiled (this was not always the case).
  666.     */
  667.     assert( !pColl || pColl->xCmp );
  668.     if( pColl ){
  669.       if( pMem1->enc==pColl->enc ){
  670.         /* The strings are already in the correct encoding.  Call the
  671.         ** comparison function directly */
  672.         return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
  673.       }else{
  674.         u8 origEnc = pMem1->enc;
  675.         const void *v1, *v2;
  676.         int n1, n2;
  677.         /* Convert the strings into the encoding that the comparison
  678.         ** function expects */
  679.         v1 = sqlite3ValueText((sqlite3_value*)pMem1, pColl->enc);
  680.         n1 = v1==0 ? 0 : pMem1->n;
  681.         assert( n1==sqlite3ValueBytes((sqlite3_value*)pMem1, pColl->enc) );
  682.         v2 = sqlite3ValueText((sqlite3_value*)pMem2, pColl->enc);
  683.         n2 = v2==0 ? 0 : pMem2->n;
  684.         assert( n2==sqlite3ValueBytes((sqlite3_value*)pMem2, pColl->enc) );
  685.         /* Do the comparison */
  686.         rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2);
  687.         /* Convert the strings back into the database encoding */
  688.         sqlite3ValueText((sqlite3_value*)pMem1, origEnc);
  689.         sqlite3ValueText((sqlite3_value*)pMem2, origEnc);
  690.         return rc;
  691.       }
  692.     }
  693.     /* If a NULL pointer was passed as the collate function, fall through
  694.     ** to the blob case and use memcmp().  */
  695.   }
  696.  
  697.   /* Both values must be blobs.  Compare using memcmp().  */
  698.   rc = memcmp(pMem1->z, pMem2->z, (pMem1->n>pMem2->n)?pMem2->n:pMem1->n);
  699.   if( rc==0 ){
  700.     rc = pMem1->n - pMem2->n;
  701.   }
  702.   return rc;
  703. }
  704. /*
  705. ** Move data out of a btree key or data field and into a Mem structure.
  706. ** The data or key is taken from the entry that pCur is currently pointing
  707. ** to.  offset and amt determine what portion of the data or key to retrieve.
  708. ** key is true to get the key or false to get data.  The result is written
  709. ** into the pMem element.
  710. **
  711. ** The pMem structure is assumed to be uninitialized.  Any prior content
  712. ** is overwritten without being freed.
  713. **
  714. ** If this routine fails for any reason (malloc returns NULL or unable
  715. ** to read from the disk) then the pMem is left in an inconsistent state.
  716. */
  717. int sqlite3VdbeMemFromBtree(
  718.   BtCursor *pCur,   /* Cursor pointing at record to retrieve. */
  719.   int offset,       /* Offset from the start of data to return bytes from. */
  720.   int amt,          /* Number of bytes to return. */
  721.   int key,          /* If true, retrieve from the btree key, not data. */
  722.   Mem *pMem         /* OUT: Return data in this Mem structure. */
  723. ){
  724.   char *zData;       /* Data from the btree layer */
  725.   int available = 0; /* Number of bytes available on the local btree page */
  726.   sqlite3 *db;       /* Database connection */
  727.   int rc = SQLITE_OK;
  728.   db = sqlite3BtreeCursorDb(pCur);
  729.   assert( sqlite3_mutex_held(db->mutex) );
  730.   if( key ){
  731.     zData = (char *)sqlite3BtreeKeyFetch(pCur, &available);
  732.   }else{
  733.     zData = (char *)sqlite3BtreeDataFetch(pCur, &available);
  734.   }
  735.   assert( zData!=0 );
  736.   if( offset+amt<=available && ((pMem->flags&MEM_Dyn)==0 || pMem->xDel) ){
  737.     sqlite3VdbeMemRelease(pMem);
  738.     pMem->z = &zData[offset];
  739.     pMem->flags = MEM_Blob|MEM_Ephem;
  740.   }else if( SQLITE_OK==(rc = sqlite3VdbeMemGrow(pMem, amt+2, 0)) ){
  741.     pMem->flags = MEM_Blob|MEM_Dyn|MEM_Term;
  742.     pMem->enc = 0;
  743.     pMem->type = SQLITE_BLOB;
  744.     if( key ){
  745.       rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
  746.     }else{
  747.       rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
  748.     }
  749.     pMem->z[amt] = 0;
  750.     pMem->z[amt+1] = 0;
  751.     if( rc!=SQLITE_OK ){
  752.       sqlite3VdbeMemRelease(pMem);
  753.     }
  754.   }
  755.   pMem->n = amt;
  756.   return rc;
  757. }
  758. #if 0
  759. /*
  760. ** Perform various checks on the memory cell pMem. An assert() will
  761. ** fail if pMem is internally inconsistent.
  762. */
  763. void sqlite3VdbeMemSanity(Mem *pMem){
  764.   int flags = pMem->flags;
  765.   assert( flags!=0 );  /* Must define some type */
  766.   if( flags & (MEM_Str|MEM_Blob) ){
  767.     int x = flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short);
  768.     assert( x!=0 );            /* Strings must define a string subtype */
  769.     assert( (x & (x-1))==0 );  /* Only one string subtype can be defined */
  770.     assert( pMem->z!=0 );      /* Strings must have a value */
  771.     /* Mem.z points to Mem.zShort iff the subtype is MEM_Short */
  772.     assert( (x & MEM_Short)==0 || pMem->z==pMem->zShort );
  773.     assert( (x & MEM_Short)!=0 || pMem->z!=pMem->zShort );
  774.     /* No destructor unless there is MEM_Dyn */
  775.     assert( pMem->xDel==0 || (pMem->flags & MEM_Dyn)!=0 );
  776.     if( (flags & MEM_Str) ){
  777.       assert( pMem->enc==SQLITE_UTF8 || 
  778.               pMem->enc==SQLITE_UTF16BE ||
  779.               pMem->enc==SQLITE_UTF16LE 
  780.       );
  781.       /* If the string is UTF-8 encoded and nul terminated, then pMem->n
  782.       ** must be the length of the string.  (Later:)  If the database file
  783.       ** has been corrupted, '00' characters might have been inserted
  784.       ** into the middle of the string.  In that case, the strlen() might
  785.       ** be less.
  786.       */
  787.       if( pMem->enc==SQLITE_UTF8 && (flags & MEM_Term) ){ 
  788.         assert( strlen(pMem->z)<=pMem->n );
  789.         assert( pMem->z[pMem->n]==0 );
  790.       }
  791.     }
  792.   }else{
  793.     /* Cannot define a string subtype for non-string objects */
  794.     assert( (pMem->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short))==0 );
  795.     assert( pMem->xDel==0 );
  796.   }
  797.   /* MEM_Null excludes all other types */
  798.   assert( (pMem->flags&(MEM_Str|MEM_Int|MEM_Real|MEM_Blob))==0
  799.           || (pMem->flags&MEM_Null)==0 );
  800.   /* If the MEM is both real and integer, the values are equal */
  801.   assert( (pMem->flags & (MEM_Int|MEM_Real))!=(MEM_Int|MEM_Real) 
  802.           || pMem->r==pMem->u.i );
  803. }
  804. #endif
  805. /* This function is only available internally, it is not part of the
  806. ** external API. It works in a similar way to sqlite3_value_text(),
  807. ** except the data returned is in the encoding specified by the second
  808. ** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
  809. ** SQLITE_UTF8.
  810. **
  811. ** (2006-02-16:)  The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
  812. ** If that is the case, then the result must be aligned on an even byte
  813. ** boundary.
  814. */
  815. const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
  816.   if( !pVal ) return 0;
  817.   assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
  818.   assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
  819.   if( pVal->flags&MEM_Null ){
  820.     return 0;
  821.   }
  822.   assert( (MEM_Blob>>3) == MEM_Str );
  823.   pVal->flags |= (pVal->flags & MEM_Blob)>>3;
  824.   expandBlob(pVal);
  825.   if( pVal->flags&MEM_Str ){
  826.     sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
  827.     if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&(sqlite3_intptr_t)pVal->z) ){
  828.       assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
  829.       if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
  830.         return 0;
  831.       }
  832.     }
  833.     sqlite3VdbeMemNulTerminate(pVal);
  834.   }else{
  835.     assert( (pVal->flags&MEM_Blob)==0 );
  836.     sqlite3VdbeMemStringify(pVal, enc);
  837.     assert( 0==(1&(sqlite3_intptr_t)pVal->z) );
  838.   }
  839.   assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
  840.               || pVal->db->mallocFailed );
  841.   if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
  842.     return pVal->z;
  843.   }else{
  844.     return 0;
  845.   }
  846. }
  847. /*
  848. ** Create a new sqlite3_value object.
  849. */
  850. sqlite3_value *sqlite3ValueNew(sqlite3 *db){
  851.   Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
  852.   if( p ){
  853.     p->flags = MEM_Null;
  854.     p->type = SQLITE_NULL;
  855.     p->db = db;
  856.   }
  857.   return p;
  858. }
  859. /*
  860. ** Create a new sqlite3_value object, containing the value of pExpr.
  861. **
  862. ** This only works for very simple expressions that consist of one constant
  863. ** token (i.e. "5", "5.1", "'a string'"). If the expression can
  864. ** be converted directly into a value, then the value is allocated and
  865. ** a pointer written to *ppVal. The caller is responsible for deallocating
  866. ** the value by passing it to sqlite3ValueFree() later on. If the expression
  867. ** cannot be converted to a value, then *ppVal is set to NULL.
  868. */
  869. int sqlite3ValueFromExpr(
  870.   sqlite3 *db,              /* The database connection */
  871.   Expr *pExpr,              /* The expression to evaluate */
  872.   u8 enc,                   /* Encoding to use */
  873.   u8 affinity,              /* Affinity to use */
  874.   sqlite3_value **ppVal     /* Write the new value here */
  875. ){
  876.   int op;
  877.   char *zVal = 0;
  878.   sqlite3_value *pVal = 0;
  879.   if( !pExpr ){
  880.     *ppVal = 0;
  881.     return SQLITE_OK;
  882.   }
  883.   op = pExpr->op;
  884.   if( op==TK_STRING || op==TK_FLOAT || op==TK_INTEGER ){
  885.     zVal = sqlite3StrNDup((char*)pExpr->token.z, pExpr->token.n);
  886.     pVal = sqlite3ValueNew(db);
  887.     if( !zVal || !pVal ) goto no_mem;
  888.     sqlite3Dequote(zVal);
  889.     sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, sqlite3_free);
  890.     if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
  891.       sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, enc);
  892.     }else{
  893.       sqlite3ValueApplyAffinity(pVal, affinity, enc);
  894.     }
  895.   }else if( op==TK_UMINUS ) {
  896.     if( SQLITE_OK==sqlite3ValueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal) ){
  897.       pVal->u.i = -1 * pVal->u.i;
  898.       pVal->r = -1.0 * pVal->r;
  899.     }
  900.   }
  901. #ifndef SQLITE_OMIT_BLOB_LITERAL
  902.   else if( op==TK_BLOB ){
  903.     int nVal;
  904.     assert( pExpr->token.n>=3 );
  905.     assert( pExpr->token.z[0]=='x' || pExpr->token.z[0]=='X' );
  906.     assert( pExpr->token.z[1]==''' );
  907.     assert( pExpr->token.z[pExpr->token.n-1]==''' );
  908.     pVal = sqlite3ValueNew(db);
  909.     nVal = pExpr->token.n - 3;
  910.     zVal = (char*)pExpr->token.z + 2;
  911.     sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
  912.                          0, sqlite3_free);
  913.   }
  914. #endif
  915.   *ppVal = pVal;
  916.   return SQLITE_OK;
  917. no_mem:
  918.   db->mallocFailed = 1;
  919.   sqlite3_free(zVal);
  920.   sqlite3ValueFree(pVal);
  921.   *ppVal = 0;
  922.   return SQLITE_NOMEM;
  923. }
  924. /*
  925. ** Change the string value of an sqlite3_value object
  926. */
  927. void sqlite3ValueSetStr(
  928.   sqlite3_value *v,     /* Value to be set */
  929.   int n,                /* Length of string z */
  930.   const void *z,        /* Text of the new string */
  931.   u8 enc,               /* Encoding to use */
  932.   void (*xDel)(void*)   /* Destructor for the string */
  933. ){
  934.   if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
  935. }
  936. /*
  937. ** Free an sqlite3_value object
  938. */
  939. void sqlite3ValueFree(sqlite3_value *v){
  940.   if( !v ) return;
  941.   sqlite3VdbeMemRelease((Mem *)v);
  942.   sqlite3_free(v);
  943. }
  944. /*
  945. ** Return the number of bytes in the sqlite3_value object assuming
  946. ** that it uses the encoding "enc"
  947. */
  948. int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
  949.   Mem *p = (Mem*)pVal;
  950.   if( (p->flags & MEM_Blob)!=0 || sqlite3ValueText(pVal, enc) ){
  951.     if( p->flags & MEM_Zero ){
  952.       return p->n+p->u.i;
  953.     }else{
  954.       return p->n;
  955.     }
  956.   }
  957.   return 0;
  958. }