nettika/mattercontrol
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
mattercontrol/Community.CsharpSqlite/src/vdbemem_c.cs
larsbrubaker f4c1b0b85c Commit of the code
2014-01-29 19:09:30 -08:00

1607 lines
No EOL
51 KiB
C#
Raw Blame History

using System;
using System.Diagnostics;
using System.Text;
using i64 = System.Int64;
using u8 = System.Byte;
using u16 = System.UInt16;
using u32 = System.UInt32;
namespace Community.CsharpSqlite
{
using sqlite3_value = Sqlite3.Mem;
using System.Globalization;
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)
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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).
*/
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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].
*/
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.
*/
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).
*/
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.
*/
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.
*/
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.
*/
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
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;
}
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
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.
*/
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.
*/
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.
*/
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.
*/
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.
*/
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
*/
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
*/
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"
*/
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