nettika/mattercontrol
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
mattercontrol/Community.CsharpSqlite/src/vdbemem_c.cs
Lars Brubaker 591528ee91 Ran code maid against this code.
2015-04-08 15:20:10 -07:00

1640 lines
No EOL
46 KiB
C#
Raw Blame History

using System;
using System.Diagnostics;
using System.Text;
using i64 = System.Int64;
using u16 = System.UInt16;
using u32 = System.UInt32;
using u8 = System.Byte;
namespace Community.CsharpSqlite
{
using System.Globalization;
using sqlite3_value = Sqlite3.Mem;
public partial class Sqlite3
{
/*
** 2004 May 26
**
** The author disclaims copyright to this source code. In place of
** a legal notice, here is a blessing:
**
** May you do good and not evil.
** May you find forgiveness for yourself and forgive others.
** May you share freely, never taking more than you give.
**
*************************************************************************
**
** This file contains code use to manipulate "Mem" structure. A "Mem"
** stores a single value in the VDBE. Mem is an opaque structure visible
** only within the VDBE. Interface routines refer to a Mem using the
** name sqlite_value
*************************************************************************
** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
** C#-SQLite is an independent reimplementation of the SQLite software library
**
** SQLITE_SOURCE_ID: 2011-05-19 13:26:54 ed1da510a239ea767a01dc332b667119fa3c908e
**
*************************************************************************
*/
//#include "sqliteInt.h"
//#include "vdbeInt.h"
/*
** Call sqlite3VdbeMemExpandBlob() on the supplied value (type Mem*)
** P if required.
*/
//#define expandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
private static void expandBlob(Mem P)
{
if ((P.flags & MEM_Zero) != 0)
sqlite3VdbeMemExpandBlob(P);
} // TODO -- Convert to inline for speed
/*
** If pMem is an object with a valid string representation, this routine
** ensures the internal encoding for the string representation is
** 'desiredEnc', one of SQLITE_UTF8, SQLITE_UTF16LE or SQLITE_UTF16BE.
**
** If pMem is not a string object, or the encoding of the string
** representation is already stored using the requested encoding, then this
** routine is a no-op.
**
** SQLITE_OK is returned if the conversion is successful (or not required).
** SQLITE_NOMEM may be returned if a malloc() fails during conversion
** between formats.
*/
private static int sqlite3VdbeChangeEncoding(Mem pMem, int desiredEnc)
{
int rc;
Debug.Assert((pMem.flags & MEM_RowSet) == 0);
Debug.Assert(desiredEnc == SQLITE_UTF8 || desiredEnc == SQLITE_UTF16LE
|| desiredEnc == SQLITE_UTF16BE);
if ((pMem.flags & MEM_Str) == 0 || pMem.enc == desiredEnc)
{
if (String.IsNullOrEmpty(pMem.z) && pMem.zBLOB != null)
pMem.z = Encoding.UTF8.GetString(pMem.zBLOB, 0, pMem.zBLOB.Length);
return SQLITE_OK;
}
Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
#if SQLITE_OMIT_UTF16
return SQLITE_ERROR;
#else
/* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
** then the encoding of the value may not have changed.
*/
rc = sqlite3VdbeMemTranslate(pMem, (u8)desiredEnc);
Debug.Assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
Debug.Assert(rc==SQLITE_OK || pMem.enc!=desiredEnc);
Debug.Assert(rc==SQLITE_NOMEM || pMem.enc==desiredEnc);
return rc;
#endif
}
/*
** Make sure pMem.z points to a writable allocation of at least
** n bytes.
**
** If the memory cell currently contains string or blob data
** and the third argument passed to this function is true, the
** current content of the cell is preserved. Otherwise, it may
** be discarded.
**
** This function sets the MEM_Dyn flag and clears any xDel callback.
** It also clears MEM_Ephem and MEM_Static. If the preserve flag is
** not set, Mem.n is zeroed.
*/
private static int sqlite3VdbeMemGrow(Mem pMem, int n, int preserve)
{
// TODO -- What do we want to do about this routine?
//Debug.Assert( 1 >=
// ((pMem.zMalloc !=null )? 1 : 0) + //&& pMem.zMalloc==pMem.z) ? 1 : 0) +
// (((pMem.flags & MEM_Dyn)!=0 && pMem.xDel!=null) ? 1 : 0) +
// ((pMem.flags & MEM_Ephem)!=0 ? 1 : 0) +
// ((pMem.flags & MEM_Static)!=0 ? 1 : 0)
//);
//assert( (pMem->flags&MEM_RowSet)==0 );
//if( n<32 ) n = 32;
//if( sqlite3DbMallocSize(pMem->db, pMem.zMalloc)<n ){
if (preserve != 0)
{//& pMem.z==pMem.zMalloc ){
if (pMem.z == null)
pMem.z = "";// sqlite3DbReallocOrFree( pMem.db, pMem.z, n );
else
if (n < pMem.z.Length)
pMem.z = pMem.z.Substring(0, n);
preserve = 0;
}
else
{
// sqlite3DbFree(pMem->db,ref pMem.zMalloc);
pMem.z = "";// sqlite3DbMallocRaw( pMem.db, n );
}
//}
// if( pMem->z && preserve && pMem->zMalloc && pMem->z!=pMem->zMalloc ){
// memcpy(pMem.zMalloc, pMem.z, pMem.n);
//}
if ((pMem.flags & MEM_Dyn) != 0 && pMem.xDel != null)
{
pMem.xDel(ref pMem.z);
}
// TODO --pMem.z = pMem.zMalloc;
if (pMem.z == null)
{
pMem.flags = MEM_Null;
}
else
{
pMem.flags = (u16)(pMem.flags & ~(MEM_Ephem | MEM_Static));
}
pMem.xDel = null;
return pMem.z != null ? SQLITE_OK : SQLITE_NOMEM;
}
/*
** Make the given Mem object MEM_Dyn. In other words, make it so
** that any TEXT or BLOB content is stored in memory obtained from
** malloc(). In this way, we know that the memory is safe to be
** overwritten or altered.
**
** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
*/
private static int sqlite3VdbeMemMakeWriteable(Mem pMem)
{
int f;
Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
Debug.Assert((pMem.flags & MEM_RowSet) == 0);
expandBlob(pMem);
f = pMem.flags;
if ((f & (MEM_Str | MEM_Blob)) != 0) // TODO -- && pMem.z != pMem.zMalloc )
{
if (sqlite3VdbeMemGrow(pMem, pMem.n + 2, 1) != 0)
//{
// return SQLITE_NOMEM;
//}
//pMem.z[pMem->n] = 0;
//pMem.z[pMem->n + 1] = 0;
pMem.flags |= MEM_Term;
#if SQLITE_DEBUG
pMem.pScopyFrom = null;
#endif
}
return SQLITE_OK;
}
/*
** If the given Mem* has a zero-filled tail, turn it into an ordinary
** blob stored in dynamically allocated space.
*/
#if !SQLITE_OMIT_INCRBLOB
static int sqlite3VdbeMemExpandBlob( Mem pMem )
{
if ( ( pMem.flags & MEM_Zero ) != 0 )
{
u32 nByte;
Debug.Assert( ( pMem.flags & MEM_Blob ) != 0 );
Debug.Assert( ( pMem.flags & MEM_RowSet ) == 0 );
Debug.Assert( pMem.db == null || sqlite3_mutex_held( pMem.db.mutex ) );
/* Set nByte to the number of bytes required to store the expanded blob. */
nByte = (u32)( pMem.n + pMem.u.nZero );
if ( nByte <= 0 )
{
nByte = 1;
}
if ( sqlite3VdbeMemGrow( pMem, (int)nByte, 1 ) != 0 )
{
return SQLITE_NOMEM;
} /* Set nByte to the number of bytes required to store the expanded blob. */
nByte = (u32)( pMem.n + pMem.u.nZero );
if ( nByte <= 0 )
{
nByte = 1;
}
if ( sqlite3VdbeMemGrow( pMem, (int)nByte, 1 ) != 0 )
{
return SQLITE_NOMEM;
}
//memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
pMem.zBLOB = Encoding.UTF8.GetBytes( pMem.z );
pMem.z = null;
pMem.n += (int)pMem.u.nZero;
pMem.u.i = 0;
pMem.flags = (u16)( pMem.flags & ~( MEM_Zero | MEM_Static | MEM_Ephem | MEM_Term ) );
pMem.flags |= MEM_Dyn;
}
return SQLITE_OK;
}
#endif
/*
** Make sure the given Mem is \u0000 terminated.
*/
private static int sqlite3VdbeMemNulTerminate(Mem pMem)
{
Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
if ((pMem.flags & MEM_Term) != 0 || (pMem.flags & MEM_Str) == 0)
{
return SQLITE_OK; /* Nothing to do */
}
//if ( pMem.n != 0 && sqlite3VdbeMemGrow( pMem, pMem.n + 2, 1 ) != 0 )
//{
// return SQLITE_NOMEM;
//}
// pMem.z[pMem->n] = 0;
// pMem.z[pMem->n+1] = 0;
if (pMem.z != null && pMem.n < pMem.z.Length)
pMem.z = pMem.z.Substring(0, pMem.n);
pMem.flags |= MEM_Term;
return SQLITE_OK;
}
/*
** Add MEM_Str to the set of representations for the given Mem. Numbers
** are converted using sqlite3_snprintf(). Converting a BLOB to a string
** is a no-op.
**
** Existing representations MEM_Int and MEM_Real are *not* invalidated.
**
** A MEM_Null value will never be passed to this function. This function is
** used for converting values to text for returning to the user (i.e. via
** sqlite3_value_text()), or for ensuring that values to be used as btree
** keys are strings. In the former case a NULL pointer is returned the
** user and the later is an internal programming error.
*/
private static int sqlite3VdbeMemStringify(Mem pMem, int enc)
{
int rc = SQLITE_OK;
int fg = pMem.flags;
const int nByte = 32;
Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
Debug.Assert((fg & MEM_Zero) == 0);
Debug.Assert((fg & (MEM_Str | MEM_Blob)) == 0);
Debug.Assert((fg & (MEM_Int | MEM_Real)) != 0);
Debug.Assert((pMem.flags & MEM_RowSet) == 0);
//assert( EIGHT_BYTE_ALIGNMENT(pMem) );
if (sqlite3VdbeMemGrow(pMem, nByte, 0) != 0)
{
return SQLITE_NOMEM;
}
/* For a Real or Integer, use sqlite3_snprintf() to produce the UTF-8
** string representation of the value. Then, if the required encoding
** is UTF-16le or UTF-16be do a translation.
**
** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16.
*/
if ((fg & MEM_Int) != 0)
{
pMem.z = pMem.u.i.ToString(); //sqlite3_snprintf(nByte, pMem.z, "%lld", pMem->u.i);
}
else
{
Debug.Assert((fg & MEM_Real) != 0);
if (Double.IsNegativeInfinity(pMem.r))
pMem.z = "-Inf";
else if (Double.IsInfinity(pMem.r))
pMem.z = "Inf";
else if (Double.IsPositiveInfinity(pMem.r))
pMem.z = "+Inf";
else if (pMem.r.ToString(CultureInfo.InvariantCulture).Contains("."))
pMem.z = pMem.r.ToString(CultureInfo.InvariantCulture).ToLower();//sqlite3_snprintf(nByte, pMem.z, "%!.15g", pMem->r);
else
pMem.z = pMem.r.ToString(CultureInfo.InvariantCulture) + ".0";
}
pMem.n = sqlite3Strlen30(pMem.z);
pMem.enc = SQLITE_UTF8;
pMem.flags |= MEM_Str | MEM_Term;
sqlite3VdbeChangeEncoding(pMem, enc);
return rc;
}
/*
** Memory cell pMem contains the context of an aggregate function.
** This routine calls the finalize method for that function. The
** result of the aggregate is stored back into pMem.
**
** Return SQLITE_ERROR if the finalizer reports an error. SQLITE_OK
** otherwise.
*/
private static int sqlite3VdbeMemFinalize(Mem pMem, FuncDef pFunc)
{
int rc = SQLITE_OK;
if (ALWAYS(pFunc != null && pFunc.xFinalize != null))
{
sqlite3_context ctx = new sqlite3_context();
Debug.Assert((pMem.flags & MEM_Null) != 0 || pFunc == pMem.u.pDef);
Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
//memset(&ctx, 0, sizeof(ctx));
ctx.s.flags = MEM_Null;
ctx.s.db = pMem.db;
ctx.pMem = pMem;
ctx.pFunc = pFunc;
pFunc.xFinalize(ctx); /* IMP: R-24505-23230 */
Debug.Assert(0 == (pMem.flags & MEM_Dyn) && pMem.xDel == null);
sqlite3DbFree(pMem.db, ref pMem.zBLOB);//zMalloc );
ctx.s.CopyTo(ref pMem);//memcpy(pMem, &ctx.s, sizeof(ctx.s));
rc = ctx.isError;
}
return rc;
}
/*
** If the memory cell contains a string value that must be freed by
** invoking an external callback, free it now. Calling this function
** does not free any Mem.zMalloc buffer.
*/
private static void sqlite3VdbeMemReleaseExternal(Mem p)
{
Debug.Assert(p.db == null || sqlite3_mutex_held(p.db.mutex));
testcase(p.flags & MEM_Agg);
testcase(p.flags & MEM_Dyn);
testcase(p.flags & MEM_RowSet);
testcase(p.flags & MEM_Frame);
if ((p.flags & (MEM_Agg | MEM_Dyn | MEM_RowSet | MEM_Frame)) != 0)
{
if ((p.flags & MEM_Agg) != 0)
{
sqlite3VdbeMemFinalize(p, p.u.pDef);
Debug.Assert((p.flags & MEM_Agg) == 0);
sqlite3VdbeMemRelease(p);
}
else if ((p.flags & MEM_Dyn) != 0 && p.xDel != null)
{
Debug.Assert((p.flags & MEM_RowSet) == 0);
p.xDel(ref p.z);
p.xDel = null;
}
else if ((p.flags & MEM_RowSet) != 0)
{
sqlite3RowSetClear(p.u.pRowSet);
}
else if ((p.flags & MEM_Frame) != 0)
{
sqlite3VdbeMemSetNull(p);
}
}
p.n = 0;
p.z = null;
p.zBLOB = null;
}
/*
** Release any memory held by the Mem. This may leave the Mem in an
** inconsistent state, for example with (Mem.z==0) and
** (Mem.type==SQLITE_TEXT).
*/
private static void sqlite3VdbeMemRelease(Mem p)
{
sqlite3VdbeMemReleaseExternal(p);
sqlite3DbFree(p.db, ref p.zBLOB);//zMalloc );
p.z = null;
//p.zMalloc = 0;
p.xDel = null;
}
/*
** Convert a 64-bit IEEE double into a 64-bit signed integer.
** If the double is too large, return 0x8000000000000000.
**
** Most systems appear to do this simply by assigning
** variables and without the extra range tests. But
** there are reports that windows throws an expection
** if the floating point value is out of range. (See ticket #2880.)
** Because we do not completely understand the problem, we will
** take the conservative approach and always do range tests
** before attempting the conversion.
*/
private static i64 doubleToInt64(double r)
{
#if SQLITE_OMIT_FLOATING_POINT
/* When floating-point is omitted, double and int64 are the same thing */
return r;
#else
/*
** Many compilers we encounter do not define constants for the
** minimum and maximum 64-bit integers, or they define them
** inconsistently. And many do not understand the "LL" notation.
** So we define our own static constants here using nothing
** larger than a 32-bit integer constant.
*/
const i64 maxInt = LARGEST_INT64;
const i64 minInt = SMALLEST_INT64;
if (r < (double)minInt)
{
return minInt;
}
else if (r > (double)maxInt)
{
/* minInt is correct here - not maxInt. It turns out that assigning
** a very large positive number to an integer results in a very large
** negative integer. This makes no sense, but it is what x86 hardware
** does so for compatibility we will do the same in software. */
return minInt;
}
else
{
return (i64)r;
}
#endif
}
/*
** Return some kind of integer value which is the best we can do
** at representing the value that *pMem describes as an integer.
** If pMem is an integer, then the value is exact. If pMem is
** a floating-point then the value returned is the integer part.
** If pMem is a string or blob, then we make an attempt to convert
** it into a integer and return that. If pMem represents an
** an SQL-NULL value, return 0.
**
** If pMem represents a string value, its encoding might be changed.
*/
private static i64 sqlite3VdbeIntValue(Mem pMem)
{
int flags;
Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
// assert( EIGHT_BYTE_ALIGNMENT(pMem) );
flags = pMem.flags;
if ((flags & MEM_Int) != 0)
{
return pMem.u.i;
}
else if ((flags & MEM_Real) != 0)
{
return doubleToInt64(pMem.r);
}
else if ((flags & (MEM_Str)) != 0)
{
i64 value = 0;
Debug.Assert(pMem.z != null || pMem.n == 0);
testcase(pMem.z == null);
sqlite3Atoi64(pMem.z, ref value, pMem.n, pMem.enc);
return value;
}
else if ((flags & (MEM_Blob)) != 0)
{
i64 value = 0;
Debug.Assert(pMem.zBLOB != null || pMem.n == 0);
testcase(pMem.zBLOB == null);
sqlite3Atoi64(Encoding.UTF8.GetString(pMem.zBLOB, 0, pMem.n), ref value, pMem.n, pMem.enc);
return value;
}
else
{
return 0;
}
}
/*
** Return the best representation of pMem that we can get into a
** double. If pMem is already a double or an integer, return its
** value. If it is a string or blob, try to convert it to a double.
** If it is a NULL, return 0.0.
*/
private static double sqlite3VdbeRealValue(Mem pMem)
{
Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
//assert( EIGHT_BYTE_ALIGNMENT(pMem) );
if ((pMem.flags & MEM_Real) != 0)
{
return pMem.r;
}
else if ((pMem.flags & MEM_Int) != 0)
{
return (double)pMem.u.i;
}
else if ((pMem.flags & (MEM_Str)) != 0)
{
/* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
double val = (double)0;
sqlite3AtoF(pMem.z, ref val, pMem.n, pMem.enc);
return val;
}
else if ((pMem.flags & (MEM_Blob)) != 0)
{
/* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
double val = (double)0;
Debug.Assert(pMem.zBLOB != null || pMem.n == 0);
sqlite3AtoF(Encoding.UTF8.GetString(pMem.zBLOB, 0, pMem.n), ref val, pMem.n, pMem.enc);
return val;
}
else
{
/* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
return (double)0;
}
}
/*
** The MEM structure is already a MEM_Real. Try to also make it a
** MEM_Int if we can.
*/
private static void sqlite3VdbeIntegerAffinity(Mem pMem)
{
Debug.Assert((pMem.flags & MEM_Real) != 0);
Debug.Assert((pMem.flags & MEM_RowSet) == 0);
Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
//assert( EIGHT_BYTE_ALIGNMENT(pMem) );
pMem.u.i = doubleToInt64(pMem.r);
/* Only mark the value as an integer if
**
** (1) the round-trip conversion real->int->real is a no-op, and
** (2) The integer is neither the largest nor the smallest
** possible integer (ticket #3922)
**
** The second and third terms in the following conditional enforces
** the second condition under the assumption that addition overflow causes
** values to wrap around. On x86 hardware, the third term is always
** true and could be omitted. But we leave it in because other
** architectures might behave differently.
*/
if (pMem.r == (double)pMem.u.i && pMem.u.i > SMALLEST_INT64
&& ALWAYS(pMem.u.i < LARGEST_INT64))
{
pMem.flags |= MEM_Int;
}
}
/*
** Convert pMem to type integer. Invalidate any prior representations.
*/
private static int sqlite3VdbeMemIntegerify(Mem pMem)
{
Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
Debug.Assert((pMem.flags & MEM_RowSet) == 0);
//assert( EIGHT_BYTE_ALIGNMENT(pMem) );
pMem.u.i = sqlite3VdbeIntValue(pMem);
MemSetTypeFlag(pMem, MEM_Int);
return SQLITE_OK;
}
/*
** Convert pMem so that it is of type MEM_Real.
** Invalidate any prior representations.
*/
private static int sqlite3VdbeMemRealify(Mem pMem)
{
Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
//assert( EIGHT_BYTE_ALIGNMENT(pMem) );
pMem.r = sqlite3VdbeRealValue(pMem);
MemSetTypeFlag(pMem, MEM_Real);
return SQLITE_OK;
}
/*
** Convert pMem so that it has types MEM_Real or MEM_Int or both.
** Invalidate any prior representations.
**
** Every effort is made to force the conversion, even if the input
** is a string that does not look completely like a number. Convert
** as much of the string as we can and ignore the rest.
*/
private static int sqlite3VdbeMemNumerify(Mem pMem)
{
if ((pMem.flags & (MEM_Int | MEM_Real | MEM_Null)) == 0)
{
Debug.Assert((pMem.flags & (MEM_Blob | MEM_Str)) != 0);
Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
if ((pMem.flags & MEM_Blob) != 0 && pMem.z == null)
{
if (0 == sqlite3Atoi64(Encoding.UTF8.GetString(pMem.zBLOB, 0, pMem.zBLOB.Length), ref pMem.u.i, pMem.n, pMem.enc))
MemSetTypeFlag(pMem, MEM_Int);
else
{
pMem.r = sqlite3VdbeRealValue(pMem);
MemSetTypeFlag(pMem, MEM_Real);
sqlite3VdbeIntegerAffinity(pMem);
}
}
else if (0 == sqlite3Atoi64(pMem.z, ref pMem.u.i, pMem.n, pMem.enc))
{
MemSetTypeFlag(pMem, MEM_Int);
}
else
{
pMem.r = sqlite3VdbeRealValue(pMem);
MemSetTypeFlag(pMem, MEM_Real);
sqlite3VdbeIntegerAffinity(pMem);
}
}
Debug.Assert((pMem.flags & (MEM_Int | MEM_Real | MEM_Null)) != 0);
pMem.flags = (ushort)(pMem.flags & ~(MEM_Str | MEM_Blob));
return SQLITE_OK;
}
#if !SQLITE_OMIT_FLOATING_POINT
/*
** Delete any previous value and set the value stored in pMem to NULL.
*/
private static void sqlite3VdbeMemSetNull(Mem pMem)
{
if ((pMem.flags & MEM_Frame) != 0)
{
VdbeFrame pFrame = pMem.u.pFrame;
pFrame.pParent = pFrame.v.pDelFrame;
pFrame.v.pDelFrame = pFrame;
}
if ((pMem.flags & MEM_RowSet) != 0)
{
sqlite3RowSetClear(pMem.u.pRowSet);
}
MemSetTypeFlag(pMem, MEM_Null);
sqlite3_free(ref pMem.zBLOB);
pMem.z = null;
pMem.type = SQLITE_NULL;
}
#endif
/*
** Delete any previous value and set the value to be a BLOB of length
** n containing all zeros.
*/
private static void sqlite3VdbeMemSetZeroBlob(Mem pMem, int n)
{
sqlite3VdbeMemRelease(pMem);
pMem.flags = MEM_Blob | MEM_Zero;
pMem.type = SQLITE_BLOB;
pMem.n = 0;
if (n < 0)
n = 0;
pMem.u.nZero = n;
pMem.enc = SQLITE_UTF8;
#if SQLITE_OMIT_INCRBLOB
sqlite3VdbeMemGrow(pMem, n, 0);
//if( pMem.z!= null ){
pMem.n = n;
pMem.z = null;//memset(pMem.z, 0, n);
pMem.zBLOB = sqlite3Malloc(n);
//}
#endif
}
/*
** Delete any previous value and set the value stored in pMem to val,
** manifest type INTEGER.
*/
private static void sqlite3VdbeMemSetInt64(Mem pMem, i64 val)
{
sqlite3VdbeMemRelease(pMem);
pMem.u.i = val;
pMem.flags = MEM_Int;
pMem.type = SQLITE_INTEGER;
}
/*
** Delete any previous value and set the value stored in pMem to val,
** manifest type REAL.
*/
private static void sqlite3VdbeMemSetDouble(Mem pMem, double val)
{
if (sqlite3IsNaN(val))
{
sqlite3VdbeMemSetNull(pMem);
}
else
{
sqlite3VdbeMemRelease(pMem);
pMem.r = val;
pMem.flags = MEM_Real;
pMem.type = SQLITE_FLOAT;
}
}
/*
** Delete any previous value and set the value of pMem to be an
** empty boolean index.
*/
private static void sqlite3VdbeMemSetRowSet(Mem pMem)
{
sqlite3 db = pMem.db;
Debug.Assert(db != null);
Debug.Assert((pMem.flags & MEM_RowSet) == 0);
sqlite3VdbeMemRelease(pMem);
//pMem.zMalloc = sqlite3DbMallocRaw( db, 64 );
//if ( db.mallocFailed != 0 )
//{
// pMem.flags = MEM_Null;
//}
//else
{
//Debug.Assert( pMem.zMalloc );
pMem.u.pRowSet = new RowSet(db, 5);// sqlite3RowSetInit( db, pMem.zMalloc,
// sqlite3DbMallocSize( db, pMem.zMalloc ) );
Debug.Assert(pMem.u.pRowSet != null);
pMem.flags = MEM_RowSet;
}
}
/*
** Return true if the Mem object contains a TEXT or BLOB that is
** too large - whose size exceeds p.db.aLimit[SQLITE_LIMIT_LENGTH].
*/
private static bool sqlite3VdbeMemTooBig(Mem p)
{
//Debug.Assert( p.db != null );
if ((p.flags & (MEM_Str | MEM_Blob)) != 0)
{
int n = p.n;
if ((p.flags & MEM_Zero) != 0)
{
n += p.u.nZero;
}
return n > p.db.aLimit[SQLITE_LIMIT_LENGTH];
}
return false;
}
#if SQLITE_DEBUG
/*
** This routine prepares a memory cell for modication by breaking
** its link to a shallow copy and by marking any current shallow
** copies of this cell as invalid.
**
** This is used for testing and debugging only - to make sure shallow
** copies are not misused.
*/
private static void sqlite3VdbeMemPrepareToChange(Vdbe pVdbe, Mem pMem)
{
int i;
Mem pX;
for (i = 1; i <= pVdbe.nMem; i++)
{
pX = pVdbe.aMem[i];
if (pX.pScopyFrom == pMem)
{
pX.flags |= MEM_Invalid;
pX.pScopyFrom = null;
}
}
pMem.pScopyFrom = null;
}
#endif //* SQLITE_DEBUG */
/*
** Size of struct Mem not including the Mem.zMalloc member.
*/
//#define MEMCELLSIZE (size_t)(&(((Mem *)0).zMalloc))
/*
** Make an shallow copy of pFrom into pTo. Prior contents of
** pTo are freed. The pFrom.z field is not duplicated. If
** pFrom.z is used, then pTo.z points to the same thing as pFrom.z
** and flags gets srcType (either MEM_Ephem or MEM_Static).
*/
private static void sqlite3VdbeMemShallowCopy(Mem pTo, Mem pFrom, int srcType)
{
Debug.Assert((pFrom.flags & MEM_RowSet) == 0);
sqlite3VdbeMemReleaseExternal(pTo);
pFrom.CopyTo(ref pTo);// memcpy(pTo, pFrom, MEMCELLSIZE);
pTo.xDel = null;
if ((pFrom.flags & MEM_Static) != 0)
{
pTo.flags = (u16)(pFrom.flags & ~(MEM_Dyn | MEM_Static | MEM_Ephem));
Debug.Assert(srcType == MEM_Ephem || srcType == MEM_Static);
pTo.flags |= (u16)srcType;
}
}
/*
** Make a full copy of pFrom into pTo. Prior contents of pTo are
** freed before the copy is made.
*/
private static int sqlite3VdbeMemCopy(Mem pTo, Mem pFrom)
{
int rc = SQLITE_OK;
Debug.Assert((pFrom.flags & MEM_RowSet) == 0);
sqlite3VdbeMemReleaseExternal(pTo);
pFrom.CopyTo(ref pTo);// memcpy(pTo, pFrom, MEMCELLSIZE);
pTo.flags = (u16)(pTo.flags & ~MEM_Dyn);
if ((pTo.flags & (MEM_Str | MEM_Blob)) != 0)
{
if (0 == (pFrom.flags & MEM_Static))
{
pTo.flags |= MEM_Ephem;
rc = sqlite3VdbeMemMakeWriteable(pTo);
}
}
return rc;
}
/*
** Transfer the contents of pFrom to pTo. Any existing value in pTo is
** freed. If pFrom contains ephemeral data, a copy is made.
**
** pFrom contains an SQL NULL when this routine returns.
*/
private static void sqlite3VdbeMemMove(Mem pTo, Mem pFrom)
{
Debug.Assert(pFrom.db == null || sqlite3_mutex_held(pFrom.db.mutex));
Debug.Assert(pTo.db == null || sqlite3_mutex_held(pTo.db.mutex));
Debug.Assert(pFrom.db == null || pTo.db == null || pFrom.db == pTo.db);
sqlite3VdbeMemRelease(pTo);
pFrom.CopyTo(ref pTo);// memcpy(pTo, pFrom, Mem).Length;
pFrom.flags = MEM_Null;
pFrom.xDel = null;
pFrom.z = null;
sqlite3_free(ref pFrom.zBLOB); //pFrom.zMalloc=0;
}
/*
** Change the value of a Mem to be a string or a BLOB.
**
** The memory management strategy depends on the value of the xDel
** parameter. If the value passed is SQLITE_TRANSIENT, then the
** string is copied into a (possibly existing) buffer managed by the
** Mem structure. Otherwise, any existing buffer is freed and the
** pointer copied.
**
** If the string is too large (if it exceeds the SQLITE_LIMIT_LENGTH
** size limit) then no memory allocation occurs. If the string can be
** stored without allocating memory, then it is. If a memory allocation
** is required to store the string, then value of pMem is unchanged. In
** either case, SQLITE_TOOBIG is returned.
*/
private static int sqlite3VdbeMemSetBlob(
Mem pMem, /* Memory cell to set to string value */
byte[] zBlob, /* Blob pointer */
int n, /* Bytes in Blob */
u8 enc, /* 0 for BLOBs */
dxDel xDel /* Destructor function */
)
{
return sqlite3VdbeMemSetBlob(pMem, zBlob, 0, n >= 0 ? n : zBlob.Length, enc, xDel);
} // Call w/o offset
private static int sqlite3VdbeMemSetBlob(
Mem pMem, /* Memory cell to set to string value */
byte[] zBlob, /* Blob pointer */
int offset, /* offset into string */
int n, /* Bytes in string, or negative */
u8 enc, /* Encoding of z. 0 for BLOBs */
dxDel xDel//)(void*)/* Destructor function */
)
{
int nByte = n; /* New value for pMem->n */
int iLimit; /* Maximum allowed string or blob size */
Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
Debug.Assert((pMem.flags & MEM_RowSet) == 0);
/* If zBlob is a NULL pointer, set pMem to contain an SQL NULL. */
if (zBlob == null || zBlob.Length < offset)
{
sqlite3VdbeMemSetNull(pMem);
return SQLITE_OK;
}
if (pMem.db != null)
{
iLimit = pMem.db.aLimit[SQLITE_LIMIT_LENGTH];
}
else
{
iLimit = SQLITE_MAX_LENGTH;
}
if (nByte < 0)
{
Debug.Assert(enc != 0);
if (enc == SQLITE_UTF8)
{
for (nByte = 0; nByte <= iLimit && nByte < zBlob.Length - offset && zBlob[offset + nByte] != 0; nByte++)
{
}
}
else
{
for (nByte = 0; nByte <= iLimit && zBlob[nByte + offset] != 0 || zBlob[offset + nByte + 1] != 0; nByte += 2)
{
}
}
}
/* The following block sets the new values of Mem.z and Mem.xDel. It
** also sets a flag in local variable "flags" to indicate the memory
** management (one of MEM_Dyn or MEM_Static).
*/
Debug.Assert(enc == 0);
{
pMem.z = null;
pMem.zBLOB = sqlite3Malloc(n);
Buffer.BlockCopy(zBlob, offset, pMem.zBLOB, 0, n);
}
pMem.n = nByte;
pMem.flags = MEM_Blob | MEM_Term;
pMem.enc = (enc == 0 ? SQLITE_UTF8 : enc);
pMem.type = (enc == 0 ? SQLITE_BLOB : SQLITE_TEXT);
if (nByte > iLimit)
{
return SQLITE_TOOBIG;
}
return SQLITE_OK;
}
private static int sqlite3VdbeMemSetStr(
Mem pMem, /* Memory cell to set to string value */
string z, /* String pointer */
int n, /* Bytes in string, or negative */
u8 enc, /* Encoding of z. 0 for BLOBs */
dxDel xDel /* Destructor function */
)
{
return sqlite3VdbeMemSetStr(pMem, z, 0, n, enc, xDel);
} // Call w/o offset
private static int sqlite3VdbeMemSetStr(
Mem pMem, /* Memory cell to set to string value */
string z, /* String pointer */
int offset, /* offset into string */
int n, /* Bytes in string, or negative */
u8 enc, /* Encoding of z. 0 for BLOBs */
dxDel xDel//)(void*)/* Destructor function */
)
{
int nByte = n; /* New value for pMem->n */
int iLimit; /* Maximum allowed string or blob size */
u16 flags = 0; /* New value for pMem->flags */
Debug.Assert(pMem.db == null || sqlite3_mutex_held(pMem.db.mutex));
Debug.Assert((pMem.flags & MEM_RowSet) == 0);
/* If z is a NULL pointer, set pMem to contain an SQL NULL. */
if (z == null || z.Length < offset)
{
sqlite3VdbeMemSetNull(pMem);
return SQLITE_OK;
}
if (pMem.db != null)
{
iLimit = pMem.db.aLimit[SQLITE_LIMIT_LENGTH];
}
else
{
iLimit = SQLITE_MAX_LENGTH;
}
flags = (u16)(enc == 0 ? MEM_Blob : MEM_Str);
if (nByte < 0)
{
Debug.Assert(enc != 0);
if (enc == SQLITE_UTF8)
{
for (nByte = 0; nByte <= iLimit && nByte < z.Length - offset && z[offset + nByte] != 0; nByte++)
{
}
}
else
{
for (nByte = 0; nByte <= iLimit && z[nByte + offset] != 0 || z[offset + nByte + 1] != 0; nByte += 2)
{
}
}
flags |= MEM_Term;
}
/* The following block sets the new values of Mem.z and Mem.xDel. It
** also sets a flag in local variable "flags" to indicate the memory
** management (one of MEM_Dyn or MEM_Static).
*/
if (xDel == SQLITE_TRANSIENT)
{
u32 nAlloc = (u32)nByte;
if ((flags & MEM_Term) != 0)
{
nAlloc += (u32)(enc == SQLITE_UTF8 ? 1 : 2);
}
if (nByte > iLimit)
{
return SQLITE_TOOBIG;
}
if (sqlite3VdbeMemGrow(pMem, (int)nAlloc, 0) != 0)
{
return SQLITE_NOMEM;
}
//if ( nAlloc < z.Length )
//pMem.z = new byte[nAlloc]; Buffer.BlockCopy( z, 0, pMem.z, 0, (int)nAlloc ); }
//else
if (enc == 0)
{
pMem.z = null;
pMem.zBLOB = sqlite3Malloc(n);
for (int i = 0; i < n && i < z.Length - offset; i++)
pMem.zBLOB[i] = (byte)z[offset + i];
}
else
{
pMem.z = n > 0 && z.Length - offset > n ? z.Substring(offset, n) : z.Substring(offset);//memcpy(pMem.z, z, nAlloc);
sqlite3_free(ref pMem.zBLOB);
}
}
else if (xDel == SQLITE_DYNAMIC)
{
sqlite3VdbeMemRelease(pMem);
//pMem.zMalloc = pMem.z = (char*)z;
if (enc == 0)
{
pMem.z = null;
if (pMem.zBLOB != null)
sqlite3_free(ref pMem.zBLOB);
pMem.zBLOB = Encoding.UTF8.GetBytes(offset == 0 ? z : z.Length + offset < n ? z.Substring(offset, n) : z.Substring(offset));
}
else
{
pMem.z = n > 0 && z.Length - offset > n ? z.Substring(offset, n) : z.Substring(offset);//memcpy(pMem.z, z, nAlloc);
sqlite3_free(ref pMem.zBLOB);
}
pMem.xDel = null;
}
else
{
sqlite3VdbeMemRelease(pMem);
if (enc == 0)
{
pMem.z = null;
if (pMem.zBLOB != null)
sqlite3_free(ref pMem.zBLOB);
pMem.zBLOB = Encoding.UTF8.GetBytes(offset == 0 ? z : z.Length + offset < n ? z.Substring(offset, n) : z.Substring(offset));
}
else
{
pMem.z = n > 0 && z.Length - offset > n ? z.Substring(offset, n) : z.Substring(offset);//memcpy(pMem.z, z, nAlloc);
sqlite3_free(ref pMem.zBLOB);
}
pMem.xDel = xDel;
flags |= (u16)((xDel == SQLITE_STATIC) ? MEM_Static : MEM_Dyn);
}
pMem.n = nByte;
pMem.flags = flags;
pMem.enc = (enc == 0 ? SQLITE_UTF8 : enc);
pMem.type = (enc == 0 ? SQLITE_BLOB : SQLITE_TEXT);
#if !SQLITE_OMIT_UTF16
if( pMem.enc!=SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem)!=0 ){
return SQLITE_NOMEM;
}
#endif
if (nByte > iLimit)
{
return SQLITE_TOOBIG;
}
return SQLITE_OK;
}
/*
** Compare the values contained by the two memory cells, returning
** negative, zero or positive if pMem1 is less than, equal to, or greater
** than pMem2. Sorting order is NULL's first, followed by numbers (integers
** and reals) sorted numerically, followed by text ordered by the collating
** sequence pColl and finally blob's ordered by memcmp().
**
** Two NULL values are considered equal by this function.
*/
private static int sqlite3MemCompare(Mem pMem1, Mem pMem2, CollSeq pColl)
{
int rc;
int f1, f2;
int combined_flags;
f1 = pMem1.flags;
f2 = pMem2.flags;
combined_flags = f1 | f2;
Debug.Assert((combined_flags & MEM_RowSet) == 0);
/* If one value is NULL, it is less than the other. If both values
** are NULL, return 0.
*/
if ((combined_flags & MEM_Null) != 0)
{
return (f2 & MEM_Null) - (f1 & MEM_Null);
}
/* If one value is a number and the other is not, the number is less.
** If both are numbers, compare as reals if one is a real, or as integers
** if both values are integers.
*/
if ((combined_flags & (MEM_Int | MEM_Real)) != 0)
{
if ((f1 & (MEM_Int | MEM_Real)) == 0)
{
return 1;
}
if ((f2 & (MEM_Int | MEM_Real)) == 0)
{
return -1;
}
if ((f1 & f2 & MEM_Int) == 0)
{
double r1, r2;
if ((f1 & MEM_Real) == 0)
{
r1 = (double)pMem1.u.i;
}
else
{
r1 = pMem1.r;
}
if ((f2 & MEM_Real) == 0)
{
r2 = (double)pMem2.u.i;
}
else
{
r2 = pMem2.r;
}
if (r1 < r2)
return -1;
if (r1 > r2)
return 1;
return 0;
}
else
{
Debug.Assert((f1 & MEM_Int) != 0);
Debug.Assert((f2 & MEM_Int) != 0);
if (pMem1.u.i < pMem2.u.i)
return -1;
if (pMem1.u.i > pMem2.u.i)
return 1;
return 0;
}
}
/* If one value is a string and the other is a blob, the string is less.
** If both are strings, compare using the collating functions.
*/
if ((combined_flags & MEM_Str) != 0)
{
if ((f1 & MEM_Str) == 0)
{
return 1;
}
if ((f2 & MEM_Str) == 0)
{
return -1;
}
Debug.Assert(pMem1.enc == pMem2.enc);
Debug.Assert(pMem1.enc == SQLITE_UTF8 ||
pMem1.enc == SQLITE_UTF16LE || pMem1.enc == SQLITE_UTF16BE);
/* The collation sequence must be defined at this point, even if
** the user deletes the collation sequence after the vdbe program is
** compiled (this was not always the case).
*/
Debug.Assert(pColl == null || pColl.xCmp != null);
if (pColl != null)
{
if (pMem1.enc == pColl.enc)
{
/* The strings are already in the correct encoding. Call the
** comparison function directly */
return pColl.xCmp(pColl.pUser, pMem1.n, pMem1.z, pMem2.n, pMem2.z);
}
else
{
string v1, v2;
int n1, n2;
Mem c1 = null;
Mem c2 = null;
c1 = sqlite3Malloc(c1);// memset( &c1, 0, sizeof( c1 ) );
c2 = sqlite3Malloc(c2);// memset( &c2, 0, sizeof( c2 ) );
sqlite3VdbeMemShallowCopy(c1, pMem1, MEM_Ephem);
sqlite3VdbeMemShallowCopy(c2, pMem2, MEM_Ephem);
v1 = sqlite3ValueText((sqlite3_value)c1, pColl.enc);
n1 = v1 == null ? 0 : c1.n;
v2 = sqlite3ValueText((sqlite3_value)c2, pColl.enc);
n2 = v2 == null ? 0 : c2.n;
rc = pColl.xCmp(pColl.pUser, n1, v1, n2, v2);
sqlite3VdbeMemRelease(c1);
sqlite3VdbeMemRelease(c2);
return rc;
}
}
/* If a NULL pointer was passed as the collate function, fall through
** to the blob case and use memcmp(). */
}
/* Both values must be blobs. Compare using memcmp(). */
if ((pMem1.flags & MEM_Blob) != 0)
if (pMem1.zBLOB != null)
rc = memcmp(pMem1.zBLOB, pMem2.zBLOB, (pMem1.n > pMem2.n) ? pMem2.n : pMem1.n);
else
rc = memcmp(pMem1.z, pMem2.zBLOB, (pMem1.n > pMem2.n) ? pMem2.n : pMem1.n);
else
rc = memcmp(pMem1.z, pMem2.z, (pMem1.n > pMem2.n) ? pMem2.n : pMem1.n);
if (rc == 0)
{
rc = pMem1.n - pMem2.n;
}
return rc;
}
/*
** Move data out of a btree key or data field and into a Mem structure.
** The data or key is taken from the entry that pCur is currently pointing
** to. offset and amt determine what portion of the data or key to retrieve.
** key is true to get the key or false to get data. The result is written
** into the pMem element.
**
** The pMem structure is assumed to be uninitialized. Any prior content
** is overwritten without being freed.
**
** If this routine fails for any reason (malloc returns NULL or unable
** to read from the disk) then the pMem is left in an inconsistent state.
*/
private static int sqlite3VdbeMemFromBtree(
BtCursor pCur, /* Cursor pointing at record to retrieve. */
int offset, /* Offset from the start of data to return bytes from. */
int amt, /* Number of bytes to return. */
bool key, /* If true, retrieve from the btree key, not data. */
Mem pMem /* OUT: Return data in this Mem structure. */
)
{
byte[] zData; /* Data from the btree layer */
int available = 0; /* Number of bytes available on the local btree page */
int rc = SQLITE_OK; /* Return code */
Debug.Assert(sqlite3BtreeCursorIsValid(pCur));
/* Note: the calls to BtreeKeyFetch() and DataFetch() below assert()
** that both the BtShared and database handle mutexes are held. */
Debug.Assert((pMem.flags & MEM_RowSet) == 0);
int outOffset = -1;
if (key)
{
zData = sqlite3BtreeKeyFetch(pCur, ref available, ref outOffset);
}
else
{
zData = sqlite3BtreeDataFetch(pCur, ref available, ref outOffset);
}
Debug.Assert(zData != null);
if (offset + amt <= available && (pMem.flags & MEM_Dyn) == 0)
{
sqlite3VdbeMemRelease(pMem);
pMem.zBLOB = sqlite3Malloc(amt);
Buffer.BlockCopy(zData, offset, pMem.zBLOB, 0, amt);//pMem.z = &zData[offset];
pMem.flags = MEM_Blob | MEM_Ephem;
}
else if (SQLITE_OK == (rc = sqlite3VdbeMemGrow(pMem, amt + 2, 0)))
{
pMem.enc = 0;
pMem.type = SQLITE_BLOB;
pMem.z = null;
pMem.zBLOB = sqlite3Malloc(amt);
pMem.flags = MEM_Blob | MEM_Dyn | MEM_Term;
if (key)
{
rc = sqlite3BtreeKey(pCur, (u32)offset, (u32)amt, pMem.zBLOB);
}
else
{
rc = sqlite3BtreeData(pCur, (u32)offset, (u32)amt, pMem.zBLOB);//pMem.z = pMem_z ;
}
//pMem.z[amt] = 0;
//pMem.z[amt+1] = 0;
if (rc != SQLITE_OK)
{
sqlite3VdbeMemRelease(pMem);
}
}
pMem.n = amt;
sqlite3_free(ref zData);
return rc;
}
/* This function is only available internally, it is not part of the
** external API. It works in a similar way to sqlite3_value_text(),
** except the data returned is in the encoding specified by the second
** parameter, which must be one of SQLITE_UTF16BE, SQLITE_UTF16LE or
** SQLITE_UTF8.
**
** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
** If that is the case, then the result must be aligned on an even byte
** boundary.
*/
private static string sqlite3ValueText(sqlite3_value pVal, int enc)
{
if (pVal == null)
return null;
Debug.Assert(pVal.db == null || sqlite3_mutex_held(pVal.db.mutex));
Debug.Assert((enc & 3) == (enc & ~SQLITE_UTF16_ALIGNED));
Debug.Assert((pVal.flags & MEM_RowSet) == 0);
if ((pVal.flags & MEM_Null) != 0)
{
return null;
}
Debug.Assert((MEM_Blob >> 3) == MEM_Str);
pVal.flags |= (u16)((pVal.flags & MEM_Blob) >> 3);
if ((pVal.flags & MEM_Zero) != 0)
sqlite3VdbeMemExpandBlob(pVal); // expandBlob(pVal);
if ((pVal.flags & MEM_Str) != 0)
{
if (sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED) != SQLITE_OK)
{
return null; // Encoding Error
}
if ((enc & SQLITE_UTF16_ALIGNED) != 0 && 1 == (1 & (pVal.z[0]))) //1==(1&SQLITE_PTR_TO_INT(pVal.z))
{
Debug.Assert((pVal.flags & (MEM_Ephem | MEM_Static)) != 0);
if (sqlite3VdbeMemMakeWriteable(pVal) != SQLITE_OK)
{
return null;
}
}
sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-59893-45467 */
}
else
{
Debug.Assert((pVal.flags & MEM_Blob) == 0);
sqlite3VdbeMemStringify(pVal, enc);
// assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
}
Debug.Assert(pVal.enc == (enc & ~SQLITE_UTF16_ALIGNED) || pVal.db == null
//|| pVal.db.mallocFailed != 0
);
if (pVal.enc == (enc & ~SQLITE_UTF16_ALIGNED))
{
return pVal.z;
}
else
{
return null;
}
}
/*
** Create a new sqlite3_value object.
*/
private static sqlite3_value sqlite3ValueNew(sqlite3 db)
{
Mem p = null;
p = sqlite3DbMallocZero(db, p);
//if ( p != null )
//{
p.flags = MEM_Null;
p.type = SQLITE_NULL;
p.db = db;
//}
return p;
}
/*
** Create a new sqlite3_value object, containing the value of pExpr.
**
** This only works for very simple expressions that consist of one constant
** token (i.e. "5", "5.1", "'a string'"). If the expression can
** be converted directly into a value, then the value is allocated and
** a pointer written to ppVal. The caller is responsible for deallocating
** the value by passing it to sqlite3ValueFree() later on. If the expression
** cannot be converted to a value, then ppVal is set to NULL.
*/
private static int sqlite3ValueFromExpr(
sqlite3 db, /* The database connection */
Expr pExpr, /* The expression to evaluate */
int enc, /* Encoding to use */
char affinity, /* Affinity to use */
ref sqlite3_value ppVal /* Write the new value here */
)
{
int op;
string zVal = "";
sqlite3_value pVal = null;
int negInt = 1;
string zNeg = "";
if (pExpr == null)
{
ppVal = null;
return SQLITE_OK;
}
op = pExpr.op;
/* op can only be TK_REGISTER if we have compiled with SQLITE_ENABLE_STAT2.
** The ifdef here is to enable us to achieve 100% branch test coverage even
** when SQLITE_ENABLE_STAT2 is omitted.
*/
#if SQLITE_ENABLE_STAT2
if ( op == TK_REGISTER )
op = pExpr.op2;
#else
if (NEVER(op == TK_REGISTER)) op = pExpr.op2;
#endif
/* Handle negative integers in a single step. This is needed in the
** case when the value is -9223372036854775808.
*/
if (op == TK_UMINUS
&& (pExpr.pLeft.op == TK_INTEGER || pExpr.pLeft.op == TK_FLOAT))
{
pExpr = pExpr.pLeft;
op = pExpr.op;
negInt = -1;
zNeg = "-";
}
if (op == TK_STRING || op == TK_FLOAT || op == TK_INTEGER)
{
pVal = sqlite3ValueNew(db);
if (pVal == null)
goto no_mem;
if (ExprHasProperty(pExpr, EP_IntValue))
{
sqlite3VdbeMemSetInt64(pVal, (i64)pExpr.u.iValue * negInt);
}
else
{
zVal = sqlite3MPrintf(db, "%s%s", zNeg, pExpr.u.zToken);
//if ( zVal == null ) goto no_mem;
sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
if (op == TK_FLOAT)
pVal.type = SQLITE_FLOAT;
}
if ((op == TK_INTEGER || op == TK_FLOAT) && affinity == SQLITE_AFF_NONE)
{
sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);
}
else
{
sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
}
if ((pVal.flags & (MEM_Int | MEM_Real)) != 0)
pVal.flags = (ushort)(pVal.flags & ~MEM_Str);
if (enc != SQLITE_UTF8)
{
sqlite3VdbeChangeEncoding(pVal, enc);
}
}
if (enc != SQLITE_UTF8)
{
sqlite3VdbeChangeEncoding(pVal, enc);
}
else if (op == TK_UMINUS)
{
/* This branch happens for multiple negative signs. Ex: -(-5) */
if (SQLITE_OK == sqlite3ValueFromExpr(db, pExpr.pLeft, enc, affinity, ref pVal))
{
sqlite3VdbeMemNumerify(pVal);
if (pVal.u.i == SMALLEST_INT64)
{
pVal.flags &= MEM_Int;
pVal.flags |= MEM_Real;
pVal.r = (double)LARGEST_INT64;
}
else
{
pVal.u.i = -pVal.u.i;
}
pVal.r = -pVal.r;
sqlite3ValueApplyAffinity(pVal, affinity, enc);
}
}
else if (op == TK_NULL)
{
pVal = sqlite3ValueNew(db);
if (pVal == null)
goto no_mem;
}
#if !SQLITE_OMIT_BLOB_LITERAL
else if (op == TK_BLOB)
{
int nVal;
Debug.Assert(pExpr.u.zToken[0] == 'x' || pExpr.u.zToken[0] == 'X');
Debug.Assert(pExpr.u.zToken[1] == '\'');
pVal = sqlite3ValueNew(db);
if (null == pVal)
goto no_mem;
zVal = pExpr.u.zToken.Substring(2);
nVal = sqlite3Strlen30(zVal) - 1;
Debug.Assert(zVal[nVal] == '\'');
byte[] blob = sqlite3HexToBlob(db, zVal, nVal);
sqlite3VdbeMemSetStr(pVal, Encoding.UTF8.GetString(blob, 0, blob.Length), nVal / 2, 0, SQLITE_DYNAMIC);
}
#endif
if (pVal != null)
{
sqlite3VdbeMemStoreType(pVal);
}
ppVal = pVal;
return SQLITE_OK;
no_mem:
//db.mallocFailed = 1;
sqlite3DbFree(db, ref zVal);
pVal = null;// sqlite3ValueFree(pVal);
ppVal = null;
return SQLITE_NOMEM;
}
/*
** Change the string value of an sqlite3_value object
*/
private static void sqlite3ValueSetStr(
sqlite3_value v, /* Value to be set */
int n, /* Length of string z */
string z, /* Text of the new string */
u8 enc, /* Encoding to use */
dxDel xDel//)(void*) /* Destructor for the string */
)
{
if (v != null)
sqlite3VdbeMemSetStr(v, z, n, enc, xDel);
}
/*
** Free an sqlite3_value object
*/
private static void sqlite3ValueFree(ref sqlite3_value v)
{
if (v == null)
return;
sqlite3VdbeMemRelease(v);
sqlite3DbFree(v.db, ref v);
}
/*
** Return the number of bytes in the sqlite3_value object assuming
** that it uses the encoding "enc"
*/
private static int sqlite3ValueBytes(sqlite3_value pVal, int enc)
{
Mem p = (Mem)pVal;
if ((p.flags & MEM_Blob) != 0 || sqlite3ValueText(pVal, enc) != null)
{
if ((p.flags & MEM_Zero) != 0)
{
return p.n + p.u.nZero;
}
else
{
return p.z == null ? p.zBLOB.Length : p.n;
}
}
return 0;
}
}
}
Reference in a new issue View git blame Copy permalink