rhodes 2.3.2 → 2.4.0.beta.1

data/platform/wp7/sqlite3/SqliteWrapper/delete_c.cs

@@ -0,0 +1,726 @@
+using System;
+using System.Diagnostics;
+using System.Text;
+
+using u8 = System.Byte;
+using u32 = System.UInt32;
+
+namespace Community.CsharpSqlite
+{
+  public partial class Sqlite3
+  {
+    /*
+    ** 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 contains C code routines that are called by the parser
+    ** in order to generate code for DELETE FROM statements.
+    *************************************************************************
+    **  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: 2010-01-05 15:30:36 28d0d7710761114a44a1a3a425a6883c661f06e7
+    **
+    **  $Header$
+    *************************************************************************
+    */
+    //#include "sqliteInt.h"
+
+    /*
+    ** Look up every table that is named in pSrc.  If any table is not found,
+    ** add an error message to pParse.zErrMsg and return NULL.  If all tables
+    ** are found, return a pointer to the last table.
+    */
+    static Table sqlite3SrcListLookup( Parse pParse, SrcList pSrc )
+    {
+      SrcList_item pItem = pSrc.a[0];
+      Table pTab;
+      Debug.Assert( pItem != null && pSrc.nSrc == 1 );
+      pTab = sqlite3LocateTable( pParse, 0, pItem.zName, pItem.zDatabase );
+      sqlite3DeleteTable( ref pItem.pTab );
+      pItem.pTab = pTab;
+      if ( pTab != null )
+      {
+        pTab.nRef++;
+      }
+      if ( sqlite3IndexedByLookup( pParse, pItem ) != 0 )
+      {
+        pTab = null;
+      }
+      return pTab;
+    }
+
+    /*
+    ** Check to make sure the given table is writable.  If it is not
+    ** writable, generate an error message and return 1.  If it is
+    ** writable return 0;
+    */
+    static bool sqlite3IsReadOnly( Parse pParse, Table pTab, int viewOk )
+    {
+      /* A table is not writable under the following circumstances:
+      **
+      **   1) It is a virtual table and no implementation of the xUpdate method
+      **      has been provided, or
+      **   2) It is a system table (i.e. sqlite_master), this call is not
+      **      part of a nested parse and writable_schema pragma has not
+      **      been specified.
+      **
+      ** In either case leave an error message in pParse and return non-zero.
+      */
+      if (
+         ( IsVirtual( pTab )
+          && sqlite3GetVTable( pParse.db, pTab ).pMod.pModule.xUpdate == null )
+        || ( ( pTab.tabFlags & TF_Readonly ) != 0
+      && ( pParse.db.flags & SQLITE_WriteSchema ) == 0
+      && pParse.nested == 0 )
+      )
+      {
+        sqlite3ErrorMsg( pParse, "table %s may not be modified", pTab.zName );
+        return true;
+      }
+
+#if !SQLITE_OMIT_VIEW
+      if ( viewOk == 0 && pTab.pSelect != null )
+      {
+        sqlite3ErrorMsg( pParse, "cannot modify %s because it is a view", pTab.zName );
+        return true;
+      }
+#endif
+      return false;
+    }
+
+
+#if !SQLITE_OMIT_VIEW && !SQLITE_OMIT_TRIGGER
+    /*
+** Evaluate a view and store its result in an ephemeral table.  The
+** pWhere argument is an optional WHERE clause that restricts the
+** set of rows in the view that are to be added to the ephemeral table.
+*/
+    static void sqlite3MaterializeView(
+    Parse pParse,      /* Parsing context */
+    Table pView,       /* View definition */
+    Expr pWhere,       /* Optional WHERE clause to be added */
+    int iCur           /* VdbeCursor number for ephemerial table */
+    )
+    {
+      SelectDest dest = new SelectDest();
+      Select pDup;
+      sqlite3 db = pParse.db;
+
+      pDup = sqlite3SelectDup( db, pView.pSelect, 0 );
+      if ( pWhere != null )
+      {
+        SrcList pFrom;
+
+        pWhere = sqlite3ExprDup( db, pWhere, 0 );
+        pFrom = sqlite3SrcListAppend( db, null, null, null );
+        //if ( pFrom != null )
+        //{
+          Debug.Assert( pFrom.nSrc == 1 );
+          pFrom.a[0].zAlias = pView.zName;// sqlite3DbStrDup( db, pView.zName );
+          pFrom.a[0].pSelect = pDup;
+          Debug.Assert( pFrom.a[0].pOn == null );
+          Debug.Assert( pFrom.a[0].pUsing == null );
+        //}
+        //else
+        //{
+        //  sqlite3SelectDelete( db, ref pDup );
+        //}
+        pDup = sqlite3SelectNew( pParse, null, pFrom, pWhere, null, null, null, 0, null, null );
+      }
+      sqlite3SelectDestInit( dest, SRT_EphemTab, iCur );
+      sqlite3Select( pParse, pDup, ref dest );
+      sqlite3SelectDelete( db, ref pDup );
+    }
+#endif //* !SQLITE_OMIT_VIEW) && !SQLITE_OMIT_TRIGGER) */
+
+#if (SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !(SQLITE_OMIT_SUBQUERY)
+/*
+** Generate an expression tree to implement the WHERE, ORDER BY,
+** and LIMIT/OFFSET portion of DELETE and UPDATE statements.
+**
+**     DELETE FROM table_wxyz WHERE a<5 ORDER BY a LIMIT 1;
+**                            \__________________________/
+**                               pLimitWhere (pInClause)
+*/
+Expr sqlite3LimitWhere(
+Parse pParse,               /* The parser context */
+SrcList pSrc,               /* the FROM clause -- which tables to scan */
+Expr pWhere,                /* The WHERE clause.  May be null */
+ExprList pOrderBy,          /* The ORDER BY clause.  May be null */
+Expr pLimit,                /* The LIMIT clause.  May be null */
+Expr pOffset,               /* The OFFSET clause.  May be null */
+char zStmtType              /* Either DELETE or UPDATE.  For error messages. */
+){
+Expr pWhereRowid = null;    /* WHERE rowid .. */
+Expr pInClause = null;      /* WHERE rowid IN ( select ) */
+Expr pSelectRowid = null;   /* SELECT rowid ... */
+ExprList pEList = null;     /* Expression list contaning only pSelectRowid */
+SrcList pSelectSrc = null;  /* SELECT rowid FROM x ... (dup of pSrc) */
+Select pSelect = null;      /* Complete SELECT tree */
+
+/* Check that there isn't an ORDER BY without a LIMIT clause.
+*/
+if( pOrderBy!=null && (pLimit == null) ) {
+sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType);
+pParse.parseError = 1;
+goto limit_where_cleanup_2;
+}
+
+/* We only need to generate a select expression if there
+** is a limit/offset term to enforce.
+*/
+if ( pLimit == null )
+{
+/* if pLimit is null, pOffset will always be null as well. */
+Debug.Assert( pOffset == null );
+return pWhere;
+}
+
+/* Generate a select expression tree to enforce the limit/offset
+** term for the DELETE or UPDATE statement.  For example:
+**   DELETE FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
+** becomes:
+**   DELETE FROM table_a WHERE rowid IN (
+**     SELECT rowid FROM table_a WHERE col1=1 ORDER BY col2 LIMIT 1 OFFSET 1
+**   );
+*/
+
+pSelectRowid = sqlite3PExpr( pParse, TK_ROW, null, null, null );
+if( pSelectRowid == null ) goto limit_where_cleanup_2;
+pEList = sqlite3ExprListAppend( pParse, null, pSelectRowid);
+if( pEList == null ) goto limit_where_cleanup_2;
+
+/* duplicate the FROM clause as it is needed by both the DELETE/UPDATE tree
+** and the SELECT subtree. */
+pSelectSrc = sqlite3SrcListDup(pParse.db, pSrc,0);
+if( pSelectSrc == null ) {
+sqlite3ExprListDelete(pParse.db, pEList);
+goto limit_where_cleanup_2;
+}
+
+/* generate the SELECT expression tree. */
+pSelect = sqlite3SelectNew( pParse, pEList, pSelectSrc, pWhere, null, null,
+pOrderBy, 0, pLimit, pOffset );
+if( pSelect == null ) return null;
+
+/* now generate the new WHERE rowid IN clause for the DELETE/UDPATE */
+pWhereRowid = sqlite3PExpr( pParse, TK_ROW, null, null, null );
+if( pWhereRowid == null ) goto limit_where_cleanup_1;
+pInClause = sqlite3PExpr( pParse, TK_IN, pWhereRowid, null, null );
+if( pInClause == null ) goto limit_where_cleanup_1;
+
+pInClause->x.pSelect = pSelect;
+pInClause->flags |= EP_xIsSelect;
+sqlite3ExprSetHeight(pParse, pInClause);
+return pInClause;
+
+/* something went wrong. clean up anything allocated. */
+limit_where_cleanup_1:
+sqlite3SelectDelete(pParse.db, pSelect);
+return null;
+
+limit_where_cleanup_2:
+sqlite3ExprDelete(pParse.db, ref pWhere);
+sqlite3ExprListDelete(pParse.db, pOrderBy);
+sqlite3ExprDelete(pParse.db, ref pLimit);
+sqlite3ExprDelete(pParse.db, ref pOffset);
+return null;
+}
+#endif //* defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) */
+
+    /*
+** Generate code for a DELETE FROM statement.
+**
+**     DELETE FROM table_wxyz WHERE a<5 AND b NOT NULL;
+**                 \________/       \________________/
+**                  pTabList              pWhere
+*/
+    static void sqlite3DeleteFrom(
+    Parse pParse,          /* The parser context */
+    SrcList pTabList,      /* The table from which we should delete things */
+    Expr pWhere            /* The WHERE clause.  May be null */
+    )
+    {
+      Vdbe v;                /* The virtual database engine */
+      Table pTab;            /* The table from which records will be deleted */
+      string zDb;            /* Name of database holding pTab */
+      int end, addr = 0;     /* A couple addresses of generated code */
+      int i;                 /* Loop counter */
+      WhereInfo pWInfo;      /* Information about the WHERE clause */
+      Index pIdx;            /* For looping over indices of the table */
+      int iCur;              /* VDBE VdbeCursor number for pTab */
+      sqlite3 db;            /* Main database structure */
+      AuthContext sContext;  /* Authorization context */
+      NameContext sNC;       /* Name context to resolve expressions in */
+      int iDb;               /* Database number */
+      int memCnt = -1;        /* Memory cell used for change counting */
+      int rcauth;            /* Value returned by authorization callback */
+
+#if !SQLITE_OMIT_TRIGGER
+      bool isView;                 /* True if attempting to delete from a view */
+      Trigger pTrigger;            /* List of table triggers, if required */
+#endif
+      sContext = new AuthContext();//memset(&sContext, 0, sizeof(sContext));
+
+      db = pParse.db;
+      if ( pParse.nErr != 0 /*|| db.mallocFailed != 0 */ )
+      {
+        goto delete_from_cleanup;
+      }
+      Debug.Assert( pTabList.nSrc == 1 );
+
+      /* Locate the table which we want to delete.  This table has to be
+      ** put in an SrcList structure because some of the subroutines we
+      ** will be calling are designed to work with multiple tables and expect
+      ** an SrcList* parameter instead of just a Table* parameter.
+      */
+      pTab = sqlite3SrcListLookup( pParse, pTabList );
+      if ( pTab == null ) goto delete_from_cleanup;
+
+      /* Figure out if we have any triggers and if the table being
+      ** deleted from is a view
+      */
+#if !SQLITE_OMIT_TRIGGER
+      int iDummy = 0;
+      pTrigger = sqlite3TriggersExist( pParse, pTab, TK_DELETE, null, ref iDummy );
+      isView = pTab.pSelect != null;
+#else
+      const Trigger pTrigger = null;
+      bool isView = false;
+#endif
+#if SQLITE_OMIT_VIEW
+//# undef isView
+isView = false;
+#endif
+
+      /* If pTab is really a view, make sure it has been initialized.
+*/
+      if ( sqlite3ViewGetColumnNames( pParse, pTab ) != 0 )
+      {
+        goto delete_from_cleanup;
+      }
+
+      if ( sqlite3IsReadOnly( pParse, pTab, ( pTrigger != null ? 1 : 0 ) ) )
+      {
+        goto delete_from_cleanup;
+      }
+      iDb = sqlite3SchemaToIndex( db, pTab.pSchema );
+      Debug.Assert( iDb < db.nDb );
+      zDb = db.aDb[iDb].zName;
+#if !SQLITE_OMIT_AUTHORIZATION
+rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb);
+#else
+      rcauth = SQLITE_OK;
+#endif
+      Debug.Assert( rcauth == SQLITE_OK || rcauth == SQLITE_DENY || rcauth == SQLITE_IGNORE );
+      if ( rcauth == SQLITE_DENY )
+      {
+        goto delete_from_cleanup;
+      }
+      Debug.Assert( !isView || pTrigger != null );
+
+      /* Assign  cursor number to the table and all its indices.
+      */
+      Debug.Assert( pTabList.nSrc == 1 );
+      iCur = pTabList.a[0].iCursor = pParse.nTab++;
+      for ( pIdx = pTab.pIndex; pIdx != null; pIdx = pIdx.pNext )
+      {
+        pParse.nTab++;
+      }
+
+#if !SQLITE_OMIT_AUTHORIZATION
+/* Start the view context
+*/
+if( isView ){
+sqlite3AuthContextPush(pParse, sContext, pTab.zName);
+}
+#endif
+      /* Begin generating code.
+*/
+      v = sqlite3GetVdbe( pParse );
+      if ( v == null )
+      {
+        goto delete_from_cleanup;
+      }
+      if ( pParse.nested == 0 ) sqlite3VdbeCountChanges( v );
+      sqlite3BeginWriteOperation( pParse, 1, iDb );
+
+      /* If we are trying to delete from a view, realize that view into
+      ** a ephemeral table.
+      */
+#if !(SQLITE_OMIT_VIEW) && !(SQLITE_OMIT_TRIGGER)
+      if ( isView )
+      {
+        sqlite3MaterializeView( pParse, pTab, pWhere, iCur );
+      }
+#endif
+      /* Resolve the column names in the WHERE clause.
+      */
+      sNC = new NameContext();// memset( &sNC, 0, sizeof( sNC ) );
+      sNC.pParse = pParse;
+      sNC.pSrcList = pTabList;
+      if ( sqlite3ResolveExprNames( sNC, ref pWhere ) != 0 )
+      {
+        goto delete_from_cleanup;
+      }
+
+
+      /* Initialize the counter of the number of rows deleted, if
+** we are counting rows.
+*/
+      if ( ( db.flags & SQLITE_CountRows ) != 0 )
+      {
+        memCnt = ++pParse.nMem;
+        sqlite3VdbeAddOp2( v, OP_Integer, 0, memCnt );
+      }
+
+#if !SQLITE_OMIT_TRUNCATE_OPTIMIZATION
+      /* Special case: A DELETE without a WHERE clause deletes everything.
+  ** It is easier just to erase the whole table. Prior to version 3.6.5,
+  ** this optimization caused the row change count (the value returned by 
+  ** API function sqlite3_count_changes) to be set incorrectly.  */
+      if ( rcauth == SQLITE_OK && pWhere == null && null == pTrigger && !IsVirtual( pTab )
+        && 0 == sqlite3FkRequired( pParse, pTab, null, 0 )
+        )
+      {
+        Debug.Assert( !isView );
+        sqlite3VdbeAddOp4( v, OP_Clear, pTab.tnum, iDb, memCnt,
+              pTab.zName, P4_STATIC );
+        for ( pIdx = pTab.pIndex; pIdx != null; pIdx = pIdx.pNext )
+        {
+          Debug.Assert( pIdx.pSchema == pTab.pSchema );
+          sqlite3VdbeAddOp2( v, OP_Clear, pIdx.tnum, iDb );
+        }
+      }
+      else
+#endif //* SQLITE_OMIT_TRUNCATE_OPTIMIZATION */
+      /* The usual case: There is a WHERE clause so we have to scan through
+** the table and pick which records to delete.
+*/
+      {
+        int iRowSet = ++pParse.nMem;    /* Register for rowset of rows to delete */
+        int iRowid = ++pParse.nMem;     /* Used for storing rowid values. */
+        int regRowid;                   /* Actual register containing rowids */
+
+        /* Collect rowids of every row to be deleted.
+        */
+        sqlite3VdbeAddOp2( v, OP_Null, 0, iRowSet );
+        ExprList elDummy = null;
+        pWInfo = sqlite3WhereBegin( pParse, pTabList, pWhere, ref elDummy, WHERE_DUPLICATES_OK );
+        if ( pWInfo == null ) goto delete_from_cleanup;
+        regRowid = sqlite3ExprCodeGetColumn( pParse, pTab, -1, iCur, iRowid );
+        sqlite3VdbeAddOp2( v, OP_RowSetAdd, iRowSet, regRowid );
+        if ( ( db.flags & SQLITE_CountRows ) != 0 )
+        {
+          sqlite3VdbeAddOp2( v, OP_AddImm, memCnt, 1 );
+        }
+
+        sqlite3WhereEnd( pWInfo );
+
+        /* Delete every item whose key was written to the list during the
+        ** database scan.  We have to delete items after the scan is complete
+        ** because deleting an item can change the scan order. */
+        end = sqlite3VdbeMakeLabel( v );
+
+        /* Unless this is a view, open cursors for the table we are 
+        ** deleting from and all its indices. If this is a view, then the
+        ** only effect this statement has is to fire the INSTEAD OF 
+        ** triggers.  */
+        if ( !isView )
+        {
+          sqlite3OpenTableAndIndices( pParse, pTab, iCur, OP_OpenWrite );
+        }
+
+        addr = sqlite3VdbeAddOp3( v, OP_RowSetRead, iRowSet, end, iRowid );
+
+        /* Delete the row */
+#if !SQLITE_OMIT_VIRTUALTABLE
+if( IsVirtual(pTab) ){
+const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
+sqlite3VtabMakeWritable(pParse, pTab);
+sqlite3VdbeAddOp4(v, OP_VUpdate, 0, 1, iRowid, pVTab, P4_VTAB);
+sqlite3MayAbort(pParse);
+}else
+#endif
+        {
+          int count = ( pParse.nested == 0 ) ? 1 : 0;    /* True to count changes */
+          sqlite3GenerateRowDelete( pParse, pTab, iCur, iRowid, count, pTrigger, OE_Default );
+        }
+
+        /* End of the delete loop */
+        sqlite3VdbeAddOp2( v, OP_Goto, 0, addr );
+        sqlite3VdbeResolveLabel( v, end );
+
+        /* Close the cursors open on the table and its indexes. */
+        if ( !isView && !IsVirtual( pTab ) )
+        {
+          for ( i = 1, pIdx = pTab.pIndex; pIdx != null; i++, pIdx = pIdx.pNext )
+          {
+            sqlite3VdbeAddOp2( v, OP_Close, iCur + i, pIdx.tnum );
+          }
+          sqlite3VdbeAddOp1( v, OP_Close, iCur );
+        }
+      }
+
+      /* Update the sqlite_sequence table by storing the content of the
+      ** maximum rowid counter values recorded while inserting into
+      ** autoincrement tables.
+      */
+      if ( pParse.nested == 0 && pParse.pTriggerTab == null )
+      {
+        sqlite3AutoincrementEnd( pParse );
+      }
+
+      /* Return the number of rows that were deleted. If this routine is 
+      ** generating code because of a call to sqlite3NestedParse(), do not
+      ** invoke the callback function.
+      */
+
+      if ( ( db.flags & SQLITE_CountRows ) != 0 && 0 == pParse.nested && null == pParse.pTriggerTab )
+      {
+        sqlite3VdbeAddOp2( v, OP_ResultRow, memCnt, 1 );
+        sqlite3VdbeSetNumCols( v, 1 );
+        sqlite3VdbeSetColName( v, 0, COLNAME_NAME, "rows deleted", SQLITE_STATIC );
+      }
+
+    delete_from_cleanup:
+#if !SQLITE_OMIT_AUTHORIZATION
+sqlite3AuthContextPop(sContext);
+#endif
+      sqlite3SrcListDelete( db, ref pTabList );
+      sqlite3ExprDelete( db, ref pWhere );
+      return;
+    }
+
+    /* Make sure "isView" and other macros defined above are undefined. Otherwise
+    ** thely may interfere with compilation of other functions in this file
+    ** (or in another file, if this file becomes part of the amalgamation).  */
+    //#ifdef isView
+    // #undef isView
+    //#endif
+    //#ifdef pTrigger
+    // #undef pTrigger
+    //#endif
+
+    /*
+    ** This routine generates VDBE code that causes a single row of a
+    ** single table to be deleted.
+    **
+    ** The VDBE must be in a particular state when this routine is called.
+    ** These are the requirements:
+    **
+    **   1.  A read/write cursor pointing to pTab, the table containing the row
+    **       to be deleted, must be opened as cursor number $iCur.
+    **
+    **   2.  Read/write cursors for all indices of pTab must be open as
+    **       cursor number base+i for the i-th index.
+    **
+    **   3.  The record number of the row to be deleted must be stored in
+    **       memory cell iRowid.
+    **
+    ** This routine generates code to remove both the table record and all 
+    ** index entries that point to that record.
+    */
+    static void sqlite3GenerateRowDelete(
+    Parse pParse,      /* Parsing context */
+    Table pTab,        /* Table containing the row to be deleted */
+    int iCur,          /* VdbeCursor number for the table */
+    int iRowid,        /* Memory cell that contains the rowid to delete */
+    int count,         /* If non-zero, increment the row change counter */
+    Trigger pTrigger,  /* List of triggers to (potentially) fire */
+    int onconf         /* Default ON CONFLICT policy for triggers */
+)
+    {
+      Vdbe v = pParse.pVdbe;          /* Vdbe */
+      int iOld = 0;                   /* First register in OLD.* array */
+      int iLabel;                     /* Label resolved to end of generated code */
+
+      /* Vdbe is guaranteed to have been allocated by this stage. */
+      Debug.Assert( v != null );
+
+      /* Seek cursor iCur to the row to delete. If this row no longer exists 
+      ** (this can happen if a trigger program has already deleted it), do
+      ** not attempt to delete it or fire any DELETE triggers.  */
+      iLabel = sqlite3VdbeMakeLabel( v );
+      sqlite3VdbeAddOp3( v, OP_NotExists, iCur, iLabel, iRowid );
+
+      /* If there are any triggers to fire, allocate a range of registers to
+      ** use for the old.* references in the triggers.  */
+      if ( sqlite3FkRequired( pParse, pTab, null, 0 ) != 0 || pTrigger != null )
+      {
+        u32 mask;                     /* Mask of OLD.* columns in use */
+        int iCol;                     /* Iterator used while populating OLD.* */
+
+        /* TODO: Could use temporary registers here. Also could attempt to
+        ** avoid copying the contents of the rowid register.  */
+        mask = sqlite3TriggerColmask(
+            pParse, pTrigger, null, 0, TRIGGER_BEFORE | TRIGGER_AFTER, pTab, onconf
+        );
+        mask |= sqlite3FkOldmask( pParse, pTab );
+        iOld = pParse.nMem + 1;
+        pParse.nMem += ( 1 + pTab.nCol );
+
+        /* Populate the OLD.* pseudo-table register array. These values will be 
+        ** used by any BEFORE and AFTER triggers that exist.  */
+        sqlite3VdbeAddOp2( v, OP_Copy, iRowid, iOld );
+        for ( iCol = 0; iCol < pTab.nCol; iCol++ )
+        {
+          if ( mask == 0xffffffff || ( mask & ( 1 << iCol ) ) != 0 )
+          {
+            int iTarget = iOld + iCol + 1;
+            sqlite3VdbeAddOp3( v, OP_Column, iCur, iCol, iTarget );
+            sqlite3ColumnDefault( v, pTab, iCol, iTarget );
+          }
+        }
+
+        /* Invoke BEFORE DELETE trigger programs. */
+        sqlite3CodeRowTrigger( pParse, pTrigger,
+            TK_DELETE, null, TRIGGER_BEFORE, pTab, iOld, onconf, iLabel
+        );
+
+        /* Seek the cursor to the row to be deleted again. It may be that
+        ** the BEFORE triggers coded above have already removed the row
+        ** being deleted. Do not attempt to delete the row a second time, and 
+        ** do not fire AFTER triggers.  */
+        sqlite3VdbeAddOp3( v, OP_NotExists, iCur, iLabel, iRowid );
+
+        /* Do FK processing. This call checks that any FK constraints that
+        ** refer to this table (i.e. constraints attached to other tables) 
+        ** are not violated by deleting this row.  */
+        sqlite3FkCheck( pParse, pTab, iOld, 0 );
+      }
+
+      /* Delete the index and table entries. Skip this step if pTab is really
+      ** a view (in which case the only effect of the DELETE statement is to
+      ** fire the INSTEAD OF triggers).  */
+      if ( pTab.pSelect == null )
+      {
+        sqlite3GenerateRowIndexDelete( pParse, pTab, iCur, 0 );
+        sqlite3VdbeAddOp2( v, OP_Delete, iCur, ( count != 0 ? (int)OPFLAG_NCHANGE : 0 ) );
+        if ( count != 0 )
+        {
+          sqlite3VdbeChangeP4( v, -1, pTab.zName, P4_STATIC );
+        }
+      }
+
+      /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
+      ** handle rows (possibly in other tables) that refer via a foreign key
+      ** to the row just deleted. */
+      sqlite3FkActions( pParse, pTab, null, iOld );
+
+      /* Invoke AFTER DELETE trigger programs. */
+      sqlite3CodeRowTrigger( pParse, pTrigger,
+          TK_DELETE, null, TRIGGER_AFTER, pTab, iOld, onconf, iLabel
+      );
+
+      /* Jump here if the row had already been deleted before any BEFORE
+      ** trigger programs were invoked. Or if a trigger program throws a 
+      ** RAISE(IGNORE) exception.  */
+      sqlite3VdbeResolveLabel( v, iLabel );
+    }
+
+
+    /*
+    ** This routine generates VDBE code that causes the deletion of all
+    ** index entries associated with a single row of a single table.
+    **
+    ** The VDBE must be in a particular state when this routine is called.
+    ** These are the requirements:
+    **
+    **   1.  A read/write cursor pointing to pTab, the table containing the row
+    **       to be deleted, must be opened as cursor number "iCur".
+    **
+    **   2.  Read/write cursors for all indices of pTab must be open as
+    **       cursor number iCur+i for the i-th index.
+    **
+    **   3.  The "iCur" cursor must be pointing to the row that is to be
+    **       deleted.
+    */
+    static void sqlite3GenerateRowIndexDelete(
+    Parse pParse,     /* Parsing and code generating context */
+    Table pTab,       /* Table containing the row to be deleted */
+    int iCur,         /* VdbeCursor number for the table */
+    int nothing       /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */
+    )
+    {
+      int[] aRegIdx = null;
+      sqlite3GenerateRowIndexDelete( pParse, pTab, iCur, aRegIdx );
+    }
+    static void sqlite3GenerateRowIndexDelete(
+    Parse pParse,     /* Parsing and code generating context */
+    Table pTab,       /* Table containing the row to be deleted */
+    int iCur,          /* VdbeCursor number for the table */
+    int[] aRegIdx       /* Only delete if aRegIdx!=0 && aRegIdx[i]>0 */
+    )
+    {
+      int i;
+      Index pIdx;
+      int r1;
+
+      for ( i = 1, pIdx = pTab.pIndex; pIdx != null; i++, pIdx = pIdx.pNext )
+      {
+        if ( aRegIdx != null && aRegIdx[i - 1] == 0 ) continue;
+        r1 = sqlite3GenerateIndexKey( pParse, pIdx, iCur, 0, false );
+        sqlite3VdbeAddOp3( pParse.pVdbe, OP_IdxDelete, iCur + i, r1, pIdx.nColumn + 1 );
+      }
+    }
+
+    /*
+    ** Generate code that will assemble an index key and put it in register
+    ** regOut.  The key with be for index pIdx which is an index on pTab.
+    ** iCur is the index of a cursor open on the pTab table and pointing to
+    ** the entry that needs indexing.
+    **
+    ** Return a register number which is the first in a block of
+    ** registers that holds the elements of the index key.  The
+    ** block of registers has already been deallocated by the time
+    ** this routine returns.
+    */
+    static int sqlite3GenerateIndexKey(
+    Parse pParse,     /* Parsing context */
+    Index pIdx,       /* The index for which to generate a key */
+    int iCur,         /* VdbeCursor number for the pIdx.pTable table */
+    int regOut,       /* Write the new index key to this register */
+    bool doMakeRec    /* Run the OP_MakeRecord instruction if true */
+    )
+    {
+      Vdbe v = pParse.pVdbe;
+      int j;
+      Table pTab = pIdx.pTable;
+      int regBase;
+      int nCol;
+
+      nCol = pIdx.nColumn;
+      regBase = sqlite3GetTempRange( pParse, nCol + 1 );
+      sqlite3VdbeAddOp2( v, OP_Rowid, iCur, regBase + nCol );
+      for ( j = 0; j < nCol; j++ )
+      {
+        int idx = pIdx.aiColumn[j];
+        if ( idx == pTab.iPKey )
+        {
+          sqlite3VdbeAddOp2( v, OP_SCopy, regBase + nCol, regBase + j );
+        }
+        else
+        {
+          sqlite3VdbeAddOp3( v, OP_Column, iCur, idx, regBase + j );
+          sqlite3ColumnDefault( v, pTab, idx, -1 );
+        }
+      }
+      if ( doMakeRec )
+      {
+        sqlite3VdbeAddOp3( v, OP_MakeRecord, regBase, nCol + 1, regOut );
+        sqlite3VdbeChangeP4( v, -1, sqlite3IndexAffinityStr( v, pIdx ), 0 );
+      }
+      sqlite3ReleaseTempRange( pParse, regBase, nCol + 1 );
+      return regBase;
+    }
+  }
+}