WebSVN – wasCSharpSQLite – Blame – Rev 1 – /trunk/Community.CsharpSqlite/src/vdbeaux

        // TO DO -- PASS TESTS WITH THIS ON Debug.Assert( pMem.n + ( ( pMem.flags & MEM_Zero ) != 0 ? pMem.u.nZero : 0 ) == (int)sqlite3VdbeSerialTypeLen( serial_type ) );

3534

Debug.Assert( pMem.n <= nBuf );

3535

if ( ( len = (u32)pMem.n ) != 0 )

3536

if ( pMem.zBLOB == null && string.IsNullOrEmpty( pMem.z ) )

3537

{

3538

}

3539

else if ( pMem.zBLOB != null && (( pMem.flags & MEM_Blob ) != 0 || pMem.z == null ))

3540

Buffer.BlockCopy( pMem.zBLOB, 0, buf, offset, (int)len );//memcpy( buf, pMem.z, len );

3541

else

3542

Buffer.BlockCopy( Encoding.UTF8.GetBytes( pMem.z ), 0, buf, offset, (int)len );//memcpy( buf, pMem.z, len );

3543

if ( ( pMem.flags & MEM_Zero ) != 0 )

3544

{

3545

len += (u32)pMem.u.nZero;

3546

Debug.Assert( nBuf >= 0 );

3547

if ( len > (u32)nBuf )

{

len = (u32)nBuf;

}

Array.Clear( buf, offset + pMem.n, (int)( len - pMem.n ) );// memset( &buf[pMem.n], 0, len - pMem.n );

}

return len;

}

/* NULL or constants 0 or 1 */

return 0;

}

/*

** Deserialize the data blob pointed to by buf as serial type serial_type

3562

** and store the result in pMem. Return the number of bytes read.

3563

*/

3564

static u32 sqlite3VdbeSerialGet(

3565

byte[] buf, /* Buffer to deserialize from */

3566

int offset, /* Offset into Buffer */

3567

u32 serial_type, /* Serial type to deserialize */

3568

Mem pMem /* Memory cell to write value into */

3569

)

3570

