SQLite

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This header file defines the interface that the SQLite library
** presents to client programs.
**
** @(#) $Id: sqlite.h.in,v 1.71 2004/05/23 13:30:58 danielk1977 Exp $
*/
#ifndef _SQLITE_H_
#define _SQLITE_H_
#include <stdarg.h>     /* Needed for the definition of va_list */

/*
** Make sure we can call this stuff from C++.

**
** After a call to sqlite3_step() that returns SQLITE_ROW, this routine
** will return the same value as the sqlite3_column_count() function.
** After sqlite3_step() has returned an SQLITE_DONE, SQLITE_BUSY or
** error code, or before sqlite3_step() has been called on a 
** compiled SQL statement, this routine returns zero.
*/
int sqlite3_data_count(sqlite3_stmt *pStmt);

#define SQLITE3_INTEGER  1
#define SQLITE3_FLOAT    2
#define SQLITE3_TEXT     3
#define SQLITE3_BLOB     4
#define SQLITE3_NULL     5

** SQLITE3_INTEGER   The value of the integer. Some rounding may occur.
** SQLITE3_FLOAT     The value of the float.
** SQLITE3_TEXT      Real number conversion of string, or 0.0
** SQLITE3_BLOB      0.0
*/
double sqlite3_column_float(sqlite3_stmt*,int);

typedef struct Mem sqlite3_value;

int sqlite3_value_type(sqlite3_value*);
int sqlite3_value_bytes(sqlite3_value*);
int sqlite3_value_bytes16(sqlite3_value*);
const unsigned char *sqlite3_value_data(sqlite3_value*);
const void *sqlite3_value_data16(sqlite3_value*);
long long int sqlite3_value_int(sqlite3_value*);
double sqlite3_value_float(sqlite3_value*);

#ifdef __cplusplus
}  /* End of the 'extern "C"' block */
#endif
#endif

/*
** 2001 September 15
**
** 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.
**
*************************************************************************
** Internal interface definitions for SQLite.
**
** @(#) $Id: sqliteInt.h,v 1.247 2004/05/23 13:30:58 danielk1977 Exp $
*/
#include "config.h"
#include "sqlite.h"
#include "hash.h"
#include "parse.h"
#include <stdio.h>
#include <stdlib.h>

/*
** Possible values for the Db.textEnc field.
*/
#define TEXT_Utf8             1
#define TEXT_Utf16le          2
#define TEXT_Utf16be          3
/* #define TEXT_Utf16            4 */

/*
** Each database is an instance of the following structure.
**
** The sqlite.file_format is initialized by the database file
** and helps determines how the data in the database file is
** represented.  This field allows newer versions of the library

char sqlite3CompareAffinity(Expr *pExpr, char aff2);
char const *sqlite3AffinityString(char affinity);
int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity);
char sqlite3ExprAffinity(Expr *pExpr);
int sqlite3atoi64(const char*, i64*);
void sqlite3Error(sqlite *, int, const char*,...);
int sqlite3utfTranslate(const void *, int , u8 , void **, int *, u8);
u8 sqlite3UtfReadBom(const void *zData, int nData);

**    May you find forgiveness for yourself and forgive others.
**    May you share freely, never taking more than you give.
**
*************************************************************************
** This file contains routines used to translate between UTF-8, 
** UTF-16, UTF-16BE, and UTF-16LE.
**
** $Id: utf.c,v 1.9 2004/05/23 13:30:58 danielk1977 Exp $
**
** Notes on UTF-8:
**
**   Byte-0    Byte-1    Byte-2    Byte-3    Value
**  0xxxxxxx                                 00000000 00000000 0xxxxxxx
**  110yyyyy  10xxxxxx                       00000000 00000yyy yyxxxxxx
**  1110zzzz  10yyyyyy  10xxxxxx             00000000 zzzzyyyy yyxxxxxx

      pStr->c = 2;
      return 0;
    }
  }

  return big_endian;
}

/*
** zData is a UTF-16 encoded string, nData bytes in length. This routine
** checks if there is a byte-order mark at the start of zData. If no
** byte order mark is found 0 is returned. Otherwise TEXT_Utf16be or
** TEXT_Utf16le is returned, depending on whether The BOM indicates that
** the text is big-endian or little-endian.
*/
u8 sqlite3UtfReadBom(const void *zData, int nData){
  if( nData<0 || nData>1 ){
    u8 b1 = *(u8 *)zData;
    u8 b2 = *(((u8 *)zData) + 1);
    if( b1==0xFE && b2==0xFF ){
      return TEXT_Utf16be;
    }
    if( b1==0xFF && b2==0xFE ){
      return TEXT_Utf16le;
    }
  }
  return 0;
}


