using System;
using System.Diagnostics;
using System.Text;

using u8 = System.Byte;

namespace Community.CsharpSqlite
{
  public partial class Sqlite3
  {
    /*
    ** 2006 June 10
    **
    ** 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 help implement virtual tables.
    *************************************************************************
    **  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-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2
    **
    *************************************************************************
    */
#if !SQLITE_OMIT_VIRTUALTABLE
    //#include "sqliteInt.h"

    /*
    ** Before a virtual table xCreate() or xConnect() method is invoked, the
    ** sqlite3.pVtabCtx member variable is set to point to an instance of
    ** this struct allocated on the stack. It is used by the implementation of 
    ** the sqlite3_declare_vtab() and sqlite3_vtab_config() APIs, both of which
    ** are invoked only from within xCreate and xConnect methods.
    */
    public class VtabCtx
    {
      public Table pTab;
      public VTable pVTable;
    };

    /*
    ** The actual function that does the work of creating a new module.
    ** This function implements the sqlite3_create_module() and
    ** sqlite3_create_module_v2() interfaces.
    */
    static int createModule(
      sqlite3 db,              /* Database in which module is registered */
      string zName,            /* Name assigned to this module */
      sqlite3_module pModule,  /* The definition of the module */
      object pAux,             /* Context pointer for xCreate/xConnect */
      smdxDestroy xDestroy     /* Module destructor function */
    )
    {
      int rc, nName;
      Module pMod;

      sqlite3_mutex_enter( db.mutex );
      nName = sqlite3Strlen30( zName );
      pMod = new Module();//  (Module)sqlite3DbMallocRaw( db, sizeof( Module ) + nName + 1 );
      if ( pMod != null )
      {
        Module pDel;
        string zCopy;// = (char )(&pMod[1]);
        zCopy = zName;//memcpy(zCopy, zName, nName+1);
        pMod.zName = zCopy;
        pMod.pModule = pModule;
        pMod.pAux = pAux;
        pMod.xDestroy = xDestroy;
        pDel = (Module)sqlite3HashInsert( ref db.aModule, zCopy, nName, pMod );
        if ( pDel != null && pDel.xDestroy != null )
        {
          sqlite3ResetInternalSchema( db, -1 );
          pDel.xDestroy( ref pDel.pAux );
        }
        sqlite3DbFree( db, ref pDel );
        //if( pDel==pMod ){
        //  db.mallocFailed = 1;
        //}
      }
      else if ( xDestroy != null )
      {
        xDestroy( ref pAux );
      }
      rc = sqlite3ApiExit( db, SQLITE_OK );
      sqlite3_mutex_leave( db.mutex );
      return rc;
    }


    /*
    ** External API function used to create a new virtual-table module.
    */
    static int sqlite3_create_module(
      sqlite3 db,               /* Database in which module is registered */
      string zName,             /* Name assigned to this module */
      sqlite3_module pModule,   /* The definition of the module */
      object pAux               /* Context pointer for xCreate/xConnect */
    )
    {
      return createModule( db, zName, pModule, pAux, null );
    }

    /*
    ** External API function used to create a new virtual-table module.
    */
    static int sqlite3_create_module_v2(
      sqlite3 db,               /* Database in which module is registered */
      string zName,             /* Name assigned to this module */
      sqlite3_module pModule,   /* The definition of the module */
      sqlite3_vtab pAux,        /* Context pointer for xCreate/xConnect */
      smdxDestroy xDestroy      /* Module destructor function */
    )
    {
      return createModule( db, zName, pModule, pAux, xDestroy );
    }

    /*
    ** Lock the virtual table so that it cannot be disconnected.
    ** Locks nest.  Every lock should have a corresponding unlock.
    ** If an unlock is omitted, resources leaks will occur.  
    **
    ** If a disconnect is attempted while a virtual table is locked,
    ** the disconnect is deferred until all locks have been removed.
    */
    static void sqlite3VtabLock( VTable pVTab )
    {
      pVTab.nRef++;
    }


    /*
    ** 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.
    */
    static VTable sqlite3GetVTable( sqlite3 db, Table pTab )
    {
      VTable pVtab;
      Debug.Assert( IsVirtual( pTab ) );
      for ( pVtab = pTab.pVTable; pVtab != null && pVtab.db != db; pVtab = pVtab.pNext )
        ;
      return pVtab;
    }

    /*
    ** Decrement the ref-count on a virtual table object. When the ref-count
    ** reaches zero, call the xDisconnect() method to delete the object.
    */
    static void sqlite3VtabUnlock( VTable pVTab )
    {
      sqlite3 db = pVTab.db;

      Debug.Assert( db != null);
      Debug.Assert( pVTab.nRef > 0 );
      Debug.Assert( sqlite3SafetyCheckOk( db ) );

      pVTab.nRef--;
      if ( pVTab.nRef == 0 )
      {
        object p = pVTab.pVtab;
        if ( p != null )
        {
          ((sqlite3_vtab)p).pModule.xDisconnect( ref p );
        }
        sqlite3DbFree( db, ref pVTab );
      }
    }

