using System;
using System.Diagnostics;
using u32 = System.UInt32;
using u8 = System.Byte;

namespace Community.CsharpSqlite
{
	public partial class Sqlite3
	{
		/*
		**
		** 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 the implementation for TRIGGERs
		*************************************************************************
		**  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
		**
		*************************************************************************
		*/
		//#include "sqliteInt.h"

#if !SQLITE_OMIT_TRIGGER
		/*
** Delete a linked list of TriggerStep structures.
*/

		private static void sqlite3DeleteTriggerStep(sqlite3 db, ref TriggerStep pTriggerStep)
		{
			while (pTriggerStep != null)
			{
				TriggerStep pTmp = pTriggerStep;
				pTriggerStep = pTriggerStep.pNext;

				sqlite3ExprDelete(db, ref pTmp.pWhere);
				sqlite3ExprListDelete(db, ref pTmp.pExprList);
				sqlite3SelectDelete(db, ref pTmp.pSelect);
				sqlite3IdListDelete(db, ref pTmp.pIdList);

				pTriggerStep = null;
				sqlite3DbFree(db, ref pTmp);
			}
		}

		/*
		** Given table pTab, return a list of all the triggers attached to
		** the table. The list is connected by Trigger.pNext pointers.
		**
		** All of the triggers on pTab that are in the same database as pTab
		** are already attached to pTab.pTrigger.  But there might be additional
		** triggers on pTab in the TEMP schema.  This routine prepends all
		** TEMP triggers on pTab to the beginning of the pTab.pTrigger list
		** and returns the combined list.
		**
		** To state it another way:  This routine returns a list of all triggers
		** that fire off of pTab.  The list will include any TEMP triggers on
		** pTab as well as the triggers lised in pTab.pTrigger.
		*/

		private static Trigger sqlite3TriggerList(Parse pParse, Table pTab)
		{
			Schema pTmpSchema = pParse.db.aDb[1].pSchema;
			Trigger pList = null;                  /* List of triggers to return */

			if (pParse.disableTriggers != 0)
			{
				return null;
			}

			if (pTmpSchema != pTab.pSchema)
			{
				HashElem p;
				Debug.Assert(sqlite3SchemaMutexHeld(pParse.db, 0, pTmpSchema));
				for (p = sqliteHashFirst(pTmpSchema.trigHash); p != null; p = sqliteHashNext(p))
				{
					Trigger pTrig = (Trigger)sqliteHashData(p);
					if (pTrig.pTabSchema == pTab.pSchema
					&& pTrig.table.Equals(pTab.zName, StringComparison.OrdinalIgnoreCase))
					{
						pTrig.pNext = (pList != null ? pList : pTab.pTrigger);
						pList = pTrig;
					}
				}
			}

			return (pList != null ? pList : pTab.pTrigger);
		}

		/*
		** This is called by the parser when it sees a CREATE TRIGGER statement
		** up to the point of the BEGIN before the trigger actions.  A Trigger
		** structure is generated based on the information available and stored
		** in pParse.pNewTrigger.  After the trigger actions have been parsed, the
		** sqlite3FinishTrigger() function is called to complete the trigger
		** construction process.
		*/