/*
** Read a single unicode character from the UTF-8 encoded string *pStr. The
** value returned is a unicode scalar value. In the case of malformed
** strings, the unicode replacement character U+FFFD may be returned.
*/

**
** Various scripts scan this source file in order to generate HTML
** documentation, headers files, or other derived files.  The formatting
** of the code in this file is, therefore, important.  See other comments
** in this file for details.  If in doubt, do not deviate from existing
** commenting and indentation practices when changing or adding code.
**
** $Id: vdbe.c,v 1.321 2004/05/23 13:30:58 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
#include <ctype.h>
#include "vdbeInt.h"

/*

    case TEXT_Utf8: return MEM_Utf8;
    case TEXT_Utf16be: return MEM_Utf16be;
    case TEXT_Utf16le: return MEM_Utf16le;
  }
  assert(0);
}

/*
** Set the encoding flags of memory cell "pMem" to the correct values
** for the database encoding "enc" (one of TEXT_Utf8, TEXT_Utf16le or
** TEXT_Utf16be).
*/
#define SetEncodingFlags(pMem, enc) (pMem->flags = \
(pMem->flags & ~(MEM_Utf8|MEM_Utf16le|MEM_Utf16be)) | encToFlags(enc))

/*
** If pMem is a string object, this routine sets the encoding of the string
** (to one of UTF-8 or UTF16) and whether or not the string is
** nul-terminated. If pMem is not a string object, then this routine is
** a no-op.
**
** The second argument, "flags" consists of one of MEM_Utf8, MEM_Utf16le

    memcpy(&pMem->z[pMem->n], "\0\0", nulTermLen);
    pMem->n += nulTermLen;
    pMem->flags |= MEM_Term;
  }
  return SQLITE_OK;
}















/*
** Convert the given stack entity into a string that has been obtained
** from sqliteMalloc().  This is different from Stringify() above in that
** Stringify() will use the NBFS bytes of static string space if the string
** will fit but this routine always mallocs for space.
** Return non-zero if we run out of memory.
*/

  if( pazValue ) *pazValue = 0;
  if( pazColName ) *pazColName = 0;
  if( pN ) *pN = 0;

  if( rc==SQLITE_DONE || rc==SQLITE_ROW ){
    int i;
    int cols = sqlite3_column_count(pStmt) * (pazColName?1:0);
    int vals = sqlite3_data_count(pStmt) * (pazValue?1:0);

    /* Temporary memory leak */
    if( cols ) *pazColName = sqliteMalloc(sizeof(char *)*cols * 2); 
    if( pN ) *pN = cols;

    for(i=0; i<cols; i++){
      (*pazColName)[i] = sqlite3_column_name(pStmt, i);

  return pVm->nResColumn;
}

/*
** Return the number of values available from the current row of the
** currently executing statement pStmt.
*/
int sqlite3_data_count(sqlite3_stmt *pStmt){
  Vdbe *pVm = (Vdbe *)pStmt;
  if( !pVm->resOnStack ) return 0;
  return pVm->nResColumn;
}

/*
** Return the value of the 'i'th column of the current row of the currently
** executing statement pStmt.
*/
const unsigned char *sqlite3_column_data(sqlite3_stmt *pStmt, int i){
  int vals;
  Vdbe *pVm = (Vdbe *)pStmt;
  Mem *pVal;

  vals = sqlite3_data_count(pStmt);
  if( i>=vals || i<0 ){
    sqlite3Error(pVm->db, SQLITE_RANGE, 0);
    return 0;
  }

  pVal = &pVm->pTos[(1-vals)+i];
  SetEncodingFlags(pVal, pVm->db->enc);
  return sqlite3_value_data((sqlite3_value *)pVal);
}

const unsigned char *sqlite3_value_data(sqlite3_value* pVal){
  if( pVal->flags&MEM_Null ){
    return 0;
  }
  if( !(pVal->flags&MEM_Blob) ){
    if( pVal->flags&MEM_Str && !(pVal->flags&MEM_Utf8) ){
      char *z = 0;
      int n;
      u8 enc = flagsToEnc(pVal->flags);
      if( sqlite3utfTranslate(pVal->z,pVal->n,enc,(void **)&z,&n,TEXT_Utf8) ){
        return 0;
      }
      Release(pVal);
      pVal->z = z;
      pVal->n = n;
      SetEncodingFlags(pVal, TEXT_Utf8);
    }else{
      Stringify(pVal);

    }
  }
  return pVal->z;
}

/*
** Return the value of the 'i'th column of the current row of the currently
** executing statement pStmt.
*/
const void *sqlite3_column_data16(sqlite3_stmt *pStmt, int i){
  int vals;
  Vdbe *pVm = (Vdbe *)pStmt;
  Mem *pVal;

  vals = sqlite3_data_count(pStmt);
  if( i>=vals || i<0 ){
    sqlite3Error(pVm->db, SQLITE_RANGE, 0);
    return 0;
  }

  pVal = &pVm->pTos[(1-vals)+i];
  if( pVal->flags&MEM_Null ){
    return 0;
  }

  if( !(pVal->flags&MEM_Blob) ){
    Stringify(pVal);
    if( SQLITE3_BIGENDIAN ){
      /* SetEncoding(pVal, MEM_Utf16be|MEM_Term); */
    }else{
  /*    SetEncoding(pVal, MEM_Utf16le|MEM_Term); */
    }
  }

  return pVal->z;
}

/*
** Return the number of bytes of data that will be returned by the
** equivalent sqlite3_column_data() call.
*/
int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
  Vdbe *pVm = (Vdbe *)pStmt;

  if( sqlite3_column_data(pStmt, i) ){
    int vals = sqlite3_data_count(pStmt);
    return pVm->pTos[(1-vals)+i].n;
  }
  return 0;
}