{

3571

switch ( serial_type )

3572

{

3573

case 10: /* Reserved for future use */

3574

case 11: /* Reserved for future use */

3575

case 0:

3576

{ /* NULL */

3577

pMem.flags = MEM_Null;

pMem.n = 0;

pMem.z = null;

pMem.zBLOB = null;

break;

}

case 1:

{ /* 1-byte signed integer */

3585

pMem.u.i = (sbyte)buf[offset + 0];

3586

pMem.flags = MEM_Int;

return 1;

}

case 2:

{ /* 2-byte signed integer */

3591

pMem.u.i = (int)( ( ( (sbyte)buf[offset + 0] ) << 8 ) | buf[offset + 1] );

3592

pMem.flags = MEM_Int;

return 2;

}

case 3:

{ /* 3-byte signed integer */

3597

pMem.u.i = (int)( ( ( (sbyte)buf[offset + 0] ) << 16 ) | ( buf[offset + 1] << 8 ) | buf[offset + 2] );

3598

pMem.flags = MEM_Int;

return 3;

}

case 4:

{ /* 4-byte signed integer */

3603

            pMem.u.i = (int)( ( (sbyte)buf[offset + 0] << 24 ) | ( buf[offset + 1] << 16 ) | ( buf[offset + 2] << 8 ) | buf[offset + 3] );

3604

pMem.flags = MEM_Int;

return 4;

}

case 5:

{ /* 6-byte signed integer */

3609

u64 x = (ulong)( ( ( (sbyte)buf[offset + 0] ) << 8 ) | buf[offset + 1] );

3610

            u32 y = (u32)( ( buf[offset + 2] << 24 ) | ( buf[offset + 3] << 16 ) | ( buf[offset + 4] << 8 ) | buf[offset + 5] );

3611

x = ( x << 32 ) | y;

3612

pMem.u.i = (i64)x;

3613

pMem.flags = MEM_Int;

3614

return 6;

3615

}

3616

case 6: /* 8-byte signed integer */

3617

case 7:

3618

{ /* IEEE floating point */

3619

u64 x;

3620

u32 y;

3621

#if !NDEBUG && !SQLITE_OMIT_FLOATING_POINT

3622

/* Verify that integers and floating point values use the same

3623

** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is

3624

** defined that 64-bit floating point values really are mixed

3625

** endian.

3626

*/

3627

const u64 t1 = ( (u64)0x3ff00000 ) << 32;

3628

const double r1 = 1.0;

3629

u64 t2 = t1;

3630

#if SQLITE_MIXED_ENDIAN_64BIT_FLOAT

3631

swapMixedEndianFloat(t2);

3632

#endif

3633

            Debug.Assert( sizeof( double ) == sizeof( u64 ) && memcmp( BitConverter.GetBytes( r1 ), BitConverter.GetBytes( t2 ), sizeof( double ) ) == 0 );//Debug.Assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, t2, sizeof(r1))==0 );

3634

#endif

3635

3636

            x = (u64)( ( buf[offset + 0] << 24 ) | ( buf[offset + 1] << 16 ) | ( buf[offset + 2] << 8 ) | buf[offset + 3] );

3637

            y = (u32)( ( buf[offset + 4] << 24 ) | ( buf[offset + 5] << 16 ) | ( buf[offset + 6] << 8 ) | buf[offset + 7] );

3638

x = ( x << 32 ) | y;

3639

if ( serial_type == 6 )

3640

{

3641

pMem.u.i = (i64)x;

3642

pMem.flags = MEM_Int;

}

else

{

Debug.Assert( sizeof( i64 ) == 8 && sizeof( double ) == 8 );

3647

#if SQLITE_MIXED_ENDIAN_64BIT_FLOAT

3648

swapMixedEndianFloat(x);

3649

#endif

3650

#if WINDOWS_PHONE || WINDOWS_MOBILE

3651

pMem.r = BitConverter.ToDouble(BitConverter.GetBytes((long)x), 0);

3652

#else

3653

pMem.r = BitConverter.Int64BitsToDouble( (long)x );// memcpy(pMem.r, x, sizeof(x))

3654

#endif

3655

pMem.flags = (u16)( sqlite3IsNaN( pMem.r ) ? MEM_Null : MEM_Real );

}

return 8;

}

case 8: /* Integer 0 */

3660

case 9:

3661

{ /* Integer 1 */

3662

pMem.u.i = serial_type - 8;

3663

pMem.flags = MEM_Int;

return 0;

}

default:

{

u32 len = ( serial_type - 12 ) / 2;

3669

pMem.n = (int)len;

3670

pMem.xDel = null;

3671

if ( ( serial_type & 0x01 ) != 0 )

3672

{

3673

pMem.flags = MEM_Str | MEM_Ephem;

3674

if ( len <= buf.Length - offset )

3675

{

3676

pMem.z = Encoding.UTF8.GetString( buf, offset, (int)len );//memcpy( buf, pMem.z, len );

3677

pMem.n = pMem.z.Length;

}

else

{

pMem.z = string.Empty; // Corrupted Data

pMem.n = 0;

}

pMem.zBLOB = null;

}

else

{

pMem.z = null;

pMem.zBLOB = sqlite3Malloc( (int)len );

3690

pMem.flags = MEM_Blob | MEM_Ephem;

3691

if ( len <= buf.Length - offset )

3692

{

3693

Buffer.BlockCopy( buf, offset, pMem.zBLOB, 0, (int)len );//memcpy( buf, pMem.z, len );

}

else

{

Buffer.BlockCopy( buf, offset, pMem.zBLOB, 0, buf.Length - offset - 1 );

}

}

return len;

}

}

return 0;

}

static int sqlite3VdbeSerialGet(

3707

byte[] buf, /* Buffer to deserialize from */

3708

u32 serial_type, /* Serial type to deserialize */

3709

Mem pMem /* Memory cell to write value into */

3710

)

3711