    /*
    ** Table p is a virtual table. This function moves all elements in the
    ** p.pVTable list to the sqlite3.pDisconnect lists of their associated
    ** database connections to be disconnected at the next opportunity. 
    ** Except, if argument db is not NULL, then the entry associated with
    ** connection db is left in the p.pVTable list.
    */
    static VTable vtabDisconnectAll( sqlite3 db, Table p )
    {
      VTable pRet = null;
      VTable pVTable = p.pVTable;
      p.pVTable = null;

      /* Assert that the mutex (if any) associated with the BtShared database 
      ** that contains table p is held by the caller. See header comments 
      ** above function sqlite3VtabUnlockList() for an explanation of why
      ** this makes it safe to access the sqlite3.pDisconnect list of any
      ** database connection that may have an entry in the p.pVTable list.
      */
      Debug.Assert( db == null || sqlite3SchemaMutexHeld( db, 0, p.pSchema ) );

      while ( pVTable != null )
      {
        sqlite3 db2 = pVTable.db;
        VTable pNext = pVTable.pNext;
        Debug.Assert( db2 != null );
        if ( db2 == db )
        {
          pRet = pVTable;
          p.pVTable = pRet;
          pRet.pNext = null;
        }
        else
        {
          pVTable.pNext = db2.pDisconnect;
          db2.pDisconnect = pVTable;
        }
        pVTable = pNext;
      }

      Debug.Assert( null == db || pRet != null );
      return pRet;
    }


    /*
    ** Disconnect all the virtual table objects in the sqlite3.pDisconnect list.
    **
    ** This function may only be called when the mutexes associated with all
    ** shared b-tree databases opened using connection db are held by the 
    ** caller. This is done to protect the sqlite3.pDisconnect list. The
    ** sqlite3.pDisconnect list is accessed only as follows:
    **
    **   1) By this function. In this case, all BtShared mutexes and the mutex
    **      associated with the database handle itself must be held.
    **
    **   2) By function vtabDisconnectAll(), when it adds a VTable entry to
    **      the sqlite3.pDisconnect list. In this case either the BtShared mutex
    **      associated with the database the virtual table is stored in is held
    **      or, if the virtual table is stored in a non-sharable database, then
    **      the database handle mutex is held.
    **
    ** As a result, a sqlite3.pDisconnect cannot be accessed simultaneously 
    ** by multiple threads. It is thread-safe.
    */
    static void sqlite3VtabUnlockList( sqlite3 db )
    {
      VTable p = db.pDisconnect;
      db.pDisconnect = null;

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

      if ( p != null )
      {
        sqlite3ExpirePreparedStatements( db );
        do
        {
          VTable pNext = p.pNext;
          sqlite3VtabUnlock( p );
          p = pNext;
        } while ( p != null );
      }
    }

    /*
    ** Clear any and all virtual-table information from the Table record.
    ** This routine is called, for example, just before deleting the Table
    ** record.
    **
    ** Since it is a virtual-table, the Table structure contains a pointer
    ** to the head of a linked list of VTable structures. Each VTable 
    ** structure is associated with a single sqlite3* user of the schema.
    ** The reference count of the VTable structure associated with database 
    ** connection db is decremented immediately (which may lead to the 
    ** structure being xDisconnected and free). Any other VTable structures
    ** in the list are moved to the sqlite3.pDisconnect list of the associated 
    ** database connection.
    */
    static void sqlite3VtabClear( sqlite3 db, Table p )
    {
      if ( null == db || db.pnBytesFreed == 0 )
        vtabDisconnectAll( null, p );
      if ( p.azModuleArg != null )
      {
        int i;
        for ( i = 0; i < p.nModuleArg; i++ )
        {
          sqlite3DbFree( db, ref p.azModuleArg[i] );
        }
        sqlite3DbFree( db, ref p.azModuleArg );
      }
    }