/*
** Return the number of bytes of data that will be returned by the
** equivalent sqlite3_column_data16() call.
*/
int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
  Vdbe *pVm = (Vdbe *)pStmt;

  if( sqlite3_column_data16(pStmt, i) ){
    int vals = sqlite3_data_count(pStmt);
    return pVm->pTos[(1-vals)+i].n;
  }
  return 0;
}

/*
** Return the value of the 'i'th column of the current row of the currently
** executing statement pStmt.
*/
long long int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
  int vals;
  Vdbe *pVm = (Vdbe *)pStmt;
  Mem *pVal;

  vals = sqlite3_data_count(pStmt);
  if( i>=vals || i<0 ){
    sqlite3Error(pVm->db, SQLITE_RANGE, 0);
    return 0;
  }

  pVal = &pVm->pTos[(1-vals)+i];
  Integerify(pVal);
  return pVal->i;
}

/*
** Return the value of the 'i'th column of the current row of the currently
** executing statement pStmt.
*/
double sqlite3_column_float(sqlite3_stmt *pStmt, int i){
  int vals;
  Vdbe *pVm = (Vdbe *)pStmt;
  Mem *pVal;

  vals = sqlite3_data_count(pStmt);
  if( i>=vals || i<0 ){
    sqlite3Error(pVm->db, SQLITE_RANGE, 0);
    return 0;
  }

  pVal = &pVm->pTos[(1-vals)+i];
  Realify(pVal);

** executing statement pStmt.
*/
int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
  int vals;
  Vdbe *p = (Vdbe *)pStmt;
  int f;

  vals = sqlite3_data_count(pStmt);
  if( i>=vals || i<0 ){
    sqlite3Error(p->db, SQLITE_RANGE, 0);
    return 0;
  }

  f = p->pTos[(1-vals)+i].flags;

    return SQLITE_ERROR;
  }else{
    p->rc = SQLITE_OK;
    return SQLITE_DONE;
  }
}