{

3712

switch ( serial_type )

3713

{

3714

case 10: /* Reserved for future use */

3715

case 11: /* Reserved for future use */

3716

case 0:

3717

{ /* NULL */

3718

pMem.flags = MEM_Null;

break;

}

case 1:

{ /* 1-byte signed integer */

3723

pMem.u.i = (sbyte)buf[0];

3724

pMem.flags = MEM_Int;

return 1;

}

case 2:

{ /* 2-byte signed integer */

3729

pMem.u.i = (int)( ( ( buf[0] ) << 8 ) | buf[1] );

3730

pMem.flags = MEM_Int;

return 2;

}

case 3:

{ /* 3-byte signed integer */

3735

pMem.u.i = (int)( ( ( buf[0] ) << 16 ) | ( buf[1] << 8 ) | buf[2] );

3736

pMem.flags = MEM_Int;

return 3;

}

case 4:

{ /* 4-byte signed integer */

3741

pMem.u.i = (int)( ( buf[0] << 24 ) | ( buf[1] << 16 ) | ( buf[2] << 8 ) | buf[3] );

3742

pMem.flags = MEM_Int;

return 4;

}

case 5:

{ /* 6-byte signed integer */

3747

u64 x = (ulong)( ( ( buf[0] ) << 8 ) | buf[1] );

3748

u32 y = (u32)( ( buf[2] << 24 ) | ( buf[3] << 16 ) | ( buf[4] << 8 ) | buf[5] );

3749

x = ( x << 32 ) | y;

3750

pMem.u.i = (i64)x;

3751

pMem.flags = MEM_Int;

3752

return 6;

3753

}

3754

case 6: /* 8-byte signed integer */

3755

case 7:

3756

{ /* IEEE floating point */

3757

u64 x;

3758

u32 y;

3759

#if !NDEBUG && !SQLITE_OMIT_FLOATING_POINT

3760

/* Verify that integers and floating point values use the same

3761

** byte order. Or, that if SQLITE_MIXED_ENDIAN_64BIT_FLOAT is

3762

** defined that 64-bit floating point values really are mixed

3763

** endian.

3764

*/

3765

const u64 t1 = ( (u64)0x3ff00000 ) << 32;

3766

const double r1 = 1.0;

3767

u64 t2 = t1;

3768

#if SQLITE_MIXED_ENDIAN_64BIT_FLOAT

3769

swapMixedEndianFloat(t2);

3770

#endif

3771

            Debug.Assert( sizeof( double ) == sizeof( u64 ) && memcmp( BitConverter.GetBytes( r1 ), BitConverter.GetBytes( t2 ), sizeof( double ) ) == 0 );//Debug.Assert( sizeof(r1)==sizeof(t2) && memcmp(&r1, t2, sizeof(r1))==0 );

3772

#endif

3773

3774

x = (u64)( ( buf[0] << 24 ) | ( buf[1] << 16 ) | ( buf[2] << 8 ) | buf[3] );

3775

y = (u32)( ( buf[4] << 24 ) | ( buf[5] << 16 ) | ( buf[6] << 8 ) | buf[7] );

3776

x = ( x << 32 ) | y;

3777

if ( serial_type == 6 )

3778

{

3779

pMem.u.i = (i64)x;

3780

pMem.flags = MEM_Int;

}

else

{

Debug.Assert( sizeof( i64 ) == 8 && sizeof( double ) == 8 );

3785

#if SQLITE_MIXED_ENDIAN_64BIT_FLOAT

3786

swapMixedEndianFloat(x);

3787

#endif

3788

#if WINDOWS_PHONE || WINDOWS_MOBILE

3789

pMem.r = BitConverter.ToDouble(BitConverter.GetBytes((long)x), 0);

3790

#else

3791

pMem.r = BitConverter.Int64BitsToDouble( (long)x );// memcpy(pMem.r, x, sizeof(x))

3792

#endif

3793

pMem.flags = MEM_Real;

}

return 8;

}

case 8: /* Integer 0 */

3798

case 9:

3799

{ /* Integer 1 */

3800

pMem.u.i = serial_type - 8;

3801

pMem.flags = MEM_Int;

return 0;

}

default:

{

int len = (int)( ( serial_type - 12 ) / 2 );

3807

pMem.xDel = null;

3808

if ( ( serial_type & 0x01 ) != 0 )

3809

{

3810

pMem.flags = MEM_Str | MEM_Ephem;

3811

pMem.z = Encoding.UTF8.GetString( buf, 0, len );//memcpy( buf, pMem.z, len );

3812

pMem.n = pMem.z.Length;// len;

pMem.zBLOB = null;

}

else

{

pMem.flags = MEM_Blob | MEM_Ephem;

3818

pMem.zBLOB = sqlite3Malloc( len );

3819

buf.CopyTo( pMem.zBLOB, 0 );

3820

pMem.n = len;// len;

pMem.z = null;

}

return len;

}

}

return 0;

}