    /*
    ** 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;
    }

    /*
    ** The parser calls this routine when it first sees a CREATE VIRTUAL TABLE
    ** statement.  The module name has been parsed, but the optional list
    ** of parameters that follow the module name are still pending.
    */
    static void sqlite3VtabBeginParse(
      Parse pParse,        /* Parsing context */
      Token pName1,        /* Name of new table, or database name */
      Token pName2,        /* Name of new table or NULL */
      Token pModuleName    /* Name of the module for the virtual table */
    )
    {
      int iDb;              /* The database the table is being created in */
      Table pTable;        /* The new virtual table */
      sqlite3 db;          /* Database connection */

      sqlite3StartTable( pParse, pName1, pName2, 0, 0, 1, 0 );
      pTable = pParse.pNewTable;
      if ( pTable == null )
        return;
      Debug.Assert( null == pTable.pIndex );

      db = pParse.db;
      iDb = sqlite3SchemaToIndex( db, pTable.pSchema );
      Debug.Assert( iDb >= 0 );

      pTable.tabFlags |= TF_Virtual;
      pTable.nModuleArg = 0;
      addModuleArgument( db, pTable, sqlite3NameFromToken( db, pModuleName ) );
      addModuleArgument( db, pTable, db.aDb[iDb].zName);//sqlite3DbStrDup( db, db.aDb[iDb].zName ) );
      addModuleArgument( db, pTable, pTable.zName );//sqlite3DbStrDup( db, pTable.zName ) );
      pParse.sNameToken.n = pParse.sNameToken.z.Length;//      (int)[pModuleName.n] - pName1.z );

#if !SQLITE_OMIT_AUTHORIZATION
  /* Creating a virtual table invokes the authorization callback twice.
  ** The first invocation, to obtain permission to INSERT a row into the
  ** sqlite_master table, has already been made by sqlite3StartTable().
  ** The second call, to obtain permission to create the table, is made now.
  */
  if( pTable->azModuleArg ){
    sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName, 
            pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
  }
#endif
    }

    /*
    ** This routine takes the module argument that has been accumulating
    ** in pParse.zArg[] and appends it to the list of arguments on the
    ** virtual table currently under construction in pParse.pTable.
    */
    static void addArgumentToVtab( Parse pParse )
    {
      if ( pParse.sArg.z != null && ALWAYS( pParse.pNewTable ) )
      {
        string z = pParse.sArg.z.Substring( 0, pParse.sArg.n );
        ////int n = pParse.sArg.n;
        sqlite3 db = pParse.db;
        addModuleArgument( db, pParse.pNewTable, z );////sqlite3DbStrNDup( db, z, n ) );
      }
    }

    /*
    ** The parser calls this routine after the CREATE VIRTUAL TABLE statement
    ** has been completely parsed.
    */
    static void sqlite3VtabFinishParse( Parse pParse, Token pEnd )
    {
      Table pTab = pParse.pNewTable;  /* The table being constructed */
      sqlite3 db = pParse.db;         /* The database connection */

      if ( pTab == null )
        return;
      addArgumentToVtab( pParse );
      pParse.sArg.z = "";
      if ( pTab.nModuleArg < 1 )
        return;

      /* If the CREATE VIRTUAL TABLE statement is being entered for the
      ** first time (in other words if the virtual table is actually being
      ** created now instead of just being read out of sqlite_master) then
      ** do additional initialization work and store the statement text
      ** in the sqlite_master table.
      */
      if ( 0 == db.init.busy )
      {
        string zStmt;
        string zWhere;
        int iDb;
        Vdbe v;

        /* Compute the complete text of the CREATE VIRTUAL TABLE statement */
        if ( pEnd != null )
        {
          pParse.sNameToken.n = pParse.sNameToken.z.Length;//(int)( pEnd.z - pParse.sNameToken.z ) + pEnd.n;
        }
        zStmt = sqlite3MPrintf( db, "CREATE VIRTUAL TABLE %T", pParse.sNameToken.z.Substring(0,pParse.sNameToken.n) );

        /* A slot for the record has already been allocated in the 
        ** SQLITE_MASTER table.  We just need to update that slot with all
        ** the information we've collected.  
        **
        ** The VM register number pParse.regRowid holds the rowid of an
        ** entry in the sqlite_master table tht was created for this vtab
        ** by sqlite3StartTable().
        */
        iDb = sqlite3SchemaToIndex( db, pTab.pSchema );
        sqlite3NestedParse( pParse,
          "UPDATE %Q.%s " +
             "SET type='table', name=%Q, tbl_name=%Q, rootpage=0, sql=%Q " +
           "WHERE rowid=#%d",
          db.aDb[iDb].zName, SCHEMA_TABLE( iDb ),
          pTab.zName,
          pTab.zName,
          zStmt,
          pParse.regRowid
        );
        sqlite3DbFree( db, ref zStmt );
        v = sqlite3GetVdbe( pParse );
        sqlite3ChangeCookie( pParse, iDb );

        sqlite3VdbeAddOp2( v, OP_Expire, 0, 0 );
        zWhere = sqlite3MPrintf( db, "name='%q' AND type='table'", pTab.zName );
        sqlite3VdbeAddParseSchemaOp( v, iDb, zWhere );
        sqlite3VdbeAddOp4( v, OP_VCreate, iDb, 0, 0,
                             pTab.zName, sqlite3Strlen30( pTab.zName ) + 1 );
      }

      /* If we are rereading the sqlite_master table create the in-memory
      ** record of the table. The xConnect() method is not called until
      ** the first time the virtual table is used in an SQL statement. This
      ** allows a schema that contains virtual tables to be loaded before
      ** the required virtual table implementations are registered.  */
      else
      {
        Table pOld;
        Schema pSchema = pTab.pSchema;
        string zName = pTab.zName;
        int nName = sqlite3Strlen30( zName );
        Debug.Assert( sqlite3SchemaMutexHeld( db, 0, pSchema ) );
        pOld = sqlite3HashInsert( ref pSchema.tblHash, zName, nName, pTab );
        if ( pOld != null )
        {
          //db.mallocFailed = 1;
          Debug.Assert( pTab == pOld );  /* Malloc must have failed inside HashInsert() */
          return;
        }
        pParse.pNewTable = null;
      }
    }