/* Opcode: String * * P3
**
** The string value P3 is pushed onto the stack.  If P3==0 then a
** NULL is pushed onto the stack.
*/
/* Opcode: Real * * P3
**
** The string value P3 is converted to a real and pushed on to the stack.
*/
/* Opcode: Integer P1 * P3
**
** The integer value P1 is pushed onto the stack.  If P3 is not zero
** then it is assumed to be a string representation of the same integer.
** If P1 is zero and P3 is not zero, then the value is derived from P3.
*/
case OP_Integer:
case OP_Real:
case OP_String: {
  char *z = pOp->p3;
  u8 op = pOp->opcode;

  pTos++;

  pTos->flags = 0;
 
  /* If this is an OP_Real or OP_Integer opcode, set the pTos->r or pTos->i
  ** values respectively.
  */
  if( op==OP_Real ){
    assert( z );
    assert( sqlite3IsNumber(z, 0) );
    pTos->r = sqlite3AtoF(z, 0);
    pTos->flags = MEM_Real;
  }else if( op==OP_Integer ){
    pTos->flags = MEM_Int;
    pTos->i = pOp->p1;
    if( pTos->i==0 && pOp->p3 ){
      sqlite3GetInt64(pOp->p3, &pTos->i);
    }
  }


  if( z ){




    /* FIX ME: For now the code in expr.c always puts UTF-8 in P3. It
    ** should transform text to the native encoding before doing so.
    */
    if( db->enc!=TEXT_Utf8 ){
      rc = sqlite3utfTranslate(z, -1, TEXT_Utf8, (void **)&pTos->z, 
          &pTos->n, db->enc);
      if( rc!=SQLITE_OK ){
        assert( !pTos->z );
        goto abort_due_to_error;
      }
      pTos->flags |= MEM_Str | MEM_Dyn | MEM_Term;
    }else{
      pTos->z = z;
      pTos->n = strlen(z) + 1;
      pTos->flags |= MEM_Str | MEM_Static | MEM_Term;
    }
  }else if( op==OP_String ){
    pTos->flags = MEM_Null;




  }


















  break;
}

/* Opcode: Variable P1 * *
**
** Push the value of variable P1 onto the stack.  A variable is
** an unknown in the original SQL string as handed to sqlite3_compile().
** Any occurance of the '?' character in the original SQL is considered
** a variable.  Variables in the SQL string are number from left to
** right beginning with 1.  The values of variables are set using the
** sqlite3_bind() API.
*/
case OP_Variable: {
  int j = pOp->p1 - 1;

  assert( j>=0 && j<p->nVar );












  pTos++;
  memcpy(pTos, &p->apVar[j], sizeof(*pTos)-NBFS);
  if( pTos->flags&(MEM_Str|MEM_Blob) ){
    pTos->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Short);
    pTos->flags |= MEM_Static;
  }
  break;
}

/* Opcode: Utf16le_8 * * *
**
** The element on the top of the stack must be a little-endian UTF-16
** encoded string. It is translated in-place to UTF-8.
*/
case OP_Utf16le_8: {
  rc = SQLITE_INTERNAL;
  break;
}

