C# sqlite3类代码示例

 internal static extern int sqlite3_prepare_v2(
     sqlite3* db, /* Database handle */
     string zSql, /* SQL statement, UTF-8 encoded */
     int nByte, /* Maximum length of zSql in bytes. */
     out sqlite3_stmt* ppStmt, /* OUT: Statement handle */
     out char* pzTail /* OUT: Pointer to unused portion of zSql */
     );

 // The token *pName contains the name of a database (either "main" or "temp" or the name of an attached db). This routine returns the
 // index of the named database in db->aDb[], or -1 if the named db does not exist.
 internal static int sqlite3FindDb(sqlite3 db, Token pName)
 {
     var zName = sqlite3NameFromToken(db, pName);
     var i = sqlite3FindDbName(db, zName);
     sqlite3DbFree(db, ref zName);
     return i;
 }

 /*
 ** This function invokes either the xRollback or xCommit method
 ** of each of the virtual tables in the sqlite3.aVTrans array. The method
 ** called is identified by the second argument, "offset", which is
 ** the offset of the method to call in the sqlite3_module structure.
 **
 ** The array is cleared after invoking the callbacks.
 */
 static void callFinaliser(sqlite3 db, int offset)
 {
     int i;
     if (db.aVTrans != null)
     {
         for (i = 0; i < db.nVTrans; i++)
         {
             VTable pVTab = db.aVTrans[i];
             sqlite3_vtab p = pVTab.pVtab;
             if (p != null)
             {
                 //int (*x)(sqlite3_vtab );
                 //x = *(int (*)(sqlite3_vtab ))((char )p.pModule + offset);
                 //if( x ) x(p);
                 if (offset == 0)
                 {
                     if (p.pModule.xCommit != null)
                         p.pModule.xCommit(p);
                 }
                 else
                 {
                     if (p.pModule.xRollback != null)
                         p.pModule.xRollback(p);
                 }
             }
             pVTab.iSavepoint = 0;
             sqlite3VtabUnlock(pVTab);
         }
         sqlite3DbFree(db, ref db.aVTrans);
         db.nVTrans = 0;
         db.aVTrans = null;
     }
 }

 /*
 ** Add a new module argument to pTable.azModuleArg[].
 ** The string is not copied - the pointer is stored.  The
 ** string will be freed automatically when the table is
 ** deleted.
 */
 static void addModuleArgument(sqlite3 db, Table pTable, string zArg)
 {
     int i = pTable.nModuleArg++;
     //int nBytes = sizeof(char )*(1+pTable.nModuleArg);
     //string[] azModuleArg;
     //sqlite3DbRealloc( db, pTable.azModuleArg, nBytes );
     if (pTable.azModuleArg == null || pTable.azModuleArg.Length < pTable.nModuleArg)
         Array.Resize(ref pTable.azModuleArg, 3 + pTable.nModuleArg);
     //if ( azModuleArg == null )
     //{
     //  int j;
     //  for ( j = 0; j < i; j++ )
     //  {
     //    sqlite3DbFree( db, ref pTable.azModuleArg[j] );
     //  }
     //  sqlite3DbFree( db, ref zArg );
     //  sqlite3DbFree( db, ref pTable.azModuleArg );
     //  pTable.nModuleArg = 0;
     //}
     //else
     {
         pTable.azModuleArg[i] = zArg;
         //pTable.azModuleArg[i + 1] = null;
         //azModuleArg[i+1] = 0;
     }
     //pTable.azModuleArg = azModuleArg;
 }

        private static bool CreateTable(sqlite3* db, string sql)
        {
            sqlite3_stmt* createTableStmt;
            char* tail;

            int error = NativeMethods.sqlite3_prepare_v2(db, sql, sql.Length, out createTableStmt, out tail);

            if (error != 0)
            {
                LogErrorWithTimeStamp("sqlite3_prepare_v2 -> " + sql + " failed to execute with SQLite error code: " + error);
                NativeMethods.sqlite3_finalize(createTableStmt);
                return false;
            }

            error = NativeMethods.sqlite3_step(createTableStmt);

            if (error != 101)
            {
                LogErrorWithTimeStamp("sqlite3_step -> " + sql + " failed to execute with SQLite error code: " + error);
                NativeMethods.sqlite3_finalize(createTableStmt);
                return false;
            }

            NativeMethods.sqlite3_finalize(createTableStmt);
            return true;
        }

 internal static extern int sqlite3_exec(
     sqlite3* db, /* An open database */
     string sql, /* SQL to be evaluated */
     IntPtr callback, /* Callback function */
     IntPtr firstArg, /* 1st argument to callback */
     IntPtr errmsg /* Error msg written here */
     );

    /*
** Execute zSql on database db. Return an error code.
*/
    static int execSql( sqlite3 db, string pzErrMsg, string zSql )
    {
      sqlite3_stmt pStmt = null;
#if !NDEBUG
      int rc;
      //VVA_ONLY( int rc; )
#endif
      if ( zSql == null )
      {
        return SQLITE_NOMEM;
      }
      if ( SQLITE_OK != sqlite3_prepare( db, zSql, -1, ref pStmt, 0 ) )
      {
        sqlite3SetString( ref pzErrMsg, db, sqlite3_errmsg( db ) );
        return sqlite3_errcode( db );
      }
#if !NDEBUG
      rc = sqlite3_step( pStmt );
      //VVA_ONLY( rc = ) sqlite3_step(pStmt);
      Debug.Assert( rc != SQLITE_ROW );
#else
sqlite3_step(pStmt);
#endif
      return vacuumFinalize( db, pStmt, pzErrMsg );
    }

 /*
 ** pTab is a pointer to a Table structure representing a virtual-table.
 ** Return a pointer to the VTable object used by connection db to access
 ** this virtual-table, if one has been created, or NULL otherwise.
 */
 VTable *sqlite3GetVTable(sqlite3 *db, Table *pTab)
 {
     VTable *pVtab;
       assert( IsVirtual(pTab) );
       for(pVtab=pTab->pVTable; pVtab && pVtab->db!=db; pVtab=pVtab->pNext);
       return pVtab;
 }

        /*
        ** The first parameter (pDef) is a function implementation.  The
        ** second parameter (pExpr) is the first argument to this function.
        ** If pExpr is a column in a virtual table, then let the virtual
        ** table implementation have an opportunity to overload the function.
        **
        ** This routine is used to allow virtual table implementations to
        ** overload MATCH, LIKE, GLOB, and REGEXP operators.
        **
        ** Return either the pDef argument (indicating no change) or a
        ** new FuncDef structure that is marked as ephemeral using the
        ** SQLITE_FUNC_EPHEM flag.
        */
        FuncDef *sqlite3VtabOverloadFunction(
            sqlite3 *db,    /* Database connection for reporting malloc problems */
            FuncDef *pDef,  /* Function to possibly overload */
            int nArg,       /* Number of arguments to the function */
            Expr *pExpr     /* First argument to the function */
            )
        {
            Table *pTab;
              sqlite3_vtab *pVtab;
              sqlite3_module *pMod;
              void (*xFunc)(sqlite3_context*,int,sqlite3_value**) = 0;
              void *pArg = 0;
              FuncDef *pNew;
              int rc = 0;
              char *zLowerName;
              unsigned char *z;

              /* Check to see the left operand is a column in a virtual table */
              if( NEVER(pExpr==0) ) return pDef;
              if( pExpr->op!=TK_COLUMN ) return pDef;
              pTab = pExpr->pTab;
              if( NEVER(pTab==0) ) return pDef;
              if( (pTab->tabFlags & TF_Virtual)==0 ) return pDef;
              pVtab = sqlite3GetVTable(db, pTab)->pVtab;
              assert( pVtab!=0 );
              assert( pVtab->pModule!=0 );
              pMod = (sqlite3_module *)pVtab->pModule;
              if( pMod->xFindFunction==0 ) return pDef;

              /* Call the xFindFunction method on the virtual table implementation
              ** to see if the implementation wants to overload this function
              */
              zLowerName = sqlite3DbStrDup(db, pDef->zName);
              if( zLowerName ){
            for(z=(unsigned char*)zLowerName; *z; z++){
              *z = sqlite3UpperToLower[*z];
            }
            rc = pMod->xFindFunction(pVtab, nArg, zLowerName, &xFunc, &pArg);
            sqlite3DbFree(db, zLowerName);
              }
              if( rc==0 ){
            return pDef;
              }

              /* Create a new ephemeral function definition for the overloaded
              ** function */
              pNew = sqlite3DbMallocZero(db, sizeof(*pNew)
                             + sqlite3Strlen30(pDef->zName) + 1);
              if( pNew==0 ){
            return pDef;
              }
              *pNew = *pDef;
              pNew->zName = (char *)&pNew[1];
              memcpy(pNew->zName, pDef->zName, sqlite3Strlen30(pDef->zName)+1);
              pNew->xFunc = xFunc;
              pNew->pUserData = pArg;
              pNew->flags |= SQLITE_FUNC_EPHEM;
              return pNew;
        }

 internal static void CheckOk(sqlite3 db, int rc)
 {
     int extended = raw.sqlite3_extended_errcode(db);
     if (raw.SQLITE_OK != rc)
     {
         throw SQLiteException.Create(rc, extended, raw.sqlite3_errmsg(db));
     }
 }

 // Reclaim the memory used by an index
 internal static void freeIndex(sqlite3 db, ref Index p)
 {
     #if !SQLITE_OMIT_ANALYZE
     sqlite3DeleteIndexSamples(db, p);
     #endif
     sqlite3DbFree(db, ref p.zColAff);
     sqlite3DbFree(db, ref p);
 }

 //OVERLOADS 
 static public int sqlite3_exec(
 sqlite3 db,             /* The database on which the SQL executes */
 string zSql,            /* The SQL to be executed */
 int NoCallback, int NoArgs, int NoErrors
 )
 {
   string Errors = "";
   return sqlite3_exec( db, zSql, null, null, ref Errors );
 }

    /*
    ** 2003 April 6
    **
    ** 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 used to implement the VACUUM command.
    **
    ** Most of the code in this file may be omitted by defining the
    ** SQLITE_OMIT_VACUUM macro.
    *************************************************************************
    **  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"

#if !SQLITE_OMIT_VACUUM && !SQLITE_OMIT_ATTACH
    /*
** Finalize a prepared statement.  If there was an error, store the
** text of the error message in *pzErrMsg.  Return the result code.
*/
    static int vacuumFinalize( sqlite3 db, sqlite3_stmt pStmt, string pzErrMsg )
    {
      int rc;
      rc = sqlite3VdbeFinalize( ref pStmt );
      if ( rc != 0 )
      {
        sqlite3SetString( ref pzErrMsg, db, sqlite3_errmsg( db ) );
      }
      return rc;
    }

 /*
 ** This is the entry point to register the extension for the cube() function.
 */
 static int cube_init(
 sqlite3 db,
 ref string pzErrMsg,
 sqlite3_api_routines pApi
 )
 {
   sqlite3_api = pApi; //SQLITE_EXTENSION_INIT2( pApi );
   sqlite3_create_function( db, "cube", 1, SQLITE_ANY, 0, cubeFunc, null, null );
   return 0;
 }

/*
** Open a blob handle.
*/
int sqlite3_blob_open(
  sqlite3* db,            /* The database connection */
  string zDb,        /* The attached database containing the blob */
  string zTable,     /* The table containing the blob */
  string zColumn,    /* The column containing the blob */
  sqlite_int64 iRow,      /* The row containing the glob */
  int flags,              /* True -> read/write access, false -> read-only */
  sqlite3_blob **ppBlob   /* Handle for accessing the blob returned here */
){
  int nAttempt = 0;
  int iCol;               /* Index of zColumn in row-record */