    /*
    ** The parser calls this routine when it sees the first token
    ** of an argument to the module name in a CREATE VIRTUAL TABLE statement.
    */
    static void sqlite3VtabArgInit( Parse pParse )
    {
      addArgumentToVtab( pParse );
      pParse.sArg.z = null;
      pParse.sArg.n = 0;
    }

    /*
    ** The parser calls this routine for each token after the first token
    ** in an argument to the module name in a CREATE VIRTUAL TABLE statement.
    */
    static void sqlite3VtabArgExtend( Parse pParse, Token p )
    {
      Token pArg = pParse.sArg;
      if ( pArg.z == null )
      {
        pArg.z = p.z;
        pArg.n = p.n;
      }
      else
      {
        //Debug.Assert( pArg.z< p.z );
        pArg.n += p.n+1;//(int)( p.z[p.n] - pArg.z );
      }
    }

    /*
    ** Invoke a virtual table constructor (either xCreate or xConnect). The
    ** pointer to the function to invoke is passed as the fourth parameter
    ** to this procedure.
    */
    static int vtabCallConstructor(
      sqlite3 db,
      Table pTab,
      Module pMod,
      smdxCreateConnect xConstruct,
      ref string pzErr
    )
    {
      VtabCtx sCtx = new VtabCtx();
      VTable pVTable;
      int rc;
      string[] azArg = pTab.azModuleArg;
      int nArg = pTab.nModuleArg;
      string zErr = null;
      string zModuleName = sqlite3MPrintf( db, "%s", pTab.zName );

      //if ( String.IsNullOrEmpty( zModuleName ) )
      //{
      //  return SQLITE_NOMEM;
      //}

      pVTable = new VTable();//sqlite3DbMallocZero( db, sizeof( VTable ) );
      //if ( null == pVTable )
      //{
      //  sqlite3DbFree( db, ref zModuleName );
      //  return SQLITE_NOMEM;
      //}
      pVTable.db = db;
      pVTable.pMod = pMod;

      /* Invoke the virtual table constructor */
      //assert( &db->pVtabCtx );
      Debug.Assert( xConstruct != null );
      sCtx.pTab = pTab;
      sCtx.pVTable = pVTable;
      db.pVtabCtx = sCtx;
      rc = xConstruct( db, pMod.pAux, nArg, azArg, out pVTable.pVtab, out zErr );
      db.pVtabCtx = null;
      //if ( rc == SQLITE_NOMEM )
      //  db.mallocFailed = 1;

      if ( SQLITE_OK != rc )
      {
        if ( zErr == "" )
        {
          pzErr = sqlite3MPrintf( db, "vtable constructor failed: %s", zModuleName );
        }
        else
        {
          pzErr = sqlite3MPrintf( db, "%s", zErr );
          zErr = null;//sqlite3_free( zErr );
        }
        sqlite3DbFree( db, ref pVTable );
      }
      else if ( ALWAYS( pVTable.pVtab ) )
      {
        /* Justification of ALWAYS():  A correct vtab constructor must allocate
        ** the sqlite3_vtab object if successful.  */
        pVTable.pVtab.pModule = pMod.pModule;
        pVTable.nRef = 1;
        if ( sCtx.pTab != null )
        {
          string zFormat = "vtable constructor did not declare schema: %s";
          pzErr = sqlite3MPrintf( db, zFormat, pTab.zName );
          sqlite3VtabUnlock( pVTable );
          rc = SQLITE_ERROR;
        }
        else
        {
          int iCol;
          /* If everything went according to plan, link the new VTable structure
          ** into the linked list headed by pTab->pVTable. Then loop through the 
          ** columns of the table to see if any of them contain the token "hidden".
          ** If so, set the Column.isHidden flag and remove the token from
          ** the type string.  */
          pVTable.pNext = pTab.pVTable;
          pTab.pVTable = pVTable;

          for ( iCol = 0; iCol < pTab.nCol; iCol++ )
          {
            if ( String.IsNullOrEmpty( pTab.aCol[iCol].zType ) )
              continue;
            StringBuilder zType = new StringBuilder( pTab.aCol[iCol].zType);
            int nType;
            int i = 0;
            //if ( zType )
            //  continue;
            nType = sqlite3Strlen30( zType );
            if ( sqlite3StrNICmp( "hidden", 0, zType.ToString(), 6 ) != 0 || ( zType.Length > 6 && zType[6] != ' ' ) )
            {
              for ( i = 0; i < nType; i++ )
              {
                if ( ( 0 == sqlite3StrNICmp( " hidden", zType.ToString().Substring( i ), 7 ) )
                 && ( i+7 == zType.Length || (zType[i + 7] == '\0' || zType[i + 7] == ' ' ))
                )
                {
                  i++;
                  break;
                }
              }
            }
            if ( i < nType )
            {
              int j;
              int nDel = 6 + ( zType.Length > i + 6 ? 1 : 0 );
              for ( j = i; ( j + nDel ) < nType; j++ )
              {
                zType[j] = zType[j + nDel];
              }
              if ( zType[i] == '\0' && i > 0 )
              {
                Debug.Assert( zType[i - 1] == ' ' );
                zType.Length = i;//[i - 1] = '\0';
              }
              pTab.aCol[iCol].isHidden = 1;
              pTab.aCol[iCol].zType = zType.ToString().Substring(0,j);
            }
          }
        }
      }

      sqlite3DbFree( db, ref zModuleName );
      return rc;
    }