/* Opcode: Utf16be_8 * * *
**
** The element on the top of the stack must be a big-endian UTF-16
** encoded string. It is translated in-place to UTF-8.
*/
case OP_Utf16be_8: {
  rc = SQLITE_INTERNAL;
  break;
}

/* Opcode: Utf8_16be * * *
**
** The element on the top of the stack must be a UTF-8 encoded
** string. It is translated to big-endian UTF-16.
*/
case OP_Utf8_16be: {
  rc = SQLITE_INTERNAL;
  break;
}

/* Opcode: Utf8_16le * * *
**
** The element on the top of the stack must be a UTF-8 encoded
** string. It is translated to little-endian UTF-16.
*/
case OP_Utf8_16le: {
  rc = SQLITE_INTERNAL;
  break;
}

/*
** Opcode: UtfSwab
**
** The element on the top of the stack must be an UTF-16 encoded
** string. Every second byte is exchanged, so as to translate
** the string from little-endian to big-endian or vice versa.
*/
case OP_UtfSwab: {
  rc = SQLITE_INTERNAL;
  break;
}

/* Opcode: Pop P1 * *
**
** P1 elements are popped off of the top of stack and discarded.
*/

      }else if( nn<p2 ){
        off += sqlite3VdbeSerialTypeLen(v);
      }
    }
    off += off2;
    
    sqlite3VdbeSerialGet(&zRec[off], colType, pTos, p->db->enc);

    if( rc!=SQLITE_OK ){
      goto abort_due_to_error;
    }
    break;
  }

    zData = &zRec[offset];
  }else{
    len = sqlite3VdbeSerialTypeLen(pC->aType[p2]);
    getBtreeMem(pCrsr, offset, len, pC->keyAsData, &sMem);
    zData = sMem.z;
  }
  sqlite3VdbeSerialGet(zData, pC->aType[p2], pTos, p->db->enc);

  if( rc!=SQLITE_OK ){
    goto abort_due_to_error;
  }

  Release(&sMem);
  break;
}

  ** out how much space is required for the new record.
  */
  for(pRec=pData0; pRec<=pTos; pRec++){
    u64 serial_type;
    if( zAffinity ){
      applyAffinity(pRec, zAffinity[pRec-pData0]);
    }

    serial_type = sqlite3VdbeSerialType(pRec);
    nBytes += sqlite3VdbeSerialTypeLen(serial_type);
    nBytes += sqlite3VarintLen(serial_type);
  }

  if( nBytes>MAX_BYTES_PER_ROW ){
    rc = SQLITE_TOOBIG;

    u64 serial_type;
    if( zAffinity ){
      applyAffinity(pRec, zAffinity[pRec-pData0]);
    }
    if( pRec->flags&MEM_Null ){
      containsNull = 1;
    }

    serial_type = sqlite3VdbeSerialType(pRec);
    nByte += sqlite3VarintLen(serial_type);
    nByte += sqlite3VdbeSerialTypeLen(serial_type);
  }

  /* If we have to append a varint rowid to this record, set 'rowid'
  ** to the value of the rowid and increase nByte by the amount of space

    }
    freeZData = 1;
    len = 0;
  }

  pTos++;
  sqlite3VdbeSerialGet(&zData[len], serial_type, pTos, p->db->enc);

  if( freeZData ){
    sqliteFree(zData);
  }
  break;
}

/* Opcode: FullKey P1 * *

#define MEM_Null      0x0001   /* Value is NULL */
#define MEM_Str       0x0002   /* Value is a string */
#define MEM_Int       0x0004   /* Value is an integer */
#define MEM_Real      0x0008   /* Value is a real number */
#define MEM_Blob      0x0010   /* Value is a BLOB */
#define MEM_Struct    0x0020   /* Value is some kind of struct */




#define MEM_Term      0x0200   /* String has a nul terminator character */