		private static void sqlite3BeginTrigger(
		Parse pParse,      /* The parse context of the CREATE TRIGGER statement */
		Token pName1,      /* The name of the trigger */
		Token pName2,      /* The name of the trigger */
		int tr_tm,         /* One of TK_BEFORE, TK_AFTER, TK_INSTEAD */
		int op,             /* One of TK_INSERT, TK_UPDATE, TK_DELETE */
		IdList pColumns,   /* column list if this is an UPDATE OF trigger */
		SrcList pTableName,/* The name of the table/view the trigger applies to */
		Expr pWhen,        /* WHEN clause */
		int isTemp,        /* True if the TEMPORARY keyword is present */
		int noErr          /* Suppress errors if the trigger already exists */
		)
		{
			Trigger pTrigger = null;      /* The new trigger */
			Table pTab;                   /* Table that the trigger fires off of */
			string zName = null;          /* Name of the trigger */
			sqlite3 db = pParse.db;       /* The database connection */
			int iDb;                      /* The database to store the trigger in */
			Token pName = null;           /* The unqualified db name */
			DbFixer sFix = new DbFixer(); /* State vector for the DB fixer */
			int iTabDb;                   /* Index of the database holding pTab */

			Debug.Assert(pName1 != null);   /* pName1.z might be NULL, but not pName1 itself */
			Debug.Assert(pName2 != null);
			Debug.Assert(op == TK_INSERT || op == TK_UPDATE || op == TK_DELETE);
			Debug.Assert(op > 0 && op < 0xff);
			if (isTemp != 0)
			{
				/* If TEMP was specified, then the trigger name may not be qualified. */
				if (pName2.n > 0)
				{
					sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name");
					goto trigger_cleanup;
				}
				iDb = 1;
				pName = pName1;
			}
			else
			{
				/* Figure out the db that the the trigger will be created in */
				iDb = sqlite3TwoPartName(pParse, pName1, pName2, ref pName);
				if (iDb < 0)
				{
					goto trigger_cleanup;
				}
			}
			if (null == pTableName) //|| db.mallocFailed
			{
				goto trigger_cleanup;
			}

			/* A long-standing parser bug is that this syntax was allowed:
			**
			**    CREATE TRIGGER attached.demo AFTER INSERT ON attached.tab ....
			**                                                 ^^^^^^^^
			**
			** To maintain backwards compatibility, ignore the database
			** name on pTableName if we are reparsing our of SQLITE_MASTER.
			*/
			if (db.init.busy != 0 && iDb != 1)
			{
				//sqlite3DbFree( db, pTableName.a[0].zDatabase );
				pTableName.a[0].zDatabase = null;
			}

			/* If the trigger name was unqualified, and the table is a temp table,
			** then set iDb to 1 to create the trigger in the temporary database.
			** If sqlite3SrcListLookup() returns 0, indicating the table does not
			** exist, the error is caught by the block below.
			*/
			if (pTableName == null /*|| db.mallocFailed != 0 */ )
			{
				goto trigger_cleanup;
			}
			pTab = sqlite3SrcListLookup(pParse, pTableName);
			if (db.init.busy == 0 && pName2.n == 0 && pTab != null
				  && pTab.pSchema == db.aDb[1].pSchema)
			{
				iDb = 1;
			}

			/* Ensure the table name matches database name and that the table exists */
			//      if ( db.mallocFailed != 0 ) goto trigger_cleanup;
			Debug.Assert(pTableName.nSrc == 1);
			if (sqlite3FixInit(sFix, pParse, iDb, "trigger", pName) != 0 &&
			sqlite3FixSrcList(sFix, pTableName) != 0)
			{
				goto trigger_cleanup;
			}
			pTab = sqlite3SrcListLookup(pParse, pTableName);
			if (pTab == null)
			{
				/* The table does not exist. */
				if (db.init.iDb == 1)
				{
					/* Ticket #3810.
					** Normally, whenever a table is dropped, all associated triggers are
					** dropped too.  But if a TEMP trigger is created on a non-TEMP table
					** and the table is dropped by a different database connection, the
					** trigger is not visible to the database connection that does the
					** drop so the trigger cannot be dropped.  This results in an
					** "orphaned trigger" - a trigger whose associated table is missing.
					*/
					db.init.orphanTrigger = 1;
				}
				goto trigger_cleanup;
			}
			if (IsVirtual(pTab))
			{
				sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables");
				goto trigger_cleanup;
			}

			/* Check that the trigger name is not reserved and that no trigger of the
			** specified name exists */
			zName = sqlite3NameFromToken(db, pName);
			if (zName == null || SQLITE_OK != sqlite3CheckObjectName(pParse, zName))
			{
				goto trigger_cleanup;
			}
			Debug.Assert(sqlite3SchemaMutexHeld(db, iDb, null));
			if (sqlite3HashFind((db.aDb[iDb].pSchema.trigHash),
			zName, sqlite3Strlen30(zName), (Trigger)null) != null)
			{
				if (noErr == 0)
				{
					sqlite3ErrorMsg(pParse, "trigger %T already exists", pName);
				}
				else
				{
					Debug.Assert(0 == db.init.busy);
					sqlite3CodeVerifySchema(pParse, iDb);
				}
				goto trigger_cleanup;
			}

			/* Do not create a trigger on a system table */
			if (pTab.zName.StartsWith("sqlite_", System.StringComparison.OrdinalIgnoreCase))
			{
				sqlite3ErrorMsg(pParse, "cannot create trigger on system table");
				pParse.nErr++;
				goto trigger_cleanup;
			}

			/* INSTEAD of triggers are only for views and views only support INSTEAD
			** of triggers.
			*/
			if (pTab.pSelect != null && tr_tm != TK_INSTEAD)
			{
				sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S",
				(tr_tm == TK_BEFORE) ? "BEFORE" : "AFTER", pTableName, 0);
				goto trigger_cleanup;
			}
			if (pTab.pSelect == null && tr_tm == TK_INSTEAD)
			{
				sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF" +
				" trigger on table: %S", pTableName, 0);
				goto trigger_cleanup;
			}
			iTabDb = sqlite3SchemaToIndex(db, pTab.pSchema);

#if !SQLITE_OMIT_AUTHORIZATION
{
int code = SQLITE_CREATE_TRIGGER;
string zDb = db.aDb[iTabDb].zName;
string zDbTrig = isTemp ? db.aDb[1].zName : zDb;
if( iTabDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER;
if( sqlite3AuthCheck(pParse, code, zName, pTab.zName, zDbTrig) ){
goto trigger_cleanup;
}
if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){
goto trigger_cleanup;
}
}
#endif

			/* INSTEAD OF triggers can only appear on views and BEFORE triggers
** cannot appear on views.  So we might as well translate every
** INSTEAD OF trigger into a BEFORE trigger.  It simplifies code
** elsewhere.
*/
			if (tr_tm == TK_INSTEAD)
			{
				tr_tm = TK_BEFORE;
			}

			/* Build the Trigger object */
			pTrigger = new Trigger();// (Trigger*)sqlite3DbMallocZero( db, sizeof(Trigger ))
			if (pTrigger == null)
				goto trigger_cleanup;
			pTrigger.zName = zName;
			pTrigger.table = pTableName.a[0].zName;// sqlite3DbStrDup( db, pTableName.a[0].zName );
			pTrigger.pSchema = db.aDb[iDb].pSchema;
			pTrigger.pTabSchema = pTab.pSchema;
			pTrigger.op = (u8)op;
			pTrigger.tr_tm = tr_tm == TK_BEFORE ? TRIGGER_BEFORE : TRIGGER_AFTER;
			pTrigger.pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
			pTrigger.pColumns = sqlite3IdListDup(db, pColumns);
			Debug.Assert(pParse.pNewTrigger == null);
			pParse.pNewTrigger = pTrigger;