    /*
    ** This function is invoked by the parser to call the xConnect() method
    ** of the virtual table pTab. If an error occurs, an error code is returned 
    ** and an error left in pParse.
    **
    ** This call is a no-op if table pTab is not a virtual table.
    */
    static int sqlite3VtabCallConnect( Parse pParse, Table pTab )
    {
      sqlite3 db = pParse.db;
      string zMod;
      Module pMod;
      int rc;

      Debug.Assert( pTab != null);
      if ( ( pTab.tabFlags & TF_Virtual ) == 0 || sqlite3GetVTable( db, pTab )!= null )
      {
        return SQLITE_OK;
      }

      /* Locate the required virtual table module */
      zMod = pTab.azModuleArg[0];
      pMod = (Module)sqlite3HashFind( db.aModule, zMod, sqlite3Strlen30( zMod ), (Module)null );

      if ( null == pMod )
      {
        string zModule = pTab.azModuleArg[0];
        sqlite3ErrorMsg( pParse, "no such module: %s", zModule );
        rc = SQLITE_ERROR;
      }
      else
      {
        string zErr = null;
        rc = vtabCallConstructor( db, pTab, pMod, pMod.pModule.xConnect, ref zErr );
        if ( rc != SQLITE_OK )
        {
          sqlite3ErrorMsg( pParse, "%s", zErr );
        }
        zErr = null;//sqlite3DbFree( db, zErr );
      }

      return rc;
    }
    /*
    ** Grow the db.aVTrans[] array so that there is room for at least one
    ** more v-table. Return SQLITE_NOMEM if a malloc fails, or SQLITE_OK otherwise.
    */
    static int growVTrans( sqlite3 db )
    {
      const int ARRAY_INCR = 5;

      /* Grow the sqlite3.aVTrans array if required */
      if ( ( db.nVTrans % ARRAY_INCR ) == 0 )
      {
        //VTable** aVTrans;
        //int nBytes = sizeof( sqlite3_vtab* ) * ( db.nVTrans + ARRAY_INCR );
        //aVTrans = sqlite3DbRealloc( db, (void)db.aVTrans, nBytes );
        //if ( !aVTrans )
        //{
        //  return SQLITE_NOMEM;
        //}
        //memset( &aVTrans[db.nVTrans], 0, sizeof( sqlite3_vtab* ) * ARRAY_INCR );
        Array.Resize( ref db.aVTrans, db.nVTrans + ARRAY_INCR );
      }

      return SQLITE_OK;
    }

    /*
    ** Add the virtual table pVTab to the array sqlite3.aVTrans[]. Space should
    ** have already been reserved using growVTrans().
    */
    static void addToVTrans( sqlite3 db, VTable pVTab )
    {
      /* Add pVtab to the end of sqlite3.aVTrans */
      db.aVTrans[db.nVTrans++] = pVTab;
      sqlite3VtabLock( pVTab );
    }