#define MEM_Dyn       0x0400   /* Need to call sqliteFree() on Mem.z */
#define MEM_Static    0x0800   /* Mem.z points to a static string */
#define MEM_Ephem     0x1000   /* Mem.z points to an ephemeral string */
#define MEM_Short     0x2000   /* Mem.z points to Mem.zShort */

/* Internally, all strings manipulated by the  VDBE are encoded using the
** native encoding for the main database. Therefore the following three
** flags, which describe the text encoding of the string if the MEM_Str
** flag is true, are not generally valid for Mem* objects handled by the
** VDBE.
**
** When a user-defined function is called (see OP_Function), the Mem*
** objects that store the argument values for the function call are 
** passed to the user-defined function routine cast to sqlite3_value*.
** The user routine may then call sqlite3_value_data() or
** sqlite3_value_data16() to request a UTF-8 or UTF-16 string. If the
** string representation currently stored in Mem.z is not the requested
** encoding, then a translation occurs. To keep track of things, the
** MEM_Utf* flags are set correctly for the database encoding before a
** user-routine is called, and kept up to date if any translations occur
** thereafter.
** 
** When sqlite3_step() returns SQLITE3_ROW, indicating that a row of data
** is ready for processing by the caller, the data values are stored
** internally as Mem* objects. Before sqlite3_step() returns, the MEM_Utf*
** flags are set correctly for the database encoding. A translation may
** take place if the user requests a non-native encoding via
** sqlite3_column_data() or sqlite3_column_data16(). If this occurs, then
** the MEM_Utf* flags are updated accordingly.
*/
#define MEM_Utf8      0x0040   /* String uses UTF-8 encoding */
#define MEM_Utf16be   0x0080   /* String uses UTF-16 big-endian */
#define MEM_Utf16le   0x0100   /* String uses UTF-16 little-endian */

/* The following MEM_ value appears only in AggElem.aMem.s.flag fields.
** It indicates that the corresponding AggElem.aMem.z points to a
** aggregate function context that needs to be finalized.
*/
#define MEM_AggCtx    0x4000   /* Mem.z points to an agg function context */