		trigger_cleanup:
			sqlite3DbFree(db, ref zName);
			sqlite3SrcListDelete(db, ref pTableName);
			sqlite3IdListDelete(db, ref pColumns);
			sqlite3ExprDelete(db, ref pWhen);
			if (pParse.pNewTrigger == null)
			{
				sqlite3DeleteTrigger(db, ref pTrigger);
			}
			else
			{
				Debug.Assert(pParse.pNewTrigger == pTrigger);
			}
		}

		/*
		** This routine is called after all of the trigger actions have been parsed
		** in order to complete the process of building the trigger.
		*/

		private static void sqlite3FinishTrigger(
		Parse pParse,          /* Parser context */
		TriggerStep pStepList, /* The triggered program */
		Token pAll             /* Token that describes the complete CREATE TRIGGER */
		)
		{
			Trigger pTrig = pParse.pNewTrigger; /* Trigger being finished */
			string zName;                       /* Name of trigger */

			sqlite3 db = pParse.db;             /* The database */
			DbFixer sFix = new DbFixer();       /* Fixer object */
			int iDb;                            /* Database containing the trigger */
			Token nameToken = new Token();      /* Trigger name for error reporting */

			pParse.pNewTrigger = null;
			if (NEVER(pParse.nErr != 0) || pTrig == null)
				goto triggerfinish_cleanup;
			zName = pTrig.zName;
			iDb = sqlite3SchemaToIndex(pParse.db, pTrig.pSchema);
			pTrig.step_list = pStepList;
			while (pStepList != null)
			{
				pStepList.pTrig = pTrig;
				pStepList = pStepList.pNext;
			}
			nameToken.z = pTrig.zName;
			nameToken.n = sqlite3Strlen30(nameToken.z);
			if (sqlite3FixInit(sFix, pParse, iDb, "trigger", nameToken) != 0
			&& sqlite3FixTriggerStep(sFix, pTrig.step_list) != 0)
			{
				goto triggerfinish_cleanup;
			}

			/* if we are not initializing,
			** build the sqlite_master entry
			*/
			if (0 == db.init.busy)
			{
				Vdbe v;
				string z;

				/* Make an entry in the sqlite_master table */
				v = sqlite3GetVdbe(pParse);
				if (v == null)
					goto triggerfinish_cleanup;
				sqlite3BeginWriteOperation(pParse, 0, iDb);
				z = pAll.z.Substring(0, pAll.n);//sqlite3DbStrNDup( db, (char*)pAll.z, pAll.n );
				sqlite3NestedParse(pParse,
				"INSERT INTO %Q.%s VALUES('trigger',%Q,%Q,0,'CREATE TRIGGER %q')",
				db.aDb[iDb].zName, SCHEMA_TABLE(iDb), zName,
				pTrig.table, z);
				sqlite3DbFree(db, ref z);
				sqlite3ChangeCookie(pParse, iDb);
				sqlite3VdbeAddParseSchemaOp(v, iDb,
					sqlite3MPrintf(db, "type='trigger' AND name='%q'", zName));
			}

			if (db.init.busy != 0)
			{
				Trigger pLink = pTrig;
				Hash pHash = db.aDb[iDb].pSchema.trigHash;
				Debug.Assert(sqlite3SchemaMutexHeld(db, iDb, null));
				pTrig = sqlite3HashInsert(ref pHash, zName, sqlite3Strlen30(zName), pTrig);
				if (pTrig != null)
				{
					//db.mallocFailed = 1;
				}
				else if (pLink.pSchema == pLink.pTabSchema)
				{
					Table pTab;
					int n = sqlite3Strlen30(pLink.table);
					pTab = sqlite3HashFind(pLink.pTabSchema.tblHash, pLink.table, n, (Table)null);
					Debug.Assert(pTab != null);
					pLink.pNext = pTab.pTrigger;
					pTab.pTrigger = pLink;
				}
			}

		triggerfinish_cleanup:
			sqlite3DeleteTrigger(db, ref pTrig);
			Debug.Assert(pParse.pNewTrigger == null);
			sqlite3DeleteTriggerStep(db, ref pStepList);
		}

		/*
		** Turn a SELECT statement (that the pSelect parameter points to) into
		** a trigger step.  Return a pointer to a TriggerStep structure.
		**
		** The parser calls this routine when it finds a SELECT statement in
		** body of a TRIGGER.
		*/

		private static TriggerStep sqlite3TriggerSelectStep(sqlite3 db, Select pSelect)
		{
			TriggerStep pTriggerStep = new TriggerStep();// sqlite3DbMallocZero( db, sizeof(TriggerStep ))
			if (pTriggerStep == null)
			{
				sqlite3SelectDelete(db, ref pSelect);
				return null;
			}

			pTriggerStep.op = TK_SELECT;
			pTriggerStep.pSelect = pSelect;
			pTriggerStep.orconf = OE_Default;
			return pTriggerStep;
		}

		/*
		** Allocate space to hold a new trigger step.  The allocated space
		** holds both the TriggerStep object and the TriggerStep.target.z string.
		**
		** If an OOM error occurs, NULL is returned and db.mallocFailed is set.
		*/

		private static TriggerStep triggerStepAllocate(
		sqlite3 db,                /* Database connection */
		u8 op,                     /* Trigger opcode */
		Token pName                /* The target name */
		)
		{
			TriggerStep pTriggerStep;

			pTriggerStep = new TriggerStep();// sqlite3DbMallocZero( db, sizeof( TriggerStep ) + pName.n );
			//if ( pTriggerStep != null )
			//{
			string z;// = (char*)&pTriggerStep[1];
			z = pName.z;// memcpy( z, pName.z, pName.n );
			pTriggerStep.target.z = z;
			pTriggerStep.target.n = pName.n;
			pTriggerStep.op = op;
			//}
			return pTriggerStep;
		}

		/*
		** Build a trigger step out of an INSERT statement.  Return a pointer
		** to the new trigger step.
		**
		** The parser calls this routine when it sees an INSERT inside the
		** body of a trigger.
		*/

		// OVERLOADS, so I don't need to rewrite parse.c
		private static TriggerStep sqlite3TriggerInsertStep(sqlite3 db, Token pTableName, IdList pColumn, int null_4, int null_5, u8 orconf)
		{
			return sqlite3TriggerInsertStep(db, pTableName, pColumn, null, null, orconf);
		}

		private static TriggerStep sqlite3TriggerInsertStep(sqlite3 db, Token pTableName, IdList pColumn, ExprList pEList, int null_5, u8 orconf)
		{
			return sqlite3TriggerInsertStep(db, pTableName, pColumn, pEList, null, orconf);
		}

		private static TriggerStep sqlite3TriggerInsertStep(sqlite3 db, Token pTableName, IdList pColumn, int null_4, Select pSelect, u8 orconf)
		{
			return sqlite3TriggerInsertStep(db, pTableName, pColumn, null, pSelect, orconf);
		}

		private static TriggerStep sqlite3TriggerInsertStep(
		sqlite3 db,        /* The database connection */
		Token pTableName,  /* Name of the table into which we insert */
		IdList pColumn,    /* List of columns in pTableName to insert into */
		ExprList pEList,   /* The VALUE clause: a list of values to be inserted */
		Select pSelect,    /* A SELECT statement that supplies values */
		u8 orconf          /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */
		)
		{
			TriggerStep pTriggerStep;

			Debug.Assert(pEList == null || pSelect == null);
			Debug.Assert(pEList != null || pSelect != null /*|| db.mallocFailed != 0 */ );

			pTriggerStep = triggerStepAllocate(db, TK_INSERT, pTableName);
			//if ( pTriggerStep != null )
			//{
			pTriggerStep.pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
			pTriggerStep.pIdList = pColumn;
			pTriggerStep.pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);
			pTriggerStep.orconf = orconf;
			//}
			//else
			//{
			//  sqlite3IdListDelete( db, ref pColumn );
			//}
			sqlite3ExprListDelete(db, ref pEList);
			sqlite3SelectDelete(db, ref pSelect);

			return pTriggerStep;
		}

		/*
		** Construct a trigger step that implements an UPDATE statement and return
		** a pointer to that trigger step.  The parser calls this routine when it
		** sees an UPDATE statement inside the body of a CREATE TRIGGER.
		*/

		private static TriggerStep sqlite3TriggerUpdateStep(
		sqlite3 db,         /* The database connection */
		Token pTableName,   /* Name of the table to be updated */
		ExprList pEList,    /* The SET clause: list of column and new values */
		Expr pWhere,        /* The WHERE clause */
		u8 orconf           /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */
		)
		{
			TriggerStep pTriggerStep;

			pTriggerStep = triggerStepAllocate(db, TK_UPDATE, pTableName);
			//if ( pTriggerStep != null )
			//{
			pTriggerStep.pExprList = sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE);
			pTriggerStep.pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
			pTriggerStep.orconf = orconf;
			//}
			sqlite3ExprListDelete(db, ref pEList);
			sqlite3ExprDelete(db, ref pWhere);
			return pTriggerStep;
		}

		/*
		** Construct a trigger step that implements a DELETE statement and return
		** a pointer to that trigger step.  The parser calls this routine when it
		** sees a DELETE statement inside the body of a CREATE TRIGGER.
		*/

		private static TriggerStep sqlite3TriggerDeleteStep(
		sqlite3 db,            /* Database connection */
		Token pTableName,      /* The table from which rows are deleted */
		Expr pWhere            /* The WHERE clause */
		)
		{
			TriggerStep pTriggerStep;

			pTriggerStep = triggerStepAllocate(db, TK_DELETE, pTableName);
			//if ( pTriggerStep != null )
			//{
			pTriggerStep.pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE);
			pTriggerStep.orconf = OE_Default;
			//}
			sqlite3ExprDelete(db, ref pWhere);
			return pTriggerStep;
		}

		/*
		** Recursively delete a Trigger structure
		*/

		private static void sqlite3DeleteTrigger(sqlite3 db, ref Trigger pTrigger)
		{
			if (pTrigger == null)
				return;
			sqlite3DeleteTriggerStep(db, ref pTrigger.step_list);
			sqlite3DbFree(db, ref pTrigger.zName);
			sqlite3DbFree(db, ref pTrigger.table);
			sqlite3ExprDelete(db, ref pTrigger.pWhen);
			sqlite3IdListDelete(db, ref pTrigger.pColumns);
			pTrigger = null;
			sqlite3DbFree(db, ref pTrigger);
		}

		/*
		** This function is called to drop a trigger from the database schema.
		**
		** This may be called directly from the parser and therefore identifies
		** the trigger by name.  The sqlite3DropTriggerPtr() routine does the
		** same job as this routine except it takes a pointer to the trigger
		** instead of the trigger name.
		**/

		private static void sqlite3DropTrigger(Parse pParse, SrcList pName, int noErr)
		{
			Trigger pTrigger = null;
			int i;
			string zDb;
			string zName;
			int nName;
			sqlite3 db = pParse.db;

			//      if ( db.mallocFailed != 0 ) goto drop_trigger_cleanup;
			if (SQLITE_OK != sqlite3ReadSchema(pParse))
			{
				goto drop_trigger_cleanup;
			}

			Debug.Assert(pName.nSrc == 1);
			zDb = pName.a[0].zDatabase;
			zName = pName.a[0].zName;
			nName = sqlite3Strlen30(zName);
			Debug.Assert(zDb != null || sqlite3BtreeHoldsAllMutexes(db));
			for (i = OMIT_TEMPDB; i < db.nDb; i++)
			{
				int j = (i < 2) ? i ^ 1 : i;  /* Search TEMP before MAIN */
				if (zDb != null && !db.aDb[j].zName.Equals(zDb, StringComparison.OrdinalIgnoreCase))
					continue;
				Debug.Assert(sqlite3SchemaMutexHeld(db, j, null));
				pTrigger = sqlite3HashFind((db.aDb[j].pSchema.trigHash), zName, nName, (Trigger)null);
				if (pTrigger != null)
					break;
			}
			if (pTrigger == null)
			{
				if (noErr == 0)
				{
					sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0);
				}
				else
				{
					sqlite3CodeVerifyNamedSchema(pParse, zDb);
				}
				pParse.checkSchema = 1;
				goto drop_trigger_cleanup;
			}
			sqlite3DropTriggerPtr(pParse, pTrigger);

		drop_trigger_cleanup:
			sqlite3SrcListDelete(db, ref pName);
		}

		/*
		** Return a pointer to the Table structure for the table that a trigger
		** is set on.
		*/

		private static Table tableOfTrigger(Trigger pTrigger)
		{
			int n = sqlite3Strlen30(pTrigger.table);
			return sqlite3HashFind(pTrigger.pTabSchema.tblHash, pTrigger.table, n, (Table)null);
		}

		/*
		** Drop a trigger given a pointer to that trigger.
		*/

		private static void sqlite3DropTriggerPtr(Parse pParse, Trigger pTrigger)
		{
			Table pTable;
			Vdbe v;
			sqlite3 db = pParse.db;
			int iDb;

			iDb = sqlite3SchemaToIndex(pParse.db, pTrigger.pSchema);
			Debug.Assert(iDb >= 0 && iDb < db.nDb);
			pTable = tableOfTrigger(pTrigger);
			Debug.Assert(pTable != null);
			Debug.Assert(pTable.pSchema == pTrigger.pSchema || iDb == 1);
#if !SQLITE_OMIT_AUTHORIZATION
{
int code = SQLITE_DROP_TRIGGER;
string zDb = db.aDb[iDb].zName;
string zTab = SCHEMA_TABLE(iDb);
if( iDb==1 ) code = SQLITE_DROP_TEMP_TRIGGER;
if( sqlite3AuthCheck(pParse, code, pTrigger.name, pTable.zName, zDb) ||
sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
return;
}
}
#endif

			/* Generate code to destroy the database record of the trigger.
*/
			Debug.Assert(pTable != null);
			if ((v = sqlite3GetVdbe(pParse)) != null)
			{
				int _base;
				VdbeOpList[] dropTrigger = new VdbeOpList[]  {
new VdbeOpList( OP_Rewind,     0, ADDR(9),  0),
new VdbeOpList( OP_String8,    0, 1,        0), /* 1 */
new VdbeOpList( OP_Column,     0, 1,        2),
new VdbeOpList( OP_Ne,         2, ADDR(8),  1),
new VdbeOpList( OP_String8,    0, 1,        0), /* 4: "trigger" */
new VdbeOpList( OP_Column,     0, 0,        2),
new VdbeOpList( OP_Ne,         2, ADDR(8),  1),
new VdbeOpList( OP_Delete,     0, 0,        0),
new VdbeOpList( OP_Next,       0, ADDR(1),  0), /* 8 */
};

				sqlite3BeginWriteOperation(pParse, 0, iDb);
				sqlite3OpenMasterTable(pParse, iDb);
				_base = sqlite3VdbeAddOpList(v, dropTrigger.Length, dropTrigger);
				sqlite3VdbeChangeP4(v, _base + 1, pTrigger.zName, P4_TRANSIENT);
				sqlite3VdbeChangeP4(v, _base + 4, "trigger", P4_STATIC);
				sqlite3ChangeCookie(pParse, iDb);
				sqlite3VdbeAddOp2(v, OP_Close, 0, 0);
				sqlite3VdbeAddOp4(v, OP_DropTrigger, iDb, 0, 0, pTrigger.zName, 0);
				if (pParse.nMem < 3)
				{
					pParse.nMem = 3;
				}
			}
		}

		/*
		** Remove a trigger from the hash tables of the sqlite* pointer.
		*/

		private static void sqlite3UnlinkAndDeleteTrigger(sqlite3 db, int iDb, string zName)
		{
			Trigger pTrigger;
			Hash pHash;

			Debug.Assert(sqlite3SchemaMutexHeld(db, iDb, null));
			pHash = (db.aDb[iDb].pSchema.trigHash);
			pTrigger = sqlite3HashInsert(ref pHash, zName, sqlite3Strlen30(zName), (Trigger)null);
			if (ALWAYS(pTrigger != null))
			{
				if (pTrigger.pSchema == pTrigger.pTabSchema)
				{
					Table pTab = tableOfTrigger(pTrigger);
					//Trigger** pp;
					//for ( pp = &pTab.pTrigger ; *pp != pTrigger ; pp = &( (*pp).pNext ) ) ;
					//*pp = (*pp).pNext;
					if (pTab.pTrigger == pTrigger)
					{
						pTab.pTrigger = pTrigger.pNext;
					}
					else
					{
						Trigger cc = pTab.pTrigger;
						while (cc != null)
						{
							if (cc.pNext == pTrigger)
							{
								cc.pNext = cc.pNext.pNext;
								break;
							}
							cc = cc.pNext;
						}
						Debug.Assert(cc != null);
					}
				}
				sqlite3DeleteTrigger(db, ref pTrigger);
				db.flags |= SQLITE_InternChanges;
			}
		}

		/*
		** pEList is the SET clause of an UPDATE statement.  Each entry
		** in pEList is of the format <id>=<expr>.  If any of the entries
		** in pEList have an <id> which matches an identifier in pIdList,
		** then return TRUE.  If pIdList==NULL, then it is considered a
		** wildcard that matches anything.  Likewise if pEList==NULL then
		** it matches anything so always return true.  Return false only
		** if there is no match.
		*/

		private static int checkColumnOverlap(IdList pIdList, ExprList pEList)
		{
			int e;
			if (pIdList == null || NEVER(pEList == null))
				return 1;
			for (e = 0; e < pEList.nExpr; e++)
			{
				if (sqlite3IdListIndex(pIdList, pEList.a[e].zName) >= 0)
					return 1;
			}
			return 0;
		}

		/*
		** Return a list of all triggers on table pTab if there exists at least
		** one trigger that must be fired when an operation of type 'op' is
		** performed on the table, and, if that operation is an UPDATE, if at
		** least one of the columns in pChanges is being modified.
		*/

		private static Trigger sqlite3TriggersExist(
		Parse pParse,          /* Parse context */
		Table pTab,            /* The table the contains the triggers */
		int op,                /* one of TK_DELETE, TK_INSERT, TK_UPDATE */
		ExprList pChanges,     /* Columns that change in an UPDATE statement */
		out int pMask          /* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
		)
		{
			int mask = 0;
			Trigger pList = null;
			Trigger p;

			if ((pParse.db.flags & SQLITE_EnableTrigger) != 0)
			{
				pList = sqlite3TriggerList(pParse, pTab);
			}
			Debug.Assert(pList == null || IsVirtual(pTab) == false);
			for (p = pList; p != null; p = p.pNext)
			{
				if (p.op == op && checkColumnOverlap(p.pColumns, pChanges) != 0)
				{
					mask |= p.tr_tm;
				}
			}
			//if ( pMask != 0 )
			{
				pMask = mask;
			}
			return (mask != 0 ? pList : null);
		}

		/*
		** Convert the pStep.target token into a SrcList and return a pointer
		** to that SrcList.
		**
		** This routine adds a specific database name, if needed, to the target when
		** forming the SrcList.  This prevents a trigger in one database from
		** referring to a target in another database.  An exception is when the
		** trigger is in TEMP in which case it can refer to any other database it
		** wants.
		*/

		private static SrcList targetSrcList(
		Parse pParse,       /* The parsing context */
		TriggerStep pStep   /* The trigger containing the target token */
		)
		{
			int iDb;             /* Index of the database to use */
			SrcList pSrc;        /* SrcList to be returned */

			pSrc = sqlite3SrcListAppend(pParse.db, 0, pStep.target, 0);
			//if ( pSrc != null )
			//{
			Debug.Assert(pSrc.nSrc > 0);
			Debug.Assert(pSrc.a != null);
			iDb = sqlite3SchemaToIndex(pParse.db, pStep.pTrig.pSchema);
			if (iDb == 0 || iDb >= 2)
			{
				sqlite3 db = pParse.db;
				Debug.Assert(iDb < pParse.db.nDb);
				pSrc.a[pSrc.nSrc - 1].zDatabase = db.aDb[iDb].zName;// sqlite3DbStrDup( db, db.aDb[iDb].zName );
			}
			//}
			return pSrc;
		}

		/*
		** Generate VDBE code for the statements inside the body of a single
		** trigger.
		*/

		private static int codeTriggerProgram(
		Parse pParse,            /* The parser context */
		TriggerStep pStepList,   /* List of statements inside the trigger body */
		int orconf               /* Conflict algorithm. (OE_Abort, etc) */
		)
		{
			TriggerStep pStep;
			Vdbe v = pParse.pVdbe;
			sqlite3 db = pParse.db;

			Debug.Assert(pParse.pTriggerTab != null && pParse.pToplevel != null);
			Debug.Assert(pStepList != null);
			Debug.Assert(v != null);
			for (pStep = pStepList; pStep != null; pStep = pStep.pNext)
			{
				/* Figure out the ON CONFLICT policy that will be used for this step
				** of the trigger program. If the statement that caused this trigger
				** to fire had an explicit ON CONFLICT, then use it. Otherwise, use
				** the ON CONFLICT policy that was specified as part of the trigger
				** step statement. Example:
				**
				**   CREATE TRIGGER AFTER INSERT ON t1 BEGIN;
				**     INSERT OR REPLACE INTO t2 VALUES(new.a, new.b);
				**   END;
				**
				**   INSERT INTO t1 ... ;            -- insert into t2 uses REPLACE policy
				**   INSERT OR IGNORE INTO t1 ... ;  -- insert into t2 uses IGNORE policy
				*/
				pParse.eOrconf = (orconf == OE_Default) ? pStep.orconf : (u8)orconf;

				switch (pStep.op)
				{
					case TK_UPDATE:
						{
							sqlite3Update(pParse,
							  targetSrcList(pParse, pStep),
							  sqlite3ExprListDup(db, pStep.pExprList, 0),
							  sqlite3ExprDup(db, pStep.pWhere, 0),
							  pParse.eOrconf
							);
							break;
						}
					case TK_INSERT:
						{
							sqlite3Insert(pParse,
							  targetSrcList(pParse, pStep),
							  sqlite3ExprListDup(db, pStep.pExprList, 0),
							  sqlite3SelectDup(db, pStep.pSelect, 0),
							  sqlite3IdListDup(db, pStep.pIdList),
							  pParse.eOrconf
							);
							break;
						}
					case TK_DELETE:
						{
							sqlite3DeleteFrom(pParse,
							  targetSrcList(pParse, pStep),
							  sqlite3ExprDup(db, pStep.pWhere, 0)
							);
							break;
						}
					default:
						Debug.Assert(pStep.op == TK_SELECT);
						{
							SelectDest sDest = new SelectDest();
							Select pSelect = sqlite3SelectDup(db, pStep.pSelect, 0);
							sqlite3SelectDestInit(sDest, SRT_Discard, 0);
							sqlite3Select(pParse, pSelect, ref sDest);
							sqlite3SelectDelete(db, ref pSelect);
							break;
						}
				}
				if (pStep.op != TK_SELECT)
				{
					sqlite3VdbeAddOp0(v, OP_ResetCount);
				}
			}

			return 0;
		}

#if SQLITE_DEBUG
		/*
** This function is used to add VdbeComment() annotations to a VDBE
** program. It is not used in production code, only for debugging.
*/

		private static string onErrorText(int onError)
		{
			switch (onError)
			{
				case OE_Abort:
					return "abort";

				case OE_Rollback:
					return "rollback";

				case OE_Fail:
					return "fail";

				case OE_Replace:
					return "replace";

				case OE_Ignore:
					return "ignore";

				case OE_Default:
					return "default";
			}
			return "n/a";
		}

#endif

		/*
** Parse context structure pFrom has just been used to create a sub-vdbe
** (trigger program). If an error has occurred, transfer error information
** from pFrom to pTo.
*/

		private static void transferParseError(Parse pTo, Parse pFrom)
		{
			Debug.Assert(String.IsNullOrEmpty(pFrom.zErrMsg) || pFrom.nErr != 0);
			Debug.Assert(String.IsNullOrEmpty(pTo.zErrMsg) || pTo.nErr != 0);
			if (pTo.nErr == 0)
			{
				pTo.zErrMsg = pFrom.zErrMsg;
				pTo.nErr = pFrom.nErr;
			}
			else
			{
				sqlite3DbFree(pFrom.db, ref pFrom.zErrMsg);
			}
		}

		/*
		** Create and populate a new TriggerPrg object with a sub-program
		** implementing trigger pTrigger with ON CONFLICT policy orconf.
		*/

		private static TriggerPrg codeRowTrigger(
		  Parse pParse,        /* Current parse context */
		  Trigger pTrigger,    /* Trigger to code */
		  Table pTab,          /* The table pTrigger is attached to */
		  int orconf           /* ON CONFLICT policy to code trigger program with */
		)
		{
			Parse pTop = sqlite3ParseToplevel(pParse);
			sqlite3 db = pParse.db;     /* Database handle */
			TriggerPrg pPrg;            /* Value to return */
			Expr pWhen = null;          /* Duplicate of trigger WHEN expression */
			Vdbe v;                     /* Temporary VM */
			NameContext sNC;            /* Name context for sub-vdbe */
			SubProgram pProgram = null; /* Sub-vdbe for trigger program */
			Parse pSubParse;            /* Parse context for sub-vdbe */
			int iEndTrigger = 0;        /* Label to jump to if WHEN is false */

			Debug.Assert(pTrigger.zName == null || pTab == tableOfTrigger(pTrigger));
			Debug.Assert(pTop.pVdbe != null);

			/* Allocate the TriggerPrg and SubProgram objects. To ensure that they
			** are freed if an error occurs, link them into the Parse.pTriggerPrg
			** list of the top-level Parse object sooner rather than later.  */
			pPrg = new TriggerPrg();// sqlite3DbMallocZero( db, sizeof( TriggerPrg ) );
			//if ( null == pPrg ) return 0;
			pPrg.pNext = pTop.pTriggerPrg;
			pTop.pTriggerPrg = pPrg;
			pPrg.pProgram = pProgram = new SubProgram();// sqlite3DbMallocZero( db, sizeof( SubProgram ) );
			//if( null==pProgram ) return 0;
			sqlite3VdbeLinkSubProgram(pTop.pVdbe, pProgram);
			pPrg.pTrigger = pTrigger;
			pPrg.orconf = orconf;
			pPrg.aColmask[0] = 0xffffffff;
			pPrg.aColmask[1] = 0xffffffff;

			/* Allocate and populate a new Parse context to use for coding the
			** trigger sub-program.  */
			pSubParse = new Parse();// sqlite3StackAllocZero( db, sizeof( Parse ) );
			//if ( null == pSubParse ) return null;
			sNC = new NameContext();// memset( &sNC, 0, sizeof( sNC ) );
			sNC.pParse = pSubParse;
			pSubParse.db = db;
			pSubParse.pTriggerTab = pTab;
			pSubParse.pToplevel = pTop;
			pSubParse.zAuthContext = pTrigger.zName;
			pSubParse.eTriggerOp = pTrigger.op;
			pSubParse.nQueryLoop = pParse.nQueryLoop;

			v = sqlite3GetVdbe(pSubParse);
			if (v != null)
			{
#if SQLITE_DEBUG
				VdbeComment(v, "Start: %s.%s (%s %s%s%s ON %s)",
				  pTrigger.zName != null ? pTrigger.zName : "", onErrorText(orconf),
				  (pTrigger.tr_tm == TRIGGER_BEFORE ? "BEFORE" : "AFTER"),
					(pTrigger.op == TK_UPDATE ? "UPDATE" : ""),
					(pTrigger.op == TK_INSERT ? "INSERT" : ""),
					(pTrigger.op == TK_DELETE ? "DELETE" : ""),
				  pTab.zName
				);
#endif
#if !SQLITE_OMIT_TRACE
				sqlite3VdbeChangeP4(v, -1,
				  sqlite3MPrintf(db, "-- TRIGGER %s", pTrigger.zName), P4_DYNAMIC
				);
#endif

				/* If one was specified, code the WHEN clause. If it evaluates to false
    ** (or NULL) the sub-vdbe is immediately halted by jumping to the
    ** OP_Halt inserted at the end of the program.  */
				if (pTrigger.pWhen != null)
				{
					pWhen = sqlite3ExprDup(db, pTrigger.pWhen, 0);
					if (SQLITE_OK == sqlite3ResolveExprNames(sNC, ref pWhen)
						//&& db.mallocFailed==0
					)
					{
						iEndTrigger = sqlite3VdbeMakeLabel(v);
						sqlite3ExprIfFalse(pSubParse, pWhen, iEndTrigger, SQLITE_JUMPIFNULL);
					}
					sqlite3ExprDelete(db, ref pWhen);
				}

				/* Code the trigger program into the sub-vdbe. */
				codeTriggerProgram(pSubParse, pTrigger.step_list, orconf);

				/* Insert an OP_Halt at the end of the sub-program. */
				if (iEndTrigger != 0)
				{
					sqlite3VdbeResolveLabel(v, iEndTrigger);
				}
				sqlite3VdbeAddOp0(v, OP_Halt);
#if SQLITE_DEBUG
				VdbeComment(v, "End: %s.%s", pTrigger.zName, onErrorText(orconf));
#endif
				transferParseError(pParse, pSubParse);
				//if( db.mallocFailed==0 ){
				pProgram.aOp = sqlite3VdbeTakeOpArray(v, ref pProgram.nOp, ref pTop.nMaxArg);
				//}
				pProgram.nMem = pSubParse.nMem;
				pProgram.nCsr = pSubParse.nTab;
				pProgram.token = pTrigger.GetHashCode();
				pPrg.aColmask[0] = pSubParse.oldmask;
				pPrg.aColmask[1] = pSubParse.newmask;
				sqlite3VdbeDelete(ref v);
			}

			Debug.Assert(null == pSubParse.pAinc && null == pSubParse.pZombieTab);
			Debug.Assert(null == pSubParse.pTriggerPrg && 0 == pSubParse.nMaxArg);
			//sqlite3StackFree(db, pSubParse);

			return pPrg;
		}

		/*
		** Return a pointer to a TriggerPrg object containing the sub-program for
		** trigger pTrigger with default ON CONFLICT algorithm orconf. If no such
		** TriggerPrg object exists, a new object is allocated and populated before
		** being returned.
		*/

		private static TriggerPrg getRowTrigger(
		  Parse pParse,        /* Current parse context */
		  Trigger pTrigger,    /* Trigger to code */
		  Table pTab,          /* The table trigger pTrigger is attached to */
		  int orconf           /* ON CONFLICT algorithm. */
		)
		{
			Parse pRoot = sqlite3ParseToplevel(pParse);
			TriggerPrg pPrg;

			Debug.Assert(pTrigger.zName == null || pTab == tableOfTrigger(pTrigger));

			/* It may be that this trigger has already been coded (or is in the
			** process of being coded). If this is the case, then an entry with
			** a matching TriggerPrg.pTrigger field will be present somewhere
			** in the Parse.pTriggerPrg list. Search for such an entry.  */
			for (pPrg = pRoot.pTriggerPrg;
				pPrg != null && (pPrg.pTrigger != pTrigger || pPrg.orconf != orconf);
				pPrg = pPrg.pNext
			)
				;

			/* If an existing TriggerPrg could not be located, create a new one. */
			if (null == pPrg)
			{
				pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf);
			}

			return pPrg;
		}

		/*
		** Generate code for the trigger program associated with trigger p on
		** table pTab. The reg, orconf and ignoreJump parameters passed to this
		** function are the same as those described in the header function for
		** sqlite3CodeRowTrigger()
		*/

		private static void sqlite3CodeRowTriggerDirect(
		  Parse pParse,        /* Parse context */
		  Trigger p,           /* Trigger to code */
		  Table pTab,          /* The table to code triggers from */
		  int reg,             /* Reg array containing OLD.* and NEW.* values */
		  int orconf,          /* ON CONFLICT policy */
		  int ignoreJump       /* Instruction to jump to for RAISE(IGNORE) */
		)
		{
			Vdbe v = sqlite3GetVdbe(pParse); /* Main VM */
			TriggerPrg pPrg;
			pPrg = getRowTrigger(pParse, p, pTab, orconf);
			Debug.Assert(pPrg != null || pParse.nErr != 0);//|| pParse.db.mallocFailed );

			/* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program
			** is a pointer to the sub-vdbe containing the trigger program.  */
			if (pPrg != null)
			{
				bool bRecursive = (!String.IsNullOrEmpty(p.zName) && 0 == (pParse.db.flags & SQLITE_RecTriggers));
				sqlite3VdbeAddOp3(v, OP_Program, reg, ignoreJump, ++pParse.nMem);
				sqlite3VdbeChangeP4(v, -1, pPrg.pProgram, P4_SUBPROGRAM);
#if SQLITE_DEBUG
				VdbeComment
					(v, "Call: %s.%s", (!String.IsNullOrEmpty(p.zName) ? p.zName : "fkey"), onErrorText(orconf));
#endif

				/* Set the P5 operand of the OP_Program instruction to non-zero if
    ** recursive invocation of this trigger program is disallowed. Recursive
    ** invocation is disallowed if (a) the sub-program is really a trigger,
    ** not a foreign key action, and (b) the flag to enable recursive triggers
    ** is clear.  */
				sqlite3VdbeChangeP5(v, (u8)(bRecursive ? 1 : 0));
			}
		}

		/*
		** This is called to code the required FOR EACH ROW triggers for an operation
		** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE)
		** is given by the op paramater. The tr_tm parameter determines whether the
		** BEFORE or AFTER triggers are coded. If the operation is an UPDATE, then
		** parameter pChanges is passed the list of columns being modified.
		**
		** If there are no triggers that fire at the specified time for the specified
		** operation on pTab, this function is a no-op.
		**
		** The reg argument is the address of the first in an array of registers
		** that contain the values substituted for the new.* and old.* references
		** in the trigger program. If N is the number of columns in table pTab
		** (a copy of pTab.nCol), then registers are populated as follows:
		**
		**   Register       Contains
		**   ------------------------------------------------------
		**   reg+0          OLD.rowid
		**   reg+1          OLD.* value of left-most column of pTab
		**   ...            ...
		**   reg+N          OLD.* value of right-most column of pTab
		**   reg+N+1        NEW.rowid
		**   reg+N+2        OLD.* value of left-most column of pTab
		**   ...            ...
		**   reg+N+N+1      NEW.* value of right-most column of pTab
		**
		** For ON DELETE triggers, the registers containing the NEW.* values will
		** never be accessed by the trigger program, so they are not allocated or
		** populated by the caller (there is no data to populate them with anyway).
		** Similarly, for ON INSERT triggers the values stored in the OLD.* registers
		** are never accessed, and so are not allocated by the caller. So, for an
		** ON INSERT trigger, the value passed to this function as parameter reg
		** is not a readable register, although registers (reg+N) through
		** (reg+N+N+1) are.
		**
		** Parameter orconf is the default conflict resolution algorithm for the
		** trigger program to use (REPLACE, IGNORE etc.). Parameter ignoreJump
		** is the instruction that control should jump to if a trigger program
		** raises an IGNORE exception.
		*/

		private static void sqlite3CodeRowTrigger(
		Parse pParse,        /* Parse context */
		Trigger pTrigger,    /* List of triggers on table pTab */
		int op,              /* One of TK_UPDATE, TK_INSERT, TK_DELETE */
		ExprList pChanges,   /* Changes list for any UPDATE OF triggers */
		int tr_tm,           /* One of TRIGGER_BEFORE, TRIGGER_AFTER */
		Table pTab,          /* The table to code triggers from */
		int reg,             /* The first in an array of registers (see above) */
		int orconf,          /* ON CONFLICT policy */
		int ignoreJump       /* Instruction to jump to for RAISE(IGNORE) */
		)
		{
			Trigger p;         /* Used to iterate through pTrigger list */

			Debug.Assert(op == TK_UPDATE || op == TK_INSERT || op == TK_DELETE);
			Debug.Assert(tr_tm == TRIGGER_BEFORE || tr_tm == TRIGGER_AFTER);
			Debug.Assert((op == TK_UPDATE) == (pChanges != null));

			for (p = pTrigger; p != null; p = p.pNext)
			{
				/* Sanity checking:  The schema for the trigger and for the table are
				** always defined.  The trigger must be in the same schema as the table
				** or else it must be a TEMP trigger. */
				Debug.Assert(p.pSchema != null);
				Debug.Assert(p.pTabSchema != null);
				Debug.Assert(p.pSchema == p.pTabSchema
					 || p.pSchema == pParse.db.aDb[1].pSchema);

				/* Determine whether we should code this trigger */
				if (p.op == op
				 && p.tr_tm == tr_tm
				 && checkColumnOverlap(p.pColumns, pChanges) != 0
				)
				{
					sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
				}
			}
		}

		/*
		** Triggers may access values stored in the old.* or new.* pseudo-table.
		** This function returns a 32-bit bitmask indicating which columns of the
		** old.* or new.* tables actually are used by triggers. This information
		** may be used by the caller, for example, to avoid having to load the entire
		** old.* record into memory when executing an UPDATE or DELETE command.
		**
		** Bit 0 of the returned mask is set if the left-most column of the
		** table may be accessed using an [old|new].<col> reference. Bit 1 is set if
		** the second leftmost column value is required, and so on. If there
		** are more than 32 columns in the table, and at least one of the columns
		** with an index greater than 32 may be accessed, 0xffffffff is returned.
		**
		** It is not possible to determine if the old.rowid or new.rowid column is
		** accessed by triggers. The caller must always assume that it is.
		**
		** Parameter isNew must be either 1 or 0. If it is 0, then the mask returned
		** applies to the old.* table. If 1, the new.* table.
		**
		** Parameter tr_tm must be a mask with one or both of the TRIGGER_BEFORE
		** and TRIGGER_AFTER bits set. Values accessed by BEFORE triggers are only
		** included in the returned mask if the TRIGGER_BEFORE bit is set in the
		** tr_tm parameter. Similarly, values accessed by AFTER triggers are only
		** included in the returned mask if the TRIGGER_AFTER bit is set in tr_tm.
		*/

		private static u32 sqlite3TriggerColmask(
		  Parse pParse,        /* Parse context */
		  Trigger pTrigger,    /* List of triggers on table pTab */
		  ExprList pChanges,   /* Changes list for any UPDATE OF triggers */
		  int isNew,           /* 1 for new.* ref mask, 0 for old.* ref mask */
		  int tr_tm,           /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
		  Table pTab,          /* The table to code triggers from */
		  int orconf           /* Default ON CONFLICT policy for trigger steps */
		)
		{
			int op = pChanges != null ? TK_UPDATE : TK_DELETE;
			u32 mask = 0;
			Trigger p;

			Debug.Assert(isNew == 1 || isNew == 0);
			for (p = pTrigger; p != null; p = p.pNext)
			{
				if (p.op == op && (tr_tm & p.tr_tm) != 0
				 && checkColumnOverlap(p.pColumns, pChanges) != 0
				)
				{
					TriggerPrg pPrg;
					pPrg = getRowTrigger(pParse, p, pTab, orconf);
					if (pPrg != null)
					{
						mask |= pPrg.aColmask[isNew];
					}
				}
			}

			return mask;
		}

#endif // * !SQLITE_OMIT_TRIGGER) */
	}
}