    /*
    ** This function is invoked by the vdbe to call the xCreate method
    ** of the virtual table named zTab in database iDb. 
    **
    ** If an error occurs, *pzErr is set to point an an English language
    ** description of the error and an SQLITE_XXX error code is returned.
    ** In this case the caller must call sqlite3DbFree(db, ) on *pzErr.
    */
    static int sqlite3VtabCallCreate( sqlite3 db, int iDb, string zTab, ref string pzErr )
    {
      int rc = SQLITE_OK;
      Table pTab;
      Module pMod;
      string zMod;

      pTab = sqlite3FindTable( db, zTab, db.aDb[iDb].zName );
      Debug.Assert( pTab != null && ( pTab.tabFlags & TF_Virtual ) != 0 && null == pTab.pVTable );

      /* Locate the required virtual table module */
      zMod = pTab.azModuleArg[0];
      pMod = (Module)sqlite3HashFind( db.aModule, zMod, sqlite3Strlen30( zMod ), (Module)null );

      /* If the module has been registered and includes a Create method, 
      ** invoke it now. If the module has not been registered, return an 
      ** error. Otherwise, do nothing.
      */
      if ( null == pMod )
      {
        pzErr = sqlite3MPrintf( db, "no such module: %s", zMod );
        rc = SQLITE_ERROR;
      }
      else
      {
        rc = vtabCallConstructor( db, pTab, pMod, pMod.pModule.xCreate, ref pzErr );
      }

      /* Justification of ALWAYS():  The xConstructor method is required to
      ** create a valid sqlite3_vtab if it returns SQLITE_OK. */
      if ( rc == SQLITE_OK && ALWAYS( sqlite3GetVTable( db, pTab ) ) )
      {
        rc = growVTrans( db );
        if ( rc == SQLITE_OK )
        {
          addToVTrans( db, sqlite3GetVTable( db, pTab ) );
        }
      }

      return rc;
    }

    /*
    ** This function is used to set the schema of a virtual table.  It is only
    ** valid to call this function from within the xCreate() or xConnect() of a
    ** virtual table module.
    */
    static int sqlite3_declare_vtab( sqlite3 db, string zCreateTable )
    {
      Parse pParse;

      int rc = SQLITE_OK;
      Table pTab;
      string zErr = "";

      sqlite3_mutex_enter( db.mutex );
      if ( null == db.pVtabCtx || null == ( pTab = db.pVtabCtx.pTab ) )
      {
        sqlite3Error( db, SQLITE_MISUSE, 0 );
        sqlite3_mutex_leave( db.mutex );
        return SQLITE_MISUSE_BKPT();
      }
      Debug.Assert( ( pTab.tabFlags & TF_Virtual ) != 0 );

      pParse = new Parse();//sqlite3StackAllocZero(db, sizeof(*pParse));
      //if ( pParse == null )
      //{
      //  rc = SQLITE_NOMEM;
      //}
      //else
      {
        pParse.declareVtab = 1;
        pParse.db = db;
        pParse.nQueryLoop = 1;

        if ( SQLITE_OK == sqlite3RunParser( pParse, zCreateTable, ref zErr )
         && pParse.pNewTable != null
         //&& !db.mallocFailed
         && null==pParse.pNewTable.pSelect
         && ( pParse.pNewTable.tabFlags & TF_Virtual ) == 0
        )
        {
          if ( null==pTab.aCol )
          {
            pTab.aCol = pParse.pNewTable.aCol;
            pTab.nCol = pParse.pNewTable.nCol;
            pParse.pNewTable.nCol = 0;
            pParse.pNewTable.aCol = null;
          }
          db.pVtabCtx.pTab = null;
        }
        else
        {
          sqlite3Error( db, SQLITE_ERROR, ( zErr != null ? "%s" : null ), zErr );
          zErr = null;//sqlite3DbFree( db, zErr );
          rc = SQLITE_ERROR;
        }
        pParse.declareVtab = 0;

        if ( pParse.pVdbe !=null)
        {
          sqlite3VdbeFinalize( ref pParse.pVdbe );
        }
        sqlite3DeleteTable( db, ref pParse.pNewTable );
        //sqlite3StackFree( db, pParse );
      }

      Debug.Assert( ( rc & 0xff ) == rc );
      rc = sqlite3ApiExit( db, rc );
      sqlite3_mutex_leave( db.mutex );
      return rc;
    }

    /*
    ** This function is invoked by the vdbe to call the xDestroy method
    ** of the virtual table named zTab in database iDb. This occurs
    ** when a DROP TABLE is mentioned.
    **
    ** This call is a no-op if zTab is not a virtual table.
    */
    static int sqlite3VtabCallDestroy( sqlite3 db, int iDb, string zTab )
    {
      int rc = SQLITE_OK;
      Table pTab;

      pTab = sqlite3FindTable( db, zTab, db.aDb[iDb].zName );
      if ( ALWAYS( pTab != null && pTab.pVTable != null ) )
      {
        VTable p = vtabDisconnectAll( db, pTab );

        Debug.Assert( rc == SQLITE_OK );
        object obj = p.pVtab;
        rc = p.pMod.pModule.xDestroy( ref obj );
        p.pVtab = null;

        /* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */
        if ( rc == SQLITE_OK )
        {
          Debug.Assert( pTab.pVTable == p && p.pNext == null );
          p.pVtab = null;
          pTab.pVTable = null;
          sqlite3VtabUnlock( p );
        }
      }

      return rc;
    }