/*

** Given the nKey-byte encoding of a record in pKey[], parse the

3831

** record into a UnpackedRecord structure. Return a pointer to

3832

** that structure.

3833

**

3834

** The calling function might provide szSpace bytes of memory

3835

** space at pSpace. This space can be used to hold the returned

3836

** VDbeParsedRecord structure if it is large enough. If it is

3837

** not big enough, space is obtained from sqlite3Malloc().

3838

**

3839

** The returned structure should be closed by a call to

3840

** sqlite3VdbeDeleteUnpackedRecord().

3841

*/

3842

static UnpackedRecord sqlite3VdbeRecordUnpack(

3843

KeyInfo pKeyInfo, /* Information about the record format */

3844

int nKey, /* Size of the binary record */

3845

byte[] pKey, /* The binary record */

3846

UnpackedRecord pSpace, // char *pSpace, /* Unaligned space available to hold the object */

3847

int szSpace /* Size of pSpace[] in bytes */

3848

)

3849

{

3850

byte[] aKey = pKey;

3851

UnpackedRecord p; /* The unpacked record that we will return */

3852

int nByte; /* Memory space needed to hold p, in bytes */

3853

int d;

3854

u32 idx;

3855

int u; /* Unsigned loop counter */

3856

int szHdr = 0;

3857

Mem pMem;

3858

int nOff; /* Increase pSpace by this much to 8-byte align it */

3859

3860

/*

3861

** We want to shift the pointer pSpace up such that it is 8-byte aligned.

3862

** Thus, we need to calculate a value, nOff, between 0 and 7, to shift

3863

** it by. If pSpace is already 8-byte aligned, nOff should be zero.

3864

*/

3865

//nOff = ( 8 - ( SQLITE_PTR_TO_INT( pSpace ) & 7 ) ) & 7;

3866

//pSpace += nOff;

3867

//szSpace -= nOff;

3868

//nByte = ROUND8( sizeof( UnpackedRecord ) ) + sizeof( Mem ) * ( pKeyInfo->nField + 1 );

3869

//if ( nByte > szSpace)

3870

//{

3871

//var p = new UnpackedRecord();//sqlite3DbMallocRaw(pKeyInfo.db, nByte);

3872

// if ( p == null ) return null;

3873

// p.flags = UNPACKED_NEED_FREE | UNPACKED_NEED_DESTROY;

//}

//else

{

p = pSpace;//(UnpackedRecord)pSpace;

3878

p.flags = UNPACKED_NEED_DESTROY;

3879

}

3880

p.pKeyInfo = pKeyInfo;

3881

p.nField = (u16)( pKeyInfo.nField + 1 );

3882

//p->aMem = pMem = (Mem)&( (char)p )[ROUND8( sizeof( UnpackedRecord ) )];

3883

//Debug.Assert( EIGHT_BYTE_ALIGNMENT( pMem ) );

3884

p.aMem = new Mem[p.nField + 1];

3885

idx = (u32)getVarint32( aKey, 0, out szHdr );// GetVarint( aKey, szHdr );

3886

d = (int)szHdr;

3887

u = 0;

3888

while ( idx < (int)szHdr && u < p.nField && d <= nKey )

3889

{

3890

p.aMem[u] = sqlite3Malloc( p.aMem[u] );

3891

pMem = p.aMem[u];

3892

u32 serial_type = 0;

3893

3894

idx += (u32)getVarint32( aKey, idx, out serial_type );// GetVarint( aKey + idx, serial_type );

3895

pMem.enc = pKeyInfo.enc;

3896

pMem.db = pKeyInfo.db;

3897

/* pMem->flags = 0; // sqlite3VdbeSerialGet() will set this for us */

3898

//pMem.zMalloc = null;

3899

d += (int)sqlite3VdbeSerialGet( aKey, d, serial_type, pMem );

//pMem++;

u++;

}

Debug.Assert( u <= pKeyInfo.nField + 1 );

3904

p.nField = (u16)u;

3905

return p;// (void)p;

}

/*

** This routine destroys a UnpackedRecord object.

3910

*/

3911

static void sqlite3VdbeDeleteUnpackedRecord( UnpackedRecord p )