*/
static int vdbeBindBlob(
  Vdbe *p,           /* Virtual machine */
  int i,             /* Var number to bind (numbered from 1 upward) */
  const char *zVal,  /* Pointer to blob of data */
  int bytes,         /* Number of bytes to copy */
  int copy,          /* True to copy the memory, false to copy a pointer */
  int flags          /* Valid combination of MEM_Blob, MEM_Str, MEM_Term */
){
  Mem *pVar;
  int rc;

  rc = vdbeUnbind(p, i);
  if( rc!=SQLITE_OK ){
    return rc;

  return vdbeBindBlob((Vdbe *)p, i, zData, nData, eCopy, flags);
}

/*
** Bind a UTF-16 text value to an SQL statement variable.
*/
int sqlite3_bind_text16(
  sqlite3_stmt *pStmt, 
  int i, 
  const void *zData, 
  int nData, 
  int eCopy
){
  Vdbe *p = (Vdbe *)pStmt;
  Mem *pVar;
  u8 db_enc = p->db->enc;            /* Text encoding of the database */
  u8 txt_enc;
  int null_term = 0;

  int flags;
  int rc;

  rc = vdbeUnbind(p, i);
  if( rc!=SQLITE_OK ){
    return rc;
  }
  pVar = &p->apVar[i-1];

  if( db_enc==TEXT_Utf8 ){
    /* If the database encoding is UTF-8, then do a translation. */
    pVar->z = sqlite3utf16to8(zData, nData, SQLITE3_BIGENDIAN);
    if( !pVar->z ) return SQLITE_NOMEM;
    pVar->n = strlen(pVar->z)+1;
    pVar->flags = MEM_Str|MEM_Term|MEM_Dyn;
    return SQLITE_OK;
  }
 

  /* There may or may not be a byte order mark at the start of the UTF-16.
  ** Either way set 'txt_enc' to the TEXT_Utf16* value indicating the 
  ** actual byte order used by this string. If the string does happen

  ** to contain a BOM, then move zData so that it points to the first
  ** byte after the BOM.
  */
  txt_enc = sqlite3UtfReadBom(zData, nData);
  if( txt_enc ){
    zData = (void *)(((u8 *)zData) + 2);
  }else{
    txt_enc = SQLITE3_BIGENDIAN?TEXT_Utf16be:TEXT_Utf16le;
  }

  if( nData<0 ){
    nData = sqlite3utf16ByteLen(zData, -1) + 2;
    null_term = 1;
  }else if( nData>1 && !((u8*)zData)[nData-1] && !((u8*)zData)[nData-2] ){
    null_term = 1;
  }

  if( db_enc==txt_enc && !eCopy ){
    /* If the byte order of the string matches the byte order of the
    ** database and the eCopy parameter is not set, then the string can
    ** be used without making a copy.
    */
    pVar->z = (char *)zData;
    pVar->n = nData;
    pVar->flags = MEM_Str|MEM_Static|(null_term?MEM_Term:0);
  }else{
    /* Make a copy. Swap the byte order if required */
    pVar->n = nData + (null_term?0:2);
    pVar->z = sqliteMalloc(pVar->n);
    pVar->flags = MEM_Str|MEM_Dyn|MEM_Term;
    if( db_enc==txt_enc ){
      memcpy(pVar->z, zData, nData);
    }else{
      swab(zData, pVar->z, nData);
    }
    pVar->z[pVar->n-1] = '\0';
    pVar->z[pVar->n-2] = '\0';
  }

  return SQLITE_OK;
}

/*
** Bind a blob value to an SQL statement variable.
*/
int sqlite3_bind_blob(
  sqlite3_stmt *p, 

    if( i>=-2147483647 && i<=2147483647 ) return 3;
    return 4;
  }
  if( flags&MEM_Real ){
    return 5;
  }
  if( flags&MEM_Str ){
    int n = pMem->n;
    assert( n>=0 );

    if( pMem->flags&MEM_Term ){
      /* If the nul terminated flag is set we have to subtract something
      ** from the serial-type. Depending on the encoding there could be
      ** one or two 0x00 bytes at the end of the string. Check for these
      ** and subtract 2 from serial_
      */
      if( n>0 && !pMem->z[n-1] ) n--;
      if( n>0 && !pMem->z[n-1] ) n--;
    }
    return ((n*2) + 13);
  }
  if( flags&MEM_Blob ){
    return (pMem->n*2 + 12);
  }
  return 0;
}

}

/*
** Deserialize the data blob pointed to by buf as serial type serial_type
** and store the result in pMem.  Return the number of bytes read.
*/ 
int sqlite3VdbeSerialGet(
  const unsigned char *buf,     /* Buffer to deserialize from */
  u64 serial_type,              /* Serial type to deserialize */
  Mem *pMem,                    /* Memory cell to write value into */
  u8 enc      /* Text encoding. Used to determine nul term. character */
){
  int len;

  assert( serial_type!=0 );

  /* memset(pMem, 0, sizeof(pMem)); */
  pMem->flags = 0;

# 2001 September 15
#
# 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 runs all tests.
#
# $Id: quick.test,v 1.18 2004/05/23 13:30:59 danielk1977 Exp $

set testdir [file dirname $argv0]
source $testdir/tester.tcl
rename finish_test really_finish_test
proc finish_test {} {}
set ISQUICK 1

lappend EXCLUDE auth.test         ;# Cannot attach empty databases.
lappend EXCLUDE tableapi.test     ;# sqlite3_XX vs sqlite_XX problem
lappend EXCLUDE version.test      ;# uses the btree_meta API (not updated)

# Some tests fail in these file as a result of the partial manifest types
# implementation.
lappend EXCLUDE capi2.test 
lappend EXCLUDE enc2.test 


if {[sqlite -has-codec]} {
  lappend EXCLUDE \
    attach.test \
    attach2.test \
    auth.test \