    /*
    ** 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;
      }
    }

    /*
    ** Invoke the xSync method of all virtual tables in the sqlite3.aVTrans
    ** array. Return the error code for the first error that occurs, or
    ** SQLITE_OK if all xSync operations are successful.
    **
    ** Set *pzErrmsg to point to a buffer that should be released using 
    ** sqlite3DbFree() containing an error message, if one is available.
    */
    static int sqlite3VtabSync( sqlite3 db, ref string pzErrmsg )
    {
      int i;
      int rc = SQLITE_OK;
      VTable[] aVTrans = db.aVTrans;

      db.aVTrans = null;
      for ( i = 0; rc == SQLITE_OK && i < db.nVTrans; i++ )
      {
        smdxFunction x;//int (*x)(sqlite3_vtab );
        sqlite3_vtab pVtab = aVTrans[i].pVtab;
        if ( pVtab != null && ( x = pVtab.pModule.xSync ) != null )
        {
          rc = x( pVtab );
          //sqlite3DbFree(db, ref pzErrmsg);
          pzErrmsg = pVtab.zErrMsg;// sqlite3DbStrDup( db, pVtab.zErrMsg );
          pVtab.zErrMsg = null;//sqlite3_free( ref pVtab.zErrMsg );
        }
      }
      db.aVTrans = aVTrans;
      return rc;
    }

    /*
    ** Invoke the xRollback method of all virtual tables in the 
    ** sqlite3.aVTrans array. Then clear the array itself.
    */
    static int sqlite3VtabRollback( sqlite3 db )
    {
      callFinaliser( db, 1 );//offsetof( sqlite3_module, xRollback ) );
      return SQLITE_OK;
    }

    /*
    ** Invoke the xCommit method of all virtual tables in the 
    ** sqlite3.aVTrans array. Then clear the array itself.
    */
    static int sqlite3VtabCommit( sqlite3 db )
    {
      callFinaliser( db, 0 );//offsetof( sqlite3_module, xCommit ) );
      return SQLITE_OK;
    }

    /*
    ** If the virtual table pVtab supports the transaction interface
    ** (xBegin/xRollback/xCommit and optionally xSync) and a transaction is
    ** not currently open, invoke the xBegin method now.
    **
    ** If the xBegin call is successful, place the sqlite3_vtab pointer
    ** in the sqlite3.aVTrans array.
    */
    static int sqlite3VtabBegin( sqlite3 db, VTable pVTab )
    {
      int rc = SQLITE_OK;
      sqlite3_module pModule;

      /* Special case: If db.aVTrans is NULL and db.nVTrans is greater
      ** than zero, then this function is being called from within a
      ** virtual module xSync() callback. It is illegal to write to 
      ** virtual module tables in this case, so return SQLITE_LOCKED.
      */
      if ( sqlite3VtabInSync( db ) )
      {
        return SQLITE_LOCKED;
      }
      if ( null == pVTab )
      {
        return SQLITE_OK;
      }
      pModule = pVTab.pVtab.pModule;

      if ( pModule.xBegin != null )
      {
        int i;

        /* If pVtab is already in the aVTrans array, return early */
        for ( i = 0; i < db.nVTrans; i++ )
        {
          if ( db.aVTrans[i] == pVTab )
          {
            return SQLITE_OK;
          }
        }

        /* Invoke the xBegin method. If successful, add the vtab to the 
        ** sqlite3.aVTrans[] array. */
        rc = growVTrans( db );
        if ( rc == SQLITE_OK )
        {
          rc = pModule.xBegin( pVTab.pVtab );
          if ( rc == SQLITE_OK )
          {
            addToVTrans( db, pVTab );
          }
        }
      }
      return rc;
    }

    /*
    ** Invoke either the xSavepoint, xRollbackTo or xRelease method of all
    ** virtual tables that currently have an open transaction. Pass iSavepoint
    ** as the second argument to the virtual table method invoked.
    **
    ** If op is SAVEPOINT_BEGIN, the xSavepoint method is invoked. If it is
    ** SAVEPOINT_ROLLBACK, the xRollbackTo method. Otherwise, if op is 
    ** SAVEPOINT_RELEASE, then the xRelease method of each virtual table with
    ** an open transaction is invoked.
    **
    ** If any virtual table method returns an error code other than SQLITE_OK, 
    ** processing is abandoned and the error returned to the caller of this
    ** function immediately. If all calls to virtual table methods are successful,
    ** SQLITE_OK is returned.
    */
    static int sqlite3VtabSavepoint( sqlite3 db, int op, int iSavepoint )
    {
      int rc = SQLITE_OK;

      Debug.Assert( op == SAVEPOINT_RELEASE || op == SAVEPOINT_ROLLBACK || op == SAVEPOINT_BEGIN );
      Debug.Assert( iSavepoint >= 0 );
      if ( db.aVTrans != null )
      {
        int i;
        for ( i = 0; rc == SQLITE_OK && i < db.nVTrans; i++ )
        {
          VTable pVTab = db.aVTrans[i];
          sqlite3_module pMod = pVTab.pMod.pModule;
          if ( pMod.iVersion >= 2 )
          {
            smdxFunctionArg xMethod = null; //int (*xMethod)(sqlite3_vtab *, int);
            switch ( op )
            {
              case SAVEPOINT_BEGIN:
                xMethod = pMod.xSavepoint;
                pVTab.iSavepoint = iSavepoint + 1;
                break;
              case SAVEPOINT_ROLLBACK:
                xMethod = pMod.xRollbackTo;
                break;
              default:
                xMethod = pMod.xRelease;
                break;
            }
            if ( xMethod != null && pVTab.iSavepoint > iSavepoint )
            {
              rc = xMethod( db.aVTrans[i].pVtab, iSavepoint );
            }
          }
        }
      }
      return rc;
    }