{

#if SQLITE_DEBUG

int i;

Mem pMem;

Debug.Assert( p != null );

3917

Debug.Assert( ( p.flags & UNPACKED_NEED_DESTROY ) != 0 );

3918

//for ( i = 0, pMem = p->aMem ; i < p->nField ; i++, pMem++ )

3919

//{

3920

// /* The unpacked record is always constructed by the

3921

// ** sqlite3VdbeUnpackRecord() function above, which makes all

3922

// ** strings and blobs static. And none of the elements are

3923

// ** ever transformed, so there is never anything to delete.

3924

// */

3925

// if ( NEVER( pMem->zMalloc ) ) sqlite3VdbeMemRelease( pMem );

3926

//}

3927

#endif

3928

if ( ( p.flags & UNPACKED_NEED_FREE ) != 0 )

3929

{

3930

sqlite3DbFree( p.pKeyInfo.db, ref p.aMem );

p = null;

}

}

/*

** This function compares the two table rows or index records

3937

** specified by {nKey1, pKey1} and pPKey2. It returns a negative, zero

3938

** or positive integer if key1 is less than, equal to or

3939

** greater than key2. The {nKey1, pKey1} key must be a blob

3940

** created by th OP_MakeRecord opcode of the VDBE. The pPKey2

3941

** key must be a parsed key such as obtained from

3942

** sqlite3VdbeParseRecord.

3943

**

3944

** Key1 and Key2 do not have to contain the same number of fields.

3945

** The key with fewer fields is usually compares less than the

3946

** longer key. However if the UNPACKED_INCRKEY flags in pPKey2 is set

3947

** and the common prefixes are equal, then key1 is less than key2.

3948

** Or if the UNPACKED_MATCH_PREFIX flag is set and the prefixes are

3949

** equal, then the keys are considered to be equal and

3950

** the parts beyond the common prefix are ignored.

3951

**

3952

** If the UNPACKED_IGNORE_ROWID flag is set, then the last byte of

3953

** the header of pKey1 is ignored. It is assumed that pKey1 is

3954

** an index key, and thus ends with a rowid value. The last byte

3955

** of the header will therefore be the serial type of the rowid:

3956

** one of 1, 2, 3, 4, 5, 6, 8, or 9 - the integer serial types.

3957

** The serial type of the final rowid will always be a single byte.

3958

** By ignoring this last byte of the header, we force the comparison

3959

** to ignore the rowid at the end of key1.

3960

*/

3961

3962

static Mem mem1 = new Mem();

3963

// ALTERNATE FORM for C#

3964

static int sqlite3VdbeRecordCompare(

3965

int nKey1, byte[] pKey1, /* Left key */

3966

UnpackedRecord pPKey2 /* Right key */

3967

)

3968

{

3969

return sqlite3VdbeRecordCompare( nKey1, pKey1, 0, pPKey2 );

3970

}

3971

3972

static int sqlite3VdbeRecordCompare(

3973

int nKey1, byte[] pKey1, /* Left key */

3974

int offset,

3975

UnpackedRecord pPKey2 /* Right key */

3976

)

3977

{

3978

int d1; /* Offset into aKey[] of next data element */

3979

u32 idx1; /* Offset into aKey[] of next header element */

3980

u32 szHdr1; /* Number of bytes in header */

int i = 0;

int nField;

int rc = 0;

////byte[] aKey1 = new byte[pKey1.Length - offset];

3986

//Buffer.BlockCopy( pKey1, offset, aKey1, 0, aKey1.Length );

3987

3988

KeyInfo pKeyInfo = pPKey2.pKeyInfo;

3989

mem1.enc = pKeyInfo.enc;

3990

mem1.db = pKeyInfo.db;

3991

/* mem1.flags = 0; // Will be initialized by sqlite3VdbeSerialGet() */

3992

// VVA_ONLY( mem1.zMalloc = 0; ) /* Only needed by Debug.Assert() statements */

3993

3994

/* Compilers may complain that mem1.u.i is potentially uninitialized.

3995

** We could initialize it, as shown here, to silence those complaints.

3996

** But in fact, mem1.u.i will never actually be used uninitialized, and doing

3997

** the unnecessary initialization has a measurable negative performance

3998

** impact, since this routine is a very high runner. And so, we choose

3999

** to ignore the compiler warnings and leave this variable uninitialized.

4000

*/

4001

/* mem1.u.i = 0; // not needed, here to silence compiler warning */

4002

4003

      idx1 = (u32)( ( szHdr1 = pKey1[offset] ) <= 0x7f ? 1 : getVarint32( pKey1, offset, out szHdr1 ) );// GetVarint( aKey1, szHdr1 );

4004

d1 = (int)szHdr1;

4005

if ( ( pPKey2.flags & UNPACKED_IGNORE_ROWID ) != 0 )

{

szHdr1--;

}

nField = pKeyInfo.nField;

4010

while ( idx1 < szHdr1 && i < pPKey2.nField )

{

u32 serial_type1;

/* Read the serial types for the next element in each key. */

4015

        idx1 += (u32)( ( serial_type1 = pKey1[offset + idx1] ) <= 0x7f ? 1 : getVarint32( pKey1, (uint)( offset + idx1 ), out serial_type1 ) ); //GetVarint( aKey1 + idx1, serial_type1 );

4016

if ( d1 <= 0 || d1 >= nKey1 && sqlite3VdbeSerialTypeLen( serial_type1 ) > 0 )

4017

break;

4018

4019

/* Extract the values to be compared.

4020

*/

4021

        d1 += (int)sqlite3VdbeSerialGet( pKey1, offset + d1, serial_type1, mem1 );//sqlite3VdbeSerialGet( aKey1, d1, serial_type1, mem1 );

4022

4023

/* Do the comparison

4024

*/

4025

rc = sqlite3MemCompare( mem1, pPKey2.aMem[i], i < nField ? pKeyInfo.aColl[i] : null );

4026

if ( rc != 0 )

4027

{

4028

//Debug.Assert( mem1.zMalloc==null ); /* See comment below */

4029

4030

/* Invert the result if we are using DESC sort order. */

4031

if ( pKeyInfo.aSortOrder != null && i < nField && pKeyInfo.aSortOrder[i] != 0 )

{

rc = -rc;

}

/* If the PREFIX_SEARCH flag is set and all fields except the final

4037

** rowid field were equal, then clear the PREFIX_SEARCH flag and set

4038

** pPKey2->rowid to the value of the rowid field in (pKey1, nKey1).

4039

** This is used by the OP_IsUnique opcode.

4040

*/

4041

if ( ( pPKey2.flags & UNPACKED_PREFIX_SEARCH ) != 0 && i == ( pPKey2.nField - 1 ) )

4042

{

4043

Debug.Assert( idx1 == szHdr1 && rc != 0 );

4044

Debug.Assert( ( mem1.flags & MEM_Int ) != 0 );

4045

pPKey2.flags = (ushort)( pPKey2.flags & ~UNPACKED_PREFIX_SEARCH );

4046

pPKey2.rowid = mem1.u.i;

}

return rc;

}

i++;

}

/* No memory allocation is ever used on mem1. Prove this using

4055

** the following Debug.Assert(). If the Debug.Assert() fails, it indicates a

4056

** memory leak and a need to call sqlite3VdbeMemRelease(&mem1).

4057

*/

4058

//Debug.Assert( mem1.zMalloc==null );

4059

4060

/* rc==0 here means that one of the keys ran out of fields and

4061

** all the fields up to that point were equal. If the UNPACKED_INCRKEY

4062

** flag is set, then break the tie by treating key2 as larger.

4063

** If the UPACKED_PREFIX_MATCH flag is set, then keys with common prefixes

4064

** are considered to be equal. Otherwise, the longer key is the

4065

** larger. As it happens, the pPKey2 will always be the longer

4066

** if there is a difference.

4067

*/

4068

Debug.Assert( rc == 0 );

4069

if ( ( pPKey2.flags & UNPACKED_INCRKEY ) != 0 )

{

rc = -1;

}

else if ( ( pPKey2.flags & UNPACKED_PREFIX_MATCH ) != 0 )

{

/* Leave rc==0 */

}

else if ( idx1 < szHdr1 )

{

rc = 1;

}

return rc;

}

/*

** pCur points at an index entry created using the OP_MakeRecord opcode.

4086

** Read the rowid (the last field in the record) and store it in *rowid.

4087

** Return SQLITE_OK if everything works, or an error code otherwise.

4088

**

4089

** pCur might be pointing to text obtained from a corrupt database file.

4090

** So the content cannot be trusted. Do appropriate checks on the content.

4091

*/

4092

static int sqlite3VdbeIdxRowid( sqlite3 db, BtCursor pCur, ref i64 rowid )