    /*
    ** 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.
    */
    static 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;
      dxFunc xFunc = null;//void (*xFunc)(sqlite3_context*,int,sqlite3_value*) = 0;
      object pArg = null;
      FuncDef pNew;
      int rc = 0;
      string zLowerName;
      string z;

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

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

      /* Create a new ephemeral function definition for the overloaded
      ** function */
      //sqlite3DbMallocZero(db, sizeof(*pNew)
      //      + sqlite3Strlen30(pDef.zName) + 1);
      //if ( pNew == null )
      //{
      //  return pDef;
      //}
      pNew = pDef.Copy();
      pNew.zName = pDef.zName;
      //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;
    }

    /*
    ** Make sure virtual table pTab is contained in the pParse.apVirtualLock[]
    ** array so that an OP_VBegin will get generated for it.  Add pTab to the
    ** array if it is missing.  If pTab is already in the array, this routine
    ** is a no-op.
    */
    static void sqlite3VtabMakeWritable( Parse pParse, Table pTab )
    {
      Parse pToplevel = sqlite3ParseToplevel( pParse );
      int i, n;
      //Table[] apVtabLock = null;

      Debug.Assert( IsVirtual( pTab ) );
      for ( i = 0; i < pToplevel.nVtabLock; i++ )
      {
        if ( pTab == pToplevel.apVtabLock[i] )
          return;
      }
      n = pToplevel.apVtabLock == null ? 1 : pToplevel.apVtabLock.Length + 1;//(pToplevel.nVtabLock+1)*sizeof(pToplevel.apVtabLock[0]);
      //sqlite3_realloc( pToplevel.apVtabLock, n );
      //if ( apVtabLock != null )
      {
        Array.Resize( ref pToplevel.apVtabLock, n );// pToplevel.apVtabLock= apVtabLock;
        pToplevel.apVtabLock[pToplevel.nVtabLock++] = pTab;
      }
      //else
      //{
      //  pToplevel.db.mallocFailed = 1;
      //}
    }

    static int[] aMap = new int[] { 
    SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE 
  };
    /*
    ** Return the ON CONFLICT resolution mode in effect for the virtual
    ** table update operation currently in progress.
    **
    ** The results of this routine are undefined unless it is called from
    ** within an xUpdate method.
    */
    static int sqlite3_vtab_on_conflict( sqlite3 db ){
  //static const unsigned char aMap[] = { 
  //  SQLITE_ROLLBACK, SQLITE_ABORT, SQLITE_FAIL, SQLITE_IGNORE, SQLITE_REPLACE 
  //};
  Debug.Assert( OE_Rollback==1 && OE_Abort==2 && OE_Fail==3 );
  Debug.Assert( OE_Ignore==4 && OE_Replace==5 );
  Debug.Assert( db.vtabOnConflict>=1 && db.vtabOnConflict<=5 );
  return (int)aMap[db.vtabOnConflict-1];
}

    /*
    ** Call from within the xCreate() or xConnect() methods to provide 
    ** the SQLite core with additional information about the behavior
    ** of the virtual table being implemented.
    */
    static int sqlite3_vtab_config( sqlite3 db, int op, params object[] ap ){ // TODO ...){
  //va_list ap;
  int rc = SQLITE_OK;

  sqlite3_mutex_enter(db.mutex);

  va_start(ap, "op");
  switch( op ){
    case SQLITE_VTAB_CONSTRAINT_SUPPORT: {
      VtabCtx p = db.pVtabCtx;
      if(  null == p ){
        rc = SQLITE_MISUSE_BKPT();
      }else{
        Debug.Assert( p.pTab == null || ( p.pTab.tabFlags & TF_Virtual ) != 0 );
        p.pVTable.bConstraint = (Byte)va_arg(ap, (Int32)0);
      }
      break;
    }
    default:
      rc = SQLITE_MISUSE_BKPT();
      break;
  }
  va_end(ref ap);

  if( rc!=SQLITE_OK ) sqlite3Error(db, rc, 0);
  sqlite3_mutex_leave(db.mutex);
  return rc;
}

#endif //* SQLITE_OMIT_VIRTUALTABLE */
  }
}