{

i64 nCellKey = 0;

int rc;

u32 szHdr = 0; /* Size of the header */

4097

u32 typeRowid = 0; /* Serial type of the rowid */

4098

u32 lenRowid; /* Size of the rowid */

4099

Mem m = null;

4100

Mem v = null;

4101

v = sqlite3Malloc( v );

4102

UNUSED_PARAMETER( db );

4103

4104

/* Get the size of the index entry. Only indices entries of less

4105

** than 2GiB are support - anything large must be database corruption.

4106

** Any corruption is detected in sqlite3BtreeParseCellPtr(), though, so

4107

** this code can safely assume that nCellKey is 32-bits

4108

*/

4109

Debug.Assert( sqlite3BtreeCursorIsValid( pCur ) );

4110

rc = sqlite3BtreeKeySize( pCur, ref nCellKey );

4111

Debug.Assert( rc == SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */

4112

Debug.Assert( ( (u32)nCellKey & SQLITE_MAX_U32 ) == (u64)nCellKey );

4113

4114

/* Read in the complete content of the index entry */

4115

m = sqlite3Malloc( m );

4116

// memset(&m, 0, sizeof(m));

4117

rc = sqlite3VdbeMemFromBtree( pCur, 0, (int)nCellKey, true, m );

if ( rc != 0 )

{

return rc;

}

/* The index entry must begin with a header size */

4124

getVarint32( m.zBLOB, 0, out szHdr );

4125

testcase( szHdr == 3 );

4126

testcase( szHdr == m.n );

4127

if ( unlikely( szHdr < 3 || (int)szHdr > m.n ) )

4128

{

4129

goto idx_rowid_corruption;

4130

}

4131

4132

/* The last field of the index should be an integer - the ROWID.

4133

** Verify that the last entry really is an integer. */

4134

getVarint32( m.zBLOB, szHdr - 1, out typeRowid );

4135

testcase( typeRowid == 1 );

4136

testcase( typeRowid == 2 );

4137

testcase( typeRowid == 3 );

4138

testcase( typeRowid == 4 );

4139

testcase( typeRowid == 5 );

4140

testcase( typeRowid == 6 );

4141

testcase( typeRowid == 8 );

4142

testcase( typeRowid == 9 );

4143

if ( unlikely( typeRowid < 1 || typeRowid > 9 || typeRowid == 7 ) )

4144

{

4145

goto idx_rowid_corruption;

4146

}

4147

lenRowid = (u32)sqlite3VdbeSerialTypeLen( typeRowid );

4148

testcase( (u32)m.n == szHdr + lenRowid );

4149

if ( unlikely( (u32)m.n < szHdr + lenRowid ) )

4150

{

4151

goto idx_rowid_corruption;

4152

}

4153

4154

/* Fetch the integer off the end of the index record */

4155

sqlite3VdbeSerialGet( m.zBLOB, (int)( m.n - lenRowid ), typeRowid, v );

4156

rowid = v.u.i;

4157

sqlite3VdbeMemRelease( m );

4158

return SQLITE_OK;

4159

4160

/* Jump here if database corruption is detected after m has been

4161

** allocated. Free the m object and return SQLITE_CORRUPT. */

4162

idx_rowid_corruption:

4163

//testcase( m.zMalloc != 0 );

4164

sqlite3VdbeMemRelease( m );

4165

return SQLITE_CORRUPT_BKPT();

}

/*

** Compare the key of the index entry that cursor pC is pointing to against

4170

** the key string in pUnpacked. Write into *pRes a number

4171

** that is negative, zero, or positive if pC is less than, equal to,

4172

** or greater than pUnpacked. Return SQLITE_OK on success.

4173

**

4174

** pUnpacked is either created without a rowid or is truncated so that it

4175

** omits the rowid at the end. The rowid at the end of the index entry

4176

** is ignored as well. Hence, this routine only compares the prefixes

4177

** of the keys prior to the final rowid, not the entire key.

4178

*/

4179

static int sqlite3VdbeIdxKeyCompare(

4180

VdbeCursor pC, /* The cursor to compare against */

4181

UnpackedRecord pUnpacked, /* Unpacked version of key to compare against */

4182

ref int res /* Write the comparison result here */

)

{

i64 nCellKey = 0;

int rc;

BtCursor pCur = pC.pCursor;

4188

Mem m = null;

4189

4190

Debug.Assert( sqlite3BtreeCursorIsValid( pCur ) );

4191

rc = sqlite3BtreeKeySize( pCur, ref nCellKey );

4192

Debug.Assert( rc == SQLITE_OK ); /* pCur is always valid so KeySize cannot fail */

4193

/* nCellKey will always be between 0 and 0xffffffff because of the say

4194

** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */

4195

if ( nCellKey <= 0 || nCellKey > 0x7fffffff )

4196

{

4197

res = 0;

4198

return SQLITE_CORRUPT_BKPT();

4199

}

4200

4201

m = sqlite3Malloc( m );

4202

// memset(&m, 0, sizeof(m));

4203

rc = sqlite3VdbeMemFromBtree( pC.pCursor, 0, (int)nCellKey, true, m );

if ( rc != 0 )

{

return rc;

}

Debug.Assert( ( pUnpacked.flags & UNPACKED_IGNORE_ROWID ) != 0 );

4209

res = sqlite3VdbeRecordCompare( m.n, m.zBLOB, pUnpacked );

4210

sqlite3VdbeMemRelease( m );

return SQLITE_OK;

}

/*

** This routine sets the value to be returned by subsequent calls to

4216

** sqlite3_changes() on the database handle 'db'.

4217

*/

4218

static void sqlite3VdbeSetChanges( sqlite3 db, int nChange )

4219

{

4220

Debug.Assert( sqlite3_mutex_held( db.mutex ) );

4221

db.nChange = nChange;

4222

db.nTotalChange += nChange;

}

/*

** Set a flag in the vdbe to update the change counter when it is finalised

4227

** or reset.

4228

*/

4229

static void sqlite3VdbeCountChanges( Vdbe v )

4230

{

4231

v.changeCntOn = true;

}

/*

** Mark every prepared statement associated with a database connection

4236

** as expired.

4237

**

4238

** An expired statement means that recompilation of the statement is

4239

** recommend. Statements expire when things happen that make their

4240

** programs obsolete. Removing user-defined functions or collating

4241

** sequences, or changing an authorization function are the types of

4242

** things that make prepared statements obsolete.

4243

*/

4244

static void sqlite3ExpirePreparedStatements( sqlite3 db )

4245

{

4246

Vdbe p;

4247

for ( p = db.pVdbe; p != null; p = p.pNext )

{

p.expired = true;

}

}

/*

** Return the database associated with the Vdbe.

4255

*/

4256

static sqlite3 sqlite3VdbeDb( Vdbe v )

{

return v.db;

}

/*

** Return a pointer to an sqlite3_value structure containing the value bound

4262

** parameter iVar of VM v. Except, if the value is an SQL NULL, return

4263

** 0 instead. Unless it is NULL, apply affinity aff (one of the SQLITE_AFF_*

4264

** constants) to the value before returning it.

4265

**

4266

** The returned value must be freed by the caller using sqlite3ValueFree().

4267

*/

4268

static sqlite3_value sqlite3VdbeGetValue( Vdbe v, int iVar, u8 aff )

4269

{

4270

Debug.Assert( iVar > 0 );

4271

if ( v != null )

4272

{

4273

Mem pMem = v.aVar[iVar - 1];

4274

if ( 0 == ( pMem.flags & MEM_Null ) )

4275

{

4276

sqlite3_value pRet = sqlite3ValueNew( v.db );

4277

if ( pRet != null )

4278

{

4279

sqlite3VdbeMemCopy( (Mem)pRet, pMem );

4280

sqlite3ValueApplyAffinity( pRet, (char)aff, SQLITE_UTF8 );

4281

sqlite3VdbeMemStoreType( (Mem)pRet );

}

return pRet;

}

}

return null;

}

/*

** Configure SQL variable iVar so that binding a new value to it signals

4291

** to sqlite3_reoptimize() that re-preparing the statement may result

4292

** in a better query plan.

4293

*/

4294

static void sqlite3VdbeSetVarmask( Vdbe v, int iVar )

4295

{

4296

Debug.Assert( iVar > 0 );

4297

if ( iVar > 32 )

4298

{

4299

v.expmask = 0xffffffff;

}

else

{

v.expmask |= ( (u32)1 << ( iVar - 1 ) );

}

}

}

}

wasCSharpSQLite – Blame information for rev 1