Tarantool development patches archive
 help / color / mirror / Atom feed
From: Kirill Shcherbatov <kshcherbatov@tarantool.org>
To: tarantool-patches@freelists.org
Cc: n.pettik@corp.mail.ru, Kirill Shcherbatov <kshcherbatov@tarantool.org>
Subject: [tarantool-patches] [PATCH v4 6/8] sql: refactor AST trigger object name
Date: Tue, 26 Jun 2018 19:13:31 +0300	[thread overview]
Message-ID: <81986d1f9307191bd3d3e37514dc32fadb7e6970.1530029141.git.kshcherbatov@tarantool.org> (raw)
In-Reply-To: <cover.1530029141.git.kshcherbatov@tarantool.org>

Part of #3273.
---
 src/box/alter.cc        |  14 +-
 src/box/space.h         |   2 +-
 src/box/sql.h           |  17 +-
 src/box/sql/build.c     |   6 +-
 src/box/sql/callback.c  |   3 +-
 src/box/sql/delete.c    |  24 +-
 src/box/sql/expr.c      |   2 -
 src/box/sql/fkey.c      | 162 +++++------
 src/box/sql/insert.c    |  37 ++-
 src/box/sql/parse.y     |   9 +-
 src/box/sql/pragma.c    |   2 -
 src/box/sql/pragma.h    |   6 +-
 src/box/sql/resolve.c   |   2 -
 src/box/sql/select.c    |   2 -
 src/box/sql/sqliteInt.h | 253 ++++++++++++++---
 src/box/sql/status.c    |   2 +-
 src/box/sql/tokenize.c  |   4 +-
 src/box/sql/treeview.c  |   2 -
 src/box/sql/trigger.c   | 709 +++++++++++++++++++++---------------------------
 src/box/sql/update.c    |  32 +--
 src/box/sql/vdbe.c      |  10 +-
 src/box/sql/vdbe.h      |   2 -
 22 files changed, 678 insertions(+), 624 deletions(-)

diff --git a/src/box/alter.cc b/src/box/alter.cc
index 1c0e889..449b4b1 100644
--- a/src/box/alter.cc
+++ b/src/box/alter.cc
@@ -554,7 +554,7 @@ space_swap_triggers(struct space *new_space, struct space *old_space)
 	rlist_swap(&new_space->on_replace, &old_space->on_replace);
 	rlist_swap(&new_space->on_stmt_begin, &old_space->on_stmt_begin);
 	/** Swap SQL Triggers pointer. */
-	struct Trigger *new_value = new_space->sql_triggers;
+	struct sql_trigger *new_value = new_space->sql_triggers;
 	new_space->sql_triggers = old_space->sql_triggers;
 	old_space->sql_triggers = new_value;
 }
@@ -3257,8 +3257,8 @@ static void
 on_replace_trigger_rollback(struct trigger *trigger, void *event)
 {
 	struct txn_stmt *stmt = txn_last_stmt((struct txn*) event);
-	struct Trigger *old_trigger = (struct Trigger *)trigger->data;
-	struct Trigger *new_trigger;
+	struct sql_trigger *old_trigger = (struct sql_trigger *)trigger->data;
+	struct sql_trigger *new_trigger;
 
 	if (stmt->old_tuple != NULL && stmt->new_tuple == NULL) {
 		/* Rollback DELETE trigger. */
@@ -3294,7 +3294,7 @@ on_replace_trigger_rollback(struct trigger *trigger, void *event)
 static void
 on_replace_trigger_commit(struct trigger *trigger, void * /* event */)
 {
-	struct Trigger *old_trigger = (struct Trigger *)trigger->data;
+	struct sql_trigger *old_trigger = (struct sql_trigger *)trigger->data;
 	sql_trigger_delete(sql_get(), old_trigger);
 }
 
@@ -3328,7 +3328,7 @@ on_replace_dd_trigger(struct trigger * /* trigger */, void *event)
 		memcpy(trigger_name, trigger_name_src, trigger_name_len);
 		trigger_name[trigger_name_len] = 0;
 
-		struct Trigger *old_trigger;
+		struct sql_trigger *old_trigger;
 		int rc = sql_trigger_replace(sql_get(), trigger_name, NULL,
 					     &old_trigger);
 		(void)rc;
@@ -3351,7 +3351,7 @@ on_replace_dd_trigger(struct trigger * /* trigger */, void *event)
 		struct space_opts opts;
 		struct region *region = &fiber()->gc;
 		space_opts_decode(&opts, space_opts, region);
-		struct Trigger *new_trigger =
+		struct sql_trigger *new_trigger =
 			sql_trigger_compile(sql_get(), opts.sql);
 		if (new_trigger == NULL)
 			diag_raise();
@@ -3377,7 +3377,7 @@ on_replace_dd_trigger(struct trigger * /* trigger */, void *event)
 				  "resolved on AST building from SQL");
 		}
 
-		struct Trigger *old_trigger;
+		struct sql_trigger *old_trigger;
 		if (sql_trigger_replace(sql_get(), trigger_name, new_trigger,
 					&old_trigger) != 0)
 			diag_raise();
diff --git a/src/box/space.h b/src/box/space.h
index 64aa8c7..7da2ee5 100644
--- a/src/box/space.h
+++ b/src/box/space.h
@@ -147,7 +147,7 @@ struct space {
 	/** Triggers fired before space statement */
 	struct rlist on_stmt_begin;
 	/** SQL Trigger list. */
-	struct Trigger *sql_triggers;
+	struct sql_trigger *sql_triggers;
 	/**
 	 * The number of *enabled* indexes in the space.
 	 *
diff --git a/src/box/sql.h b/src/box/sql.h
index 2572a15..f483921 100644
--- a/src/box/sql.h
+++ b/src/box/sql.h
@@ -66,7 +66,7 @@ struct Expr;
 struct Parse;
 struct Select;
 struct Table;
-struct Trigger;
+struct sql_trigger;
 
 /**
  * Perform parsing of provided expression. This is done by
@@ -100,9 +100,9 @@ sql_view_compile(struct sqlite3 *db, const char *view_stmt);
  * @param sql request to parse.
  *
  * @retval NULL on error
- * @retval not NULL Trigger AST pointer on success.
+ * @retval not NULL sql_trigger AST pointer on success.
  */
-struct Trigger *
+struct sql_trigger *
 sql_trigger_compile(struct sqlite3 *db, const char *sql);
 
 /**
@@ -111,7 +111,7 @@ sql_trigger_compile(struct sqlite3 *db, const char *sql);
  * @param trigger AST object.
  */
 void
-sql_trigger_delete(struct sqlite3 *db, struct Trigger *trigger);
+sql_trigger_delete(struct sqlite3 *db, struct sql_trigger *trigger);
 
 /**
  * Get server triggers list by space_id.
@@ -119,7 +119,7 @@ sql_trigger_delete(struct sqlite3 *db, struct Trigger *trigger);
  *
  * @retval trigger AST list.
  */
-struct Trigger *
+struct sql_trigger *
 space_trigger_list(uint32_t space_id);
 
 /**
@@ -134,7 +134,8 @@ space_trigger_list(uint32_t space_id);
  */
 int
 sql_trigger_replace(struct sqlite3 *db, const char *name,
-		    struct Trigger *trigger, struct Trigger **old_trigger);
+		    struct sql_trigger *trigger,
+		    struct sql_trigger **old_trigger);
 
 /**
  * Get trigger name by trigger AST object.
@@ -142,7 +143,7 @@ sql_trigger_replace(struct sqlite3 *db, const char *name,
  * @return trigger name string.
  */
 const char *
-sql_trigger_name(struct Trigger *trigger);
+sql_trigger_name(struct sql_trigger *trigger);
 
 /**
  * Get space_id of the space that trigger has been built for.
@@ -150,7 +151,7 @@ sql_trigger_name(struct Trigger *trigger);
  * @return space identifier.
  */
 uint32_t
-sql_trigger_space_id(struct Trigger *trigger);
+sql_trigger_space_id(struct sql_trigger *trigger);
 
 /**
  * Store duplicate of a parsed expression into @a parser.
diff --git a/src/box/sql/build.c b/src/box/sql/build.c
index 2b4e6c7..b88b8fe 100644
--- a/src/box/sql/build.c
+++ b/src/box/sql/build.c
@@ -2119,10 +2119,10 @@ sql_code_drop_table(struct Parse *parse_context, struct space *space,
 	 * accounted in DELETE from _space below.
 	 */
 	parse_context->nested++;
-	struct Trigger *trigger = space->sql_triggers;
+	struct sql_trigger *trigger = space->sql_triggers;
 	while (trigger != NULL) {
-		sqlite3DropTriggerPtr(parse_context, trigger);
-		trigger = trigger->pNext;
+		vdbe_code_drop_trigger_ptr(parse_context, trigger);
+		trigger = trigger->next;
 	}
 	parse_context->nested--;
 	/*
diff --git a/src/box/sql/callback.c b/src/box/sql/callback.c
index bd8db99..c3c38cb 100644
--- a/src/box/sql/callback.c
+++ b/src/box/sql/callback.c
@@ -292,7 +292,8 @@ sqlite3SchemaClear(sqlite3 * db)
 	sqlite3HashInit(&pSchema->trigHash);
 	for (pElem = sqliteHashFirst(&temp2); pElem != NULL;
 	     pElem = sqliteHashNext(pElem))
-		sql_trigger_delete(NULL, (Trigger *) sqliteHashData(pElem));
+		sql_trigger_delete(NULL,
+				   (struct sql_trigger *)sqliteHashData(pElem));
 	sqlite3HashClear(&temp2);
 	sqlite3HashInit(&pSchema->tblHash);
 	for (pElem = sqliteHashFirst(&temp1); pElem;
diff --git a/src/box/sql/delete.c b/src/box/sql/delete.c
index 8b13f60..818bbbd 100644
--- a/src/box/sql/delete.c
+++ b/src/box/sql/delete.c
@@ -93,7 +93,7 @@ sql_table_delete_from(struct Parse *parse, struct SrcList *tab_list,
 	/* Figure out if we have any triggers and if the table
 	 * being deleted from is a view.
 	 */
-	struct Trigger *trigger_list = NULL;
+	struct sql_trigger *trigger_list = NULL;
 	/* True if there are triggers or FKs or subqueries in the
 	 * WHERE clause.
 	 */
@@ -124,8 +124,7 @@ sql_table_delete_from(struct Parse *parse, struct SrcList *tab_list,
 		space_id = SQLITE_PAGENO_TO_SPACEID(table->tnum);
 		space = space_by_id(space_id);
 		assert(space != NULL);
-		trigger_list =sqlite3TriggersExist(table, TK_DELETE,
-						   NULL, NULL);
+		trigger_list = sql_triggers_exist(table, TK_DELETE, NULL, NULL);
 		is_complex = trigger_list != NULL ||
 			     sqlite3FkRequired(table, NULL);
 	}
@@ -424,8 +423,8 @@ sql_table_delete_from(struct Parse *parse, struct SrcList *tab_list,
 
 void
 sql_generate_row_delete(struct Parse *parse, struct Table *table,
-			struct Trigger *trigger_list, int cursor, int reg_pk,
-			short npk, bool need_update_count,
+			struct sql_trigger *trigger_list, int cursor,
+			int reg_pk, short npk, bool need_update_count,
 			enum on_conflict_action onconf, u8 mode,
 			int idx_noseek)
 {
@@ -457,9 +456,10 @@ sql_generate_row_delete(struct Parse *parse, struct Table *table,
 		/* Mask of OLD.* columns in use */
 		/* TODO: Could use temporary registers here. */
 		uint32_t mask =
-		    sqlite3TriggerColmask(parse, trigger_list, 0, 0,
-					  TRIGGER_BEFORE | TRIGGER_AFTER, table,
-					  onconf);
+			sql_trigger_colmask(parse, trigger_list, 0, 0,
+					    TRIGGER_BEFORE | TRIGGER_AFTER,
+					    table,
+					    onconf);
 		mask |= sqlite3FkOldmask(parse, table);
 		first_old_reg = parse->nMem + 1;
 		parse->nMem += (1 + (int)table->def->field_count);
@@ -483,7 +483,7 @@ sql_generate_row_delete(struct Parse *parse, struct Table *table,
 
 		/* Invoke BEFORE DELETE trigger programs. */
 		int addr_start = sqlite3VdbeCurrentAddr(v);
-		sqlite3CodeRowTrigger(parse, trigger_list, TK_DELETE, NULL,
+		vdbe_code_row_trigger(parse, trigger_list, TK_DELETE, NULL,
 				      TRIGGER_BEFORE, table, first_old_reg,
 				      onconf, label);
 
@@ -537,9 +537,9 @@ sql_generate_row_delete(struct Parse *parse, struct Table *table,
 		sqlite3FkActions(parse, table, 0, first_old_reg, 0);
 
 		/* Invoke AFTER DELETE trigger programs. */
-		sqlite3CodeRowTrigger(parse, trigger_list,
-				      TK_DELETE, 0, TRIGGER_AFTER, table,
-				      first_old_reg, onconf, label);
+		vdbe_code_row_trigger(parse, trigger_list, TK_DELETE, 0,
+				      TRIGGER_AFTER, table, first_old_reg,
+				      onconf, label);
 	}
 
 	/* Jump here if the row had already been deleted before
diff --git a/src/box/sql/expr.c b/src/box/sql/expr.c
index 59e7cb4..70e134f 100644
--- a/src/box/sql/expr.c
+++ b/src/box/sql/expr.c
@@ -4289,7 +4289,6 @@ sqlite3ExprCodeTarget(Parse * pParse, Expr * pExpr, int target)
 			sqlite3VdbeResolveLabel(v, endLabel);
 			break;
 		}
-#ifndef SQLITE_OMIT_TRIGGER
 	case TK_RAISE:{
 			assert(pExpr->affinity == ON_CONFLICT_ACTION_ROLLBACK
 			       || pExpr->affinity == ON_CONFLICT_ACTION_ABORT
@@ -4319,7 +4318,6 @@ sqlite3ExprCodeTarget(Parse * pParse, Expr * pExpr, int target)
 
 			break;
 		}
-#endif
 	}
 	sqlite3ReleaseTempReg(pParse, regFree1);
 	sqlite3ReleaseTempReg(pParse, regFree2);
diff --git a/src/box/sql/fkey.c b/src/box/sql/fkey.c
index ce63ff0..121831b 100644
--- a/src/box/sql/fkey.c
+++ b/src/box/sql/fkey.c
@@ -40,7 +40,6 @@
 #include "tarantoolInt.h"
 
 #ifndef SQLITE_OMIT_FOREIGN_KEY
-#ifndef SQLITE_OMIT_TRIGGER
 
 /*
  * Deferred and Immediate FKs
@@ -730,25 +729,29 @@ sqlite3FkReferences(Table * pTab)
 					pTab->def->name);
 }
 
-/*
+/**
  * The second argument is a Trigger structure allocated by the
- * fkActionTrigger() routine. This function deletes the Trigger structure
- * and all of its sub-components.
+ * fkActionTrigger() routine. This function deletes the sql_trigger
+ * structure and all of its sub-components.
  *
- * The Trigger structure or any of its sub-components may be allocated from
- * the lookaside buffer belonging to database handle dbMem.
+ * The Trigger structure or any of its sub-components may be
+ * allocated from the lookaside buffer belonging to database
+ * handle dbMem.
+ *
+ * @param db Database connection.
+ * @param trigger AST object.
  */
 static void
-fkTriggerDelete(sqlite3 * dbMem, Trigger * p)
+sql_fk_trigger_delete(struct sqlite3 *db, struct sql_trigger *trigger)
 {
-	if (p) {
-		TriggerStep *pStep = p->step_list;
-		sql_expr_delete(dbMem, pStep->pWhere, false);
-		sql_expr_list_delete(dbMem, pStep->pExprList);
-		sql_select_delete(dbMem, pStep->pSelect);
-		sql_expr_delete(dbMem, p->pWhen, false);
-		sqlite3DbFree(dbMem, p);
-	}
+	if (trigger == NULL)
+		return;
+	struct TriggerStep *trigger_step = trigger->step_list;
+	sql_expr_delete(db, trigger_step->pWhere, false);
+	sql_expr_list_delete(db, trigger_step->pExprList);
+	sql_select_delete(db, trigger_step->pSelect);
+	sql_expr_delete(db, trigger->pWhen, false);
+	sqlite3DbFree(db, trigger);
 }
 
 /**
@@ -858,15 +861,13 @@ static int
 isSetNullAction(Parse * pParse, FKey * pFKey)
 {
 	Parse *pTop = sqlite3ParseToplevel(pParse);
-	if (pTop->pTriggerPrg) {
-		Trigger *p = pTop->pTriggerPrg->pTrigger;
-		if ((p == pFKey->apTrigger[0]
-		     && pFKey->aAction[0] == OE_SetNull)
-		    || (p == pFKey->apTrigger[1]
-			&& pFKey->aAction[1] == OE_SetNull)
-		    ) {
+	if (pTop->pTriggerPrg != NULL) {
+		struct sql_trigger *trigger = pTop->pTriggerPrg->trigger;
+		if ((trigger == pFKey->apTrigger[0] &&
+		     pFKey->aAction[0] == OE_SetNull) ||
+		    (trigger == pFKey->apTrigger[1]
+			&& pFKey->aAction[1] == OE_SetNull))
 			return 1;
-		}
 	}
 	return 0;
 }
@@ -1175,21 +1176,24 @@ sqlite3FkRequired(Table * pTab,	/* Table being modified */
 	return 0;
 }
 
-/*
- * This function is called when an UPDATE or DELETE operation is being
- * compiled on table pTab, which is the parent table of foreign-key pFKey.
- * If the current operation is an UPDATE, then the pChanges parameter is
- * passed a pointer to the list of columns being modified. If it is a
- * DELETE, pChanges is passed a NULL pointer.
- *
- * It returns a pointer to a Trigger structure containing a trigger
- * equivalent to the ON UPDATE or ON DELETE action specified by pFKey.
- * If the action is "NO ACTION" or "RESTRICT", then a NULL pointer is
- * returned (these actions require no special handling by the triggers
- * sub-system, code for them is created by fkScanChildren()).
- *
- * For example, if pFKey is the foreign key and pTab is table "p" in
- * the following schema:
+/**
+ * This function is called when an UPDATE or DELETE operation is
+ * being compiled on table pTab, which is the parent table of
+ * foreign-key pFKey.
+ * If the current operation is an UPDATE, then the pChanges
+ * parameter is passed a pointer to the list of columns being
+ * modified. If it is a DELETE, pChanges is passed a NULL pointer.
+ *
+ * It returns a pointer to a sql_trigger structure containing a
+ * trigger equivalent to the ON UPDATE or ON DELETE action
+ * specified by pFKey.
+ * If the action is "NO ACTION" or "RESTRICT", then a NULL pointer
+ * is returned (these actions require no special handling by the
+ * triggers sub-system, code for them is created by
+ * fkScanChildren()).
+ *
+ * For example, if pFKey is the foreign key and pTab is table "p"
+ * in the following schema:
  *
  *   CREATE TABLE p(pk PRIMARY KEY);
  *   CREATE TABLE c(ck REFERENCES p ON DELETE CASCADE);
@@ -1200,20 +1204,25 @@ sqlite3FkRequired(Table * pTab,	/* Table being modified */
  *     DELETE FROM c WHERE ck = old.pk;
  *   END;
  *
- * The returned pointer is cached as part of the foreign key object. It
- * is eventually freed along with the rest of the foreign key object by
- * sqlite3FkDelete().
+ * The returned pointer is cached as part of the foreign key
+ * object. It is eventually freed along with the rest of the
+ * foreign key object by sqlite3FkDelete().
+ *
+ * @param pParse Parse context.
+ * @param pTab Table being updated or deleted from.
+ * @param pFKey Foreign key to get action for.
+ * @param pChanges Change-list for UPDATE, NULL for DELETE.
+ *
+ * @retval not NULL on success.
+ * @retval NULL on failure.
  */
-static Trigger *
-fkActionTrigger(Parse * pParse,	/* Parse context */
-		Table * pTab,	/* Table being updated or deleted from */
-		FKey * pFKey,	/* Foreign key to get action for */
-		ExprList * pChanges	/* Change-list for UPDATE, NULL for DELETE */
-    )
+static struct sql_trigger *
+fkActionTrigger(Parse * pParse, Table * pTab, FKey * pFKey, ExprList * pChanges)
 {
 	sqlite3 *db = pParse->db;	/* Database handle */
 	int action;		/* One of OE_None, OE_Cascade etc. */
-	Trigger *pTrigger;	/* Trigger definition to return */
+	/* Trigger definition to return. */
+	struct sql_trigger *trigger;
 	int iAction = (pChanges != 0);	/* 1 for UPDATE, 0 for DELETE */
 	struct session *user_session = current_session();
 
@@ -1222,9 +1231,9 @@ fkActionTrigger(Parse * pParse,	/* Parse context */
 	    && (user_session->sql_flags & SQLITE_DeferFKs)) {
 		return 0;
 	}
-	pTrigger = pFKey->apTrigger[iAction];
+	trigger = pFKey->apTrigger[iAction];
 
-	if (action != ON_CONFLICT_ACTION_NONE && !pTrigger) {
+	if (action != ON_CONFLICT_ACTION_NONE && trigger == NULL) {
 		char const *zFrom;	/* Name of child table */
 		int nFrom;	/* Length in bytes of zFrom */
 		Index *pIdx = 0;	/* Parent key index for this FK */
@@ -1379,13 +1388,13 @@ fkActionTrigger(Parse * pParse,	/* Parse context */
 		/* Disable lookaside memory allocation */
 		db->lookaside.bDisable++;
 
-		pTrigger = (Trigger *) sqlite3DbMallocZero(db, sizeof(Trigger) +	/* struct Trigger */
-							   sizeof(TriggerStep) +	/* Single step in trigger program */
-							   nFrom + 1	/* Space for pStep->zTarget */
-		    );
-		if (pTrigger) {
-			pStep = pTrigger->step_list =
-			    (TriggerStep *) & pTrigger[1];
+		size_t trigger_size = sizeof(struct sql_trigger) +
+				      sizeof(TriggerStep) + nFrom + 1;
+		trigger =
+			(struct sql_trigger *)sqlite3DbMallocZero(db,
+								  trigger_size);
+		if (trigger != NULL) {
+			pStep = trigger->step_list = (TriggerStep *)&trigger[1];
 			pStep->zTarget = (char *)&pStep[1];
 			memcpy((char *)pStep->zTarget, zFrom, nFrom);
 
@@ -1397,7 +1406,7 @@ fkActionTrigger(Parse * pParse,	/* Parse context */
 			    sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE);
 			if (pWhen) {
 				pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0);
-				pTrigger->pWhen =
+				trigger->pWhen =
 				    sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
 			}
 		}
@@ -1410,7 +1419,7 @@ fkActionTrigger(Parse * pParse,	/* Parse context */
 		sql_expr_list_delete(db, pList);
 		sql_select_delete(db, pSelect);
 		if (db->mallocFailed == 1) {
-			fkTriggerDelete(db, pTrigger);
+			sql_fk_trigger_delete(db, trigger);
 			return 0;
 		}
 		assert(pStep != 0);
@@ -1428,12 +1437,12 @@ fkActionTrigger(Parse * pParse,	/* Parse context */
 		default:
 			pStep->op = TK_UPDATE;
 		}
-		pStep->pTrig = pTrigger;
-		pFKey->apTrigger[iAction] = pTrigger;
-		pTrigger->op = (pChanges ? TK_UPDATE : TK_DELETE);
+		pStep->trigger = trigger;
+		pFKey->apTrigger[iAction] = trigger;
+		trigger->op = pChanges ? TK_UPDATE : TK_DELETE;
 	}
 
-	return pTrigger;
+	return trigger;
 }
 
 /*
@@ -1460,23 +1469,20 @@ sqlite3FkActions(Parse * pParse,	/* Parse context */
 		     pFKey = pFKey->pNextTo) {
 			if (aChange == 0
 			    || fkParentIsModified(pTab, pFKey, aChange)) {
-				Trigger *pAct =
-				    fkActionTrigger(pParse, pTab, pFKey,
-						    pChanges);
-				if (pAct) {
-					sqlite3CodeRowTriggerDirect(pParse,
-								    pAct, pTab,
-								    regOld,
-								    ON_CONFLICT_ACTION_ABORT,
-								    0);
-				}
+				struct sql_trigger *pAct =
+					fkActionTrigger(pParse, pTab, pFKey,
+							pChanges);
+				if (pAct == NULL)
+					continue;
+				vdbe_code_row_trigger_direct(pParse, pAct, pTab,
+							     regOld,
+							     ON_CONFLICT_ACTION_ABORT,
+							     0);
 			}
 		}
 	}
 }
 
-#endif				/* ifndef SQLITE_OMIT_TRIGGER */
-
 /*
  * Free all memory associated with foreign key definitions attached to
  * table pTab. Remove the deleted foreign keys from the Schema.fkeyHash
@@ -1511,10 +1517,8 @@ sqlite3FkDelete(sqlite3 * db, Table * pTab)
 		assert(pFKey->isDeferred == 0 || pFKey->isDeferred == 1);
 
 		/* Delete any triggers created to implement actions for this FK. */
-#ifndef SQLITE_OMIT_TRIGGER
-		fkTriggerDelete(db, pFKey->apTrigger[0]);
-		fkTriggerDelete(db, pFKey->apTrigger[1]);
-#endif
+		sql_fk_trigger_delete(db, pFKey->apTrigger[0]);
+		sql_fk_trigger_delete(db, pFKey->apTrigger[1]);
 
 		pNext = pFKey->pNextFrom;
 		sqlite3DbFree(db, pFKey);
diff --git a/src/box/sql/insert.c b/src/box/sql/insert.c
index db8165a..dac6965 100644
--- a/src/box/sql/insert.c
+++ b/src/box/sql/insert.c
@@ -357,7 +357,8 @@ sqlite3Insert(Parse * pParse,	/* Parser context */
 	int regData;		/* register holding first column to insert */
 	int *aRegIdx = 0;	/* One register allocated to each index */
 	uint32_t space_id = 0;
-	Trigger *pTrigger;	/* List of triggers on pTab, if required */
+	/* List of triggers on pTab, if required. */
+	struct sql_trigger *trigger;
 	int tmask;		/* Mask of trigger times */
 
 	db = pParse->db;
@@ -393,9 +394,10 @@ sqlite3Insert(Parse * pParse,	/* Parser context */
 	/* Figure out if we have any triggers and if the table being
 	 * inserted into is a view
 	 */
-	pTrigger = sqlite3TriggersExist(pTab, TK_INSERT, 0, &tmask);
+	trigger = sql_triggers_exist(pTab, TK_INSERT, NULL, &tmask);
 	bool is_view = pTab->def->opts.is_view;
-	assert((pTrigger && tmask) || (pTrigger == 0 && tmask == 0));
+	assert((trigger != NULL && tmask != 0) ||
+	       (trigger == NULL && tmask == 0));
 
 	/* If pTab is really a view, make sure it has been initialized.
 	 * ViewGetColumnNames() is a no-op if pTab is not a view.
@@ -419,7 +421,7 @@ sqlite3Insert(Parse * pParse,	/* Parser context */
 		goto insert_cleanup;
 	if (pParse->nested == 0)
 		sqlite3VdbeCountChanges(v);
-	sql_set_multi_write(pParse, pSelect || pTrigger);
+	sql_set_multi_write(pParse, pSelect != NULL || trigger != NULL);
 
 #ifndef SQLITE_OMIT_XFER_OPT
 	/* If the statement is of the form
@@ -432,7 +434,7 @@ sqlite3Insert(Parse * pParse,	/* Parser context */
 	 * This is the 2nd template.
 	 */
 	if (pColumn == 0 && xferOptimization(pParse, pTab, pSelect, on_error)) {
-		assert(!pTrigger);
+		assert(trigger == NULL);
 		assert(pList == 0);
 		goto insert_end;
 	}
@@ -536,9 +538,8 @@ sqlite3Insert(Parse * pParse,	/* Parser context */
 		 * of the tables being read by the SELECT statement.  Also use a
 		 * temp table in the case of row triggers.
 		 */
-		if (pTrigger || readsTable(pParse, pTab)) {
+		if (trigger != NULL || readsTable(pParse, pTab))
 			useTempTable = 1;
-		}
 
 		if (useTempTable) {
 			/* Invoke the coroutine to extract information from the SELECT
@@ -731,7 +732,7 @@ sqlite3Insert(Parse * pParse,	/* Parser context */
 		}
 
 		/* Fire BEFORE or INSTEAD OF triggers */
-		sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0,
+		vdbe_code_row_trigger(pParse, trigger, TK_INSERT, 0,
 				      TRIGGER_BEFORE, pTab,
 				      regCols - def->field_count - 1, on_error,
 				      endOfLoop);
@@ -880,9 +881,9 @@ sqlite3Insert(Parse * pParse,	/* Parser context */
 		sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
 	}
 
-	if (pTrigger) {
+	if (trigger != NULL) {
 		/* Code AFTER triggers */
-		sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0,
+		vdbe_code_row_trigger(pParse, trigger, TK_INSERT, 0,
 				      TRIGGER_AFTER, pTab,
 				      regData - 2 - def->field_count, on_error,
 				      endOfLoop);
@@ -1360,9 +1361,8 @@ sqlite3GenerateConstraintChecks(Parse * pParse,		/* The parser context */
 		bool no_delete_triggers =
 			(0 == (user_session->sql_flags &
 			       SQLITE_RecTriggers) ||
-			 0 == sqlite3TriggersExist(pTab,
-						   TK_DELETE,
-						   0, 0));
+			 sql_triggers_exist(pTab, TK_DELETE, NULL, NULL) ==
+			 NULL);
 		bool no_foreign_keys =
 			(0 == (user_session->sql_flags &
 			       SQLITE_ForeignKeys) ||
@@ -1473,15 +1473,14 @@ sqlite3GenerateConstraintChecks(Parse * pParse,		/* The parser context */
 			sqlite3VdbeGoto(v, ignoreDest);
 			break;
 		default: {
-			Trigger *pTrigger = NULL;
+			struct sql_trigger *trigger = NULL;
 			assert(on_error == ON_CONFLICT_ACTION_REPLACE);
 			sql_set_multi_write(pParse, true);
-			if (user_session->
-			    sql_flags & SQLITE_RecTriggers) {
-				pTrigger = sqlite3TriggersExist(pTab, TK_DELETE,
-								NULL, NULL);
+			if (user_session->sql_flags & SQLITE_RecTriggers) {
+				trigger = sql_triggers_exist(pTab, TK_DELETE,
+							      NULL, NULL);
 			}
-			sql_generate_row_delete(pParse, pTab, pTrigger,
+			sql_generate_row_delete(pParse, pTab, trigger,
 						iDataCur, regR, nPkField, false,
 						ON_CONFLICT_ACTION_REPLACE,
 						pIdx == pPk ? ONEPASS_SINGLE :
diff --git a/src/box/sql/parse.y b/src/box/sql/parse.y
index ccd9d02..91bdc6e 100644
--- a/src/box/sql/parse.y
+++ b/src/box/sql/parse.y
@@ -1300,20 +1300,18 @@ plus_num(A) ::= number(A).
 minus_num(A) ::= MINUS number(X).     {A = X;}
 //////////////////////////// The CREATE TRIGGER command /////////////////////
 
-%ifndef SQLITE_OMIT_TRIGGER
-
 cmd ::= createkw trigger_decl(A) BEGIN trigger_cmd_list(S) END(Z). {
   Token all;
   all.z = A.z;
   all.n = (int)(Z.z - A.z) + Z.n;
   pParse->initiateTTrans = false;
-  sqlite3FinishTrigger(pParse, S, &all);
+  sql_trigger_finish(pParse, S, &all);
 }
 
 trigger_decl(A) ::= TRIGGER ifnotexists(NOERR) nm(B)
                     trigger_time(C) trigger_event(D)
                     ON fullname(E) foreach_clause when_clause(G). {
-  sqlite3BeginTrigger(pParse, &B, C, D.a, D.b, E, G, NOERR);
+  sql_trigger_begin(pParse, &B, C, D.a, D.b, E, G, NOERR);
   A = B; /*A-overwrites-T*/
 }
 
@@ -1414,7 +1412,6 @@ expr(A) ::= RAISE(X) LP raisetype(T) COMMA STRING(Z) RP(Y).  {
     A.pExpr->affinity = (char)T;
   }
 }
-%endif  !SQLITE_OMIT_TRIGGER
 
 %type raisetype {int}
 raisetype(A) ::= ROLLBACK.  {A = ON_CONFLICT_ACTION_ROLLBACK;}
@@ -1423,11 +1420,9 @@ raisetype(A) ::= FAIL.      {A = ON_CONFLICT_ACTION_FAIL;}
 
 
 ////////////////////////  DROP TRIGGER statement //////////////////////////////
-%ifndef SQLITE_OMIT_TRIGGER
 cmd ::= DROP TRIGGER ifexists(NOERR) fullname(X). {
   sqlite3DropTrigger(pParse,X,NOERR);
 }
-%endif  !SQLITE_OMIT_TRIGGER
 
 ////////////////////////// REINDEX collation //////////////////////////////////
 /* gh-2174: Commended until REINDEX is implemented in scope of gh-3195 */
diff --git a/src/box/sql/pragma.c b/src/box/sql/pragma.c
index 5fb29c7..be6a01c 100644
--- a/src/box/sql/pragma.c
+++ b/src/box/sql/pragma.c
@@ -583,7 +583,6 @@ sqlite3Pragma(Parse * pParse, Token * pId,	/* First part of [schema.]id field */
 #endif				/* !defined(SQLITE_OMIT_FOREIGN_KEY) */
 
 #ifndef SQLITE_OMIT_FOREIGN_KEY
-#ifndef SQLITE_OMIT_TRIGGER
 	case PragTyp_FOREIGN_KEY_CHECK:{
 			FKey *pFK;	/* A foreign key constraint */
 			Table *pTab;	/* Child table contain "REFERENCES"
@@ -755,7 +754,6 @@ sqlite3Pragma(Parse * pParse, Token * pId,	/* First part of [schema.]id field */
 			}
 			break;
 		}
-#endif				/* !defined(SQLITE_OMIT_TRIGGER) */
 #endif				/* !defined(SQLITE_OMIT_FOREIGN_KEY) */
 
 #ifndef NDEBUG
diff --git a/src/box/sql/pragma.h b/src/box/sql/pragma.h
index f966018..06b7eea 100644
--- a/src/box/sql/pragma.h
+++ b/src/box/sql/pragma.h
@@ -126,7 +126,7 @@ static const PragmaName aPragmaName[] = {
 	 /* iArg:      */ SQLITE_CountRows},
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
-#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
+#if !defined(SQLITE_OMIT_FOREIGN_KEY)
 	{ /* zName:     */ "defer_foreign_keys",
 	 /* ePragTyp:  */ PragTyp_FLAG,
 	 /* ePragFlg:  */ PragFlg_Result0 | PragFlg_NoColumns1,
@@ -134,7 +134,7 @@ static const PragmaName aPragmaName[] = {
 	 /* iArg:      */ SQLITE_DeferFKs},
 #endif
 #endif
-#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
+#if !defined(SQLITE_OMIT_FOREIGN_KEY)
 	{ /* zName:     */ "foreign_key_check",
 	 /* ePragTyp:  */ PragTyp_FOREIGN_KEY_CHECK,
 	 /* ePragFlg:  */ PragFlg_NeedSchema,
@@ -150,7 +150,7 @@ static const PragmaName aPragmaName[] = {
 	 /* iArg:      */ 0},
 #endif
 #if !defined(SQLITE_OMIT_FLAG_PRAGMAS)
-#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
+#if !defined(SQLITE_OMIT_FOREIGN_KEY)
 	{ /* zName:     */ "foreign_keys",
 	 /* ePragTyp:  */ PragTyp_FLAG,
 	 /* ePragFlg:  */ PragFlg_Result0 | PragFlg_NoColumns1,
diff --git a/src/box/sql/resolve.c b/src/box/sql/resolve.c
index 23e1618..10c717f 100644
--- a/src/box/sql/resolve.c
+++ b/src/box/sql/resolve.c
@@ -309,7 +309,6 @@ lookupName(Parse * pParse,	/* The parsing context */
 			}
 		}
 		/* if( pSrcList ) */
-#ifndef SQLITE_OMIT_TRIGGER
 		/* If we have not already resolved the name, then maybe
 		 * it is a new.* or old.* trigger argument reference
 		 */
@@ -369,7 +368,6 @@ lookupName(Parse * pParse,	/* The parsing context */
 				}
 			}
 		}
-#endif				/* !defined(SQLITE_OMIT_TRIGGER) */
 
 		/*
 		 * If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z
diff --git a/src/box/sql/select.c b/src/box/sql/select.c
index 368bcd6..4e61ec1 100644
--- a/src/box/sql/select.c
+++ b/src/box/sql/select.c
@@ -1270,7 +1270,6 @@ selectInnerLoop(Parse * pParse,		/* The parser context */
 		}
 #endif				/* SQLITE_OMIT_CTE */
 
-#if !defined(SQLITE_OMIT_TRIGGER)
 		/* Discard the results.  This is used for SELECT statements inside
 		 * the body of a TRIGGER.  The purpose of such selects is to call
 		 * user-defined functions that have side effects.  We do not care
@@ -1280,7 +1279,6 @@ selectInnerLoop(Parse * pParse,		/* The parser context */
 			assert(eDest == SRT_Discard);
 			break;
 		}
-#endif
 	}
 
 	/* Jump to the end of the loop if the LIMIT is reached.  Except, if
diff --git a/src/box/sql/sqliteInt.h b/src/box/sql/sqliteInt.h
index d5e3263..aa7d48e 100644
--- a/src/box/sql/sqliteInt.h
+++ b/src/box/sql/sqliteInt.h
@@ -1493,7 +1493,6 @@ typedef struct StrAccum StrAccum;
 typedef struct Table Table;
 typedef struct Token Token;
 typedef struct TreeView TreeView;
-typedef struct Trigger Trigger;
 typedef struct TriggerPrg TriggerPrg;
 typedef struct TriggerStep TriggerStep;
 typedef struct UnpackedRecord UnpackedRecord;
@@ -1994,7 +1993,8 @@ struct FKey {
 	/* EV: R-30323-21917 */
 	u8 isDeferred;		/* True if constraint checking is deferred till COMMIT */
 	u8 aAction[2];		/* ON DELETE and ON UPDATE actions, respectively */
-	Trigger *apTrigger[2];	/* Triggers for aAction[] actions */
+	/** Triggers for aAction[] actions. */
+	struct sql_trigger *apTrigger[2];
 	struct sColMap {	/* Mapping of columns in pFrom to columns in zTo */
 		int iFrom;	/* Index of column in pFrom */
 		char *zCol;	/* Name of column in zTo.  If NULL use PRIMARY KEY */
@@ -2842,7 +2842,8 @@ struct SelectDest {
  * a mask of new.* columns used by the program.
  */
 struct TriggerPrg {
-	Trigger *pTrigger;	/* Trigger this program was coded from */
+	/** Trigger this program was coded from. */
+	struct sql_trigger *trigger;
 	TriggerPrg *pNext;	/* Next entry in Parse.pTriggerPrg list */
 	SubProgram *pProgram;	/* Program implementing pTrigger/orconf */
 	int orconf;		/* Default ON CONFLICT policy */
@@ -2965,7 +2966,7 @@ struct Parse {
 	union {
 		struct Expr *expr;
 		struct Select *select;
-		struct Trigger *trigger;
+		struct sql_trigger *trigger;
 	} parsed_ast;
 };
 
@@ -3018,21 +3019,23 @@ struct Parse {
 					 */
 
 /*
- * Each trigger present in the database schema is stored as an instance of
- * struct Trigger.
+ * Each trigger present in the database schema is stored as an
+ * instance of struct sql_trigger.
  *
  * Pointers to instances of struct Trigger are stored in two ways.
- * 1. In the "trigHash" hash table (part of the sqlite3* that represents the
- *    database). This allows Trigger structures to be retrieved by name.
- * 2. All triggers associated with a single table form a linked list, using the
- *    pNext member of struct Trigger. A pointer to the first element of the
- *    linked list is stored as the "pTrigger" member of the associated
- *    struct Table.
- *
- * The "step_list" member points to the first element of a linked list
- * containing the SQL statements specified as the trigger program.
- */
-struct Trigger {
+ * 1. In the "trigHash" hash table (part of the sqlite3* that
+ *    represents the database). This allows Trigger structures to
+ *    be retrieved by name.
+ * 2. All triggers associated with a single table form a linked
+ *    list, using the next member of struct sql_trigger. A pointer
+ *    to the first element of the linked list is stored as the
+ *    "pTrigger" member of the associated struct Table.
+ *
+ * The "step_list" member points to the first element of a linked
+ * list containing the SQL statements specified as the trigger
+ * program.
+ */
+struct sql_trigger {
 	char *zName;		/* The name of the trigger                        */
 	/** The ID of space the trigger refers to. */
 	uint32_t space_id;
@@ -3042,7 +3045,8 @@ struct Trigger {
 	IdList *pColumns;	/* If this is an UPDATE OF <column-list> trigger,
 				   the <column-list> is stored here */
 	TriggerStep *step_list;	/* Link list of trigger program steps             */
-	Trigger *pNext;		/* Next trigger associated with the table */
+	/** Next trigger associated with the table. */
+	struct sql_trigger *next;
 };
 
 /*
@@ -3096,7 +3100,8 @@ struct Trigger {
 struct TriggerStep {
 	u8 op;			/* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */
 	u8 orconf;		/* ON_CONFLICT_ACTION_ROLLBACK etc. */
-	Trigger *pTrig;		/* The trigger that this step is a part of */
+	/** The trigger that this step is a part of */
+	struct sql_trigger *trigger;
 	Select *pSelect;	/* SELECT statement or RHS of INSERT INTO SELECT ... */
 	char *zTarget;		/* Target table for DELETE, UPDATE, INSERT */
 	Expr *pWhere;		/* The WHERE clause for DELETE or UPDATE steps */
@@ -3933,8 +3938,8 @@ int sqlite3ExprNeedsNoAffinityChange(const Expr *, char);
  */
 void
 sql_generate_row_delete(struct Parse *parse, struct Table *table,
-			struct Trigger *trigger_list, int cursor, int reg_pk,
-			short npk, bool need_update_count,
+			struct sql_trigger *trigger_list, int cursor,
+			int reg_pk, short npk, bool need_update_count,
 			enum on_conflict_action onconf, u8 mode,
 			int idx_noseek);
 
@@ -4064,17 +4069,143 @@ void
 sql_materialize_view(struct Parse *parse, const char *name, struct Expr *where,
 		     int cursor);
 
-#ifndef SQLITE_OMIT_TRIGGER
-void sqlite3BeginTrigger(Parse *, Token *, int, int, IdList *, SrcList *,
-			 Expr *, int);
-void sqlite3FinishTrigger(Parse *, TriggerStep *, Token *);
+/**
+ * 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 sql_trigger structure is generated based on the
+ * information available and stored in parse->parsed_ast.trigger.
+ * After the trigger actions have been parsed, the
+ * sql_trigger_finish() function is called to complete the trigger
+ * construction process.
+ *
+ * @param parse The parse context of the CREATE TRIGGER statement.
+ * @param name The name of the trigger.
+ * @param tr_tm One of TK_BEFORE, TK_AFTER, TK_INSTEAD.
+ * @param op One of TK_INSERT, TK_UPDATE, TK_DELETE.
+ * @param columns column list if this is an UPDATE OF trigger.
+ * @param table The name of the table/view the trigger applies to.
+ * @param when  WHEN clause.
+ * @param no_err Suppress errors if the trigger already exists.
+ */
+void
+sql_trigger_begin(struct Parse *parse, struct Token *name, int tr_tm,
+		  int op, struct IdList *columns, struct SrcList *table,
+		  struct Expr *when, int no_err);
+
+/**
+ * This routine is called after all of the trigger actions have
+ * been parsed in order to complete the process of building the
+ * trigger.
+ *
+ * @param parse Parser context.
+ * @param step_list The triggered program.
+ * @param token Token that describes the complete CREATE TRIGGER.
+ */
+void sql_trigger_finish(Parse *, TriggerStep *, Token *);
+
 void sqlite3DropTrigger(Parse *, SrcList *, int);
-void sqlite3DropTriggerPtr(Parse *, Trigger *);
-Trigger *sqlite3TriggersExist(Table *, int, ExprList *, int *pMask);
-void sqlite3CodeRowTrigger(Parse *, Trigger *, int, ExprList *, int, Table *,
-			   int, int, int);
-void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *, int, int, int);
-void sqliteViewTriggers(Parse *, Table *, Expr *, int, ExprList *);
+
+/**
+ * Drop a trigger given a pointer to that trigger.
+ *
+ * @param parser Parse context.
+ * @param trigger Trigger to drop.
+ */
+void
+vdbe_code_drop_trigger_ptr(struct Parse *parser, struct sql_trigger *trigger);
+
+/**
+ * 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 changes_list is being
+ * modified.
+ *
+ * @param table The table the contains the triggers.
+ * @param op operation one of TK_DELETE, TK_INSERT, TK_UPDATE.
+ * @param changes_list Columns that change in an UPDATE statement.
+ * @param[out] pMask Mask of TRIGGER_BEFORE|TRIGGER_AFTER
+ */
+struct sql_trigger *
+sql_triggers_exist(struct Table *table, int op, struct ExprList *changes_list,
+		   int *mask_ptr);
+
+/**
+ * This is called to code the required FOR EACH ROW triggers for
+ * an operation on table. The operation to code triggers for
+ * (INSERT, UPDATE or DELETE) is given by the op parameter. The
+ * tr_tm parameter determines whether the BEFORE or AFTER triggers
+ * are coded. If the operation is an UPDATE, then parameter
+ * changes_list is passed the list of columns being modified.
+ *
+ * If there are no triggers that fire at the specified time for
+ * the specified operation on table, 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 table, then registers are populated as
+ * follows:
+ *
+ *   Register       Contains
+ *   ------------------------------------------------------
+ *   reg+0          OLD.PK
+ *   reg+1          OLD.* value of left-most column of pTab
+ *   ...            ...
+ *   reg+N          OLD.* value of right-most column of pTab
+ *   reg+N+1        NEW.PK
+ *   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.
+ *
+ * @param parser Parse context.
+ * @param trigger List of triggers on table.
+ * @param op operation, one of TK_UPDATE, TK_INSERT, TK_DELETE.
+ * @param changes_list Changes list for any UPDATE OF triggers.
+ * @param tr_tm One of TRIGGER_BEFORE, TRIGGER_AFTER.
+ * @param table The table to code triggers from.
+ * @param reg The first in an array of registers.
+ * @param orconf ON CONFLICT policy.
+ * @param ignore_jump Instruction to jump to for RAISE(IGNORE).
+ */
+void
+vdbe_code_row_trigger(struct Parse *parser, struct sql_trigger *trigger,
+		      int op, struct ExprList *changes_list, int tr_tm,
+		      struct Table *table, int reg, int orconf, int ignore_jump);
+
+/**
+ * Generate code for the trigger program associated with trigger
+ * p on table table. The reg, orconf and ignoreJump parameters
+ * passed to this function are the same as those described in the
+ * header function for sql_code_row_trigger().
+ *
+ * @param parser Parse context.
+ * @param trigger Trigger to code.
+ * @param table The table to code triggers from.
+ * @param reg Reg array containing OLD.* and NEW.* values.
+ * @param orconf ON CONFLICT policy.
+ * @param ignore_jump Instruction to jump to for RAISE(IGNORE).
+ */
+void
+vdbe_code_row_trigger_direct(struct Parse *parser, struct sql_trigger *trigger,
+			     struct Table *table, int reg, int orconf,
+			     int ignore_jump);
+
 void sqlite3DeleteTriggerStep(sqlite3 *, TriggerStep *);
 TriggerStep *sqlite3TriggerSelectStep(sqlite3 *, Select *);
 TriggerStep *sqlite3TriggerInsertStep(sqlite3 *, Token *, IdList *,
@@ -4082,21 +4213,53 @@ TriggerStep *sqlite3TriggerInsertStep(sqlite3 *, Token *, IdList *,
 TriggerStep *sqlite3TriggerUpdateStep(sqlite3 *, Token *, ExprList *, Expr *,
 				      u8);
 TriggerStep *sqlite3TriggerDeleteStep(sqlite3 *, Token *, Expr *);
-u32 sqlite3TriggerColmask(Parse *, Trigger *, ExprList *, int, int, Table *,
-			  int);
+
+/**
+ * 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.PK or new.PK 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.
+ *
+ * @param parser  Parse context.
+ * @param trigger List of triggers on table.
+ * @param changes_list Changes list for any UPDATE OF triggers.
+ * @param new  1 for new.* ref mask, 0 for old.* ref mask.
+ * @param tr_tm Mask of TRIGGER_BEFORE|TRIGGER_AFTER.
+ * @param table The table to code triggers from.
+ * @param orconf Default ON CONFLICT policy for trigger steps.
+ *
+ * @retval mask value.
+ */
+u32
+sql_trigger_colmask(Parse *parser, struct sql_trigger *trigger,
+		    ExprList *changes_list, int new, int tr_tm,
+		    Table *table, int orconf);
 #define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p))
 #define sqlite3IsToplevel(p) ((p)->pToplevel==0)
-#else
-#define sqlite3TriggersExist(C,D,E,F) 0
-#define sql_trigger_delete(A,B)
-#define sqlite3DropTriggerPtr(A,B)
-#define sqlite3UnlinkAndDeleteTrigger(A,B,C)
-#define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I)
-#define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F)
-#define sqlite3ParseToplevel(p) p
-#define sqlite3IsToplevel(p) 1
-#define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0
-#endif
 
 int sqlite3JoinType(Parse *, Token *, Token *, Token *);
 void sqlite3CreateForeignKey(Parse *, ExprList *, Token *, ExprList *, int);
@@ -4465,7 +4628,7 @@ void sqlite3WithPush(Parse *, With *, u8);
  * this case foreign keys are parsed, but no other functionality is
  * provided (enforcement of FK constraints requires the triggers sub-system).
  */
-#if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
+#if !defined(SQLITE_OMIT_FOREIGN_KEY)
 void sqlite3FkCheck(Parse *, Table *, int, int, int *);
 void sqlite3FkDropTable(Parse *, SrcList *, Table *);
 void sqlite3FkActions(Parse *, Table *, ExprList *, int, int *);
diff --git a/src/box/sql/status.c b/src/box/sql/status.c
index dda91c5..161136c 100644
--- a/src/box/sql/status.c
+++ b/src/box/sql/status.c
@@ -257,7 +257,7 @@ sqlite3_db_status(sqlite3 * db,	/* The database connection whose status is desir
 				for (p = sqliteHashFirst(&pSchema->trigHash); p;
 				     p = sqliteHashNext(p)) {
 					sql_trigger_delete(db,
-							   (Trigger *)
+							   (struct sql_trigger *)
 							   sqliteHashData(p));
 				}
 				for (p = sqliteHashFirst(&pSchema->tblHash); p;
diff --git a/src/box/sql/tokenize.c b/src/box/sql/tokenize.c
index edcc45b..7c3dabe 100644
--- a/src/box/sql/tokenize.c
+++ b/src/box/sql/tokenize.c
@@ -597,14 +597,14 @@ sql_view_compile(struct sqlite3 *db, const char *view_stmt)
 	return select;
 }
 
-struct Trigger *
+struct sql_trigger *
 sql_trigger_compile(struct sqlite3 *db, const char *sql)
 {
 	struct Parse parser;
 	sql_parser_create(&parser, db);
 	parser.parse_only = true;
 	char *sql_error;
-	struct Trigger *trigger = NULL;
+	struct sql_trigger *trigger = NULL;
 	if (sqlite3RunParser(&parser, sql, &sql_error) != SQLITE_OK ||
 	    parser.parsed_ast_type != AST_TYPE_TRIGGER) {
 	    if (parser.rc != SQL_TARANTOOL_ERROR)
diff --git a/src/box/sql/treeview.c b/src/box/sql/treeview.c
index 84d839e..4261e73 100644
--- a/src/box/sql/treeview.c
+++ b/src/box/sql/treeview.c
@@ -565,7 +565,6 @@ sqlite3TreeViewExpr(TreeView * pView, const Expr * pExpr, u8 moreToFollow)
 			sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
 			break;
 		}
-#ifndef SQLITE_OMIT_TRIGGER
 	case TK_RAISE:{
 			const char *zType = "unk";
 			switch (pExpr->affinity) {
@@ -586,7 +585,6 @@ sqlite3TreeViewExpr(TreeView * pView, const Expr * pExpr, u8 moreToFollow)
 					    pExpr->u.zToken);
 			break;
 		}
-#endif
 	case TK_MATCH:{
 			sqlite3TreeViewLine(pView, "MATCH {%d:%d}%s",
 					    pExpr->iTable, pExpr->iColumn,
diff --git a/src/box/sql/trigger.c b/src/box/sql/trigger.c
index 3ec77c7..b23827d 100644
--- a/src/box/sql/trigger.c
+++ b/src/box/sql/trigger.c
@@ -42,7 +42,6 @@
 /* See comment in sqliteInt.h */
 int sqlSubProgramsRemaining;
 
-#ifndef SQLITE_OMIT_TRIGGER
 /*
  * Delete a linked list of TriggerStep structures.
  */
@@ -62,46 +61,36 @@ sqlite3DeleteTriggerStep(sqlite3 * db, TriggerStep * pTriggerStep)
 	}
 }
 
-/*
- * 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.
- */
 void
-sqlite3BeginTrigger(Parse * pParse,	/* The parse context of the CREATE TRIGGER statement */
-		    Token * pName,	/* 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 noErr	/* Suppress errors if the trigger already exists */
-    )
+sql_trigger_begin(struct Parse *parse, struct Token *name, int tr_tm,
+		  int op, struct IdList *columns, struct SrcList *table,
+		  struct Expr *when, int no_err)
 {
-	Trigger *pTrigger = 0;	/* The new trigger */
-	char *zName = 0;	/* Name of the trigger */
-	sqlite3 *db = pParse->db;	/* The database connection */
-	DbFixer sFix;		/* State vector for the DB fixer */
+	/* The new trigger. */
+	struct sql_trigger *trigger = NULL;
+	/* The database connection. */
+	struct sqlite3 *db = parse->db;
+	/* State vector for the DB fixer. */
+	struct DbFixer fixdb;
+	/* The name of the Trigger. */
+	char *trigger_name = NULL;
 
 	/*
 	 * Do not account nested operations: the count of such
 	 * operations depends on Tarantool data dictionary
 	 * internals, such as data layout in system spaces.
 	 */
-	if (!pParse->nested) {
-		Vdbe *v = sqlite3GetVdbe(pParse);
+	if (!parse->nested) {
+		struct Vdbe *v = sqlite3GetVdbe(parse);
 		if (v != NULL)
 			sqlite3VdbeCountChanges(v);
 	}
 	/* pName->z might be NULL, but not pName itself. */
-	assert(pName != NULL);
+	assert(name != NULL);
 	assert(op == TK_INSERT || op == TK_UPDATE || op == TK_DELETE);
 	assert(op > 0 && op < 0xff);
 
-	if (pTableName == NULL || db->mallocFailed)
+	if (table == NULL || db->mallocFailed)
 		goto trigger_cleanup;
 
 	/*
@@ -110,31 +99,31 @@ sqlite3BeginTrigger(Parse * pParse,	/* The parse context of the CREATE TRIGGER s
 	 */
 	if (db->mallocFailed)
 		goto trigger_cleanup;
-	assert(pTableName->nSrc == 1);
-	sqlite3FixInit(&sFix, pParse, "trigger", pName);
-	if (sqlite3FixSrcList(&sFix, pTableName) != 0)
+	assert(table->nSrc == 1);
+	sqlite3FixInit(&fixdb, parse, "trigger", name);
+	if (sqlite3FixSrcList(&fixdb, table) != 0)
 		goto trigger_cleanup;
 
-	zName = sqlite3NameFromToken(db, pName);
-	if (zName == NULL)
+	trigger_name = sqlite3NameFromToken(db, name);
+	if (trigger_name == NULL)
 		goto trigger_cleanup;
 
-	if (sqlite3CheckIdentifierName(pParse, zName) != SQLITE_OK)
+	if (sqlite3CheckIdentifierName(parse, trigger_name) != SQLITE_OK)
 		goto trigger_cleanup;
 
-	if (!pParse->parse_only &&
-	    sqlite3HashFind(&db->pSchema->trigHash, zName) != NULL) {
-		if (!noErr) {
-			diag_set(ClientError, ER_TRIGGER_EXISTS, zName);
-			pParse->rc = SQL_TARANTOOL_ERROR;
-			pParse->nErr++;
+	if (!parse->parse_only &&
+	    sqlite3HashFind(&db->pSchema->trigHash, trigger_name) != NULL) {
+		if (!no_err) {
+			diag_set(ClientError, ER_TRIGGER_EXISTS, trigger_name);
+			parse->rc = SQL_TARANTOOL_ERROR;
+			parse->nErr++;
 		} else {
 			assert(!db->init.busy);
 		}
 		goto trigger_cleanup;
 	}
 
-	const char *table_name = pTableName->a[0].zName;
+	const char *table_name = table->a[0].zName;
 	uint32_t space_id;
 	if (schema_find_id(BOX_SPACE_ID, 2, table_name, strlen(table_name),
 			   &space_id) != 0)
@@ -145,159 +134,161 @@ sqlite3BeginTrigger(Parse * pParse,	/* The parse context of the CREATE TRIGGER s
 	}
 
 	/* Build the Trigger object. */
-	pTrigger = (Trigger *)sqlite3DbMallocZero(db, sizeof(Trigger));
-	if (pTrigger == NULL)
+	trigger = (struct sql_trigger *)sqlite3DbMallocZero(db,
+							    sizeof(struct
+								   sql_trigger));
+	if (trigger == NULL)
 		goto trigger_cleanup;
-	pTrigger->space_id = space_id;
-	pTrigger->zName = zName;
-	zName = NULL;
-
-	pTrigger->op = (u8) op;
-	pTrigger->tr_tm = tr_tm;
-	pTrigger->pWhen = sqlite3ExprDup(db, pWhen, EXPRDUP_REDUCE);
-	pTrigger->pColumns = sqlite3IdListDup(db, pColumns);
-	if ((pWhen != NULL && pTrigger->pWhen == NULL) ||
-	    (pColumns != NULL && pTrigger->pColumns == NULL))
+	trigger->space_id = space_id;
+	trigger->zName = trigger_name;
+	trigger_name = NULL;
+
+	trigger->op = (u8) op;
+	trigger->tr_tm = tr_tm;
+	trigger->pWhen = sqlite3ExprDup(db, when, EXPRDUP_REDUCE);
+	trigger->pColumns = sqlite3IdListDup(db, columns);
+	if ((when != NULL && trigger->pWhen == NULL) ||
+	    (columns != NULL && trigger->pColumns == NULL))
 		goto trigger_cleanup;
-	assert(pParse->parsed_ast.trigger == NULL);
-	pParse->parsed_ast.trigger = pTrigger;
-	pParse->parsed_ast_type = AST_TYPE_TRIGGER;
+	assert(parse->parsed_ast.trigger == NULL);
+	parse->parsed_ast.trigger = trigger;
+	parse->parsed_ast_type = AST_TYPE_TRIGGER;
 
  trigger_cleanup:
-	sqlite3DbFree(db, zName);
-	sqlite3SrcListDelete(db, pTableName);
-	sqlite3IdListDelete(db, pColumns);
-	sql_expr_delete(db, pWhen, false);
-	if (pParse->parsed_ast.trigger == NULL)
-		sql_trigger_delete(db, pTrigger);
+	sqlite3DbFree(db, trigger_name);
+	sqlite3SrcListDelete(db, table);
+	sqlite3IdListDelete(db, columns);
+	sql_expr_delete(db, when, false);
+	if (parse->parsed_ast.trigger == NULL)
+		sql_trigger_delete(db, trigger);
 	else
-		assert(pParse->parsed_ast.trigger == pTrigger);
+		assert(parse->parsed_ast.trigger == trigger);
 
 	return;
 
 set_tarantool_error_and_cleanup:
-	pParse->rc = SQL_TARANTOOL_ERROR;
-	pParse->nErr++;
+	parse->rc = SQL_TARANTOOL_ERROR;
+	parse->nErr++;
 	goto trigger_cleanup;
 }
 
-/*
- * This routine is called after all of the trigger actions have been parsed
- * in order to complete the process of building the trigger.
- */
 void
-sqlite3FinishTrigger(Parse * pParse,	/* Parser context */
-		     TriggerStep * pStepList,	/* The triggered program */
-		     Token * pAll	/* Token that describes the complete CREATE TRIGGER */
-    )
+sql_trigger_finish(struct Parse *parse, struct TriggerStep *step_list,
+		   struct Token *token)
 {
 	/* Trigger being finished. */
-	Trigger *pTrig = pParse->parsed_ast.trigger;
-	char *zName;		/* Name of trigger */
-	char *zSql = 0;		/* SQL text */
-	char *zOpts = 0;	/* MsgPack containing SQL options */
-	sqlite3 *db = pParse->db;	/* The database */
-	DbFixer sFix;		/* Fixer object */
-	Token nameToken;	/* Trigger name for error reporting */
-
-	pParse->parsed_ast.trigger = NULL;
-	if (NEVER(pParse->nErr) || !pTrig)
+	struct sql_trigger *trigger = parse->parsed_ast.trigger;
+	/* Name of trigger. */
+	char *trigger_name;
+	/* SQL text. */
+	char *sql_str = NULL;
+	/* MsgPack containing SQL options. */
+	char *opts_buff = NULL;
+	/* The database. */
+	struct sqlite3 *db = parse->db;
+
+	parse->parsed_ast.trigger = NULL;
+	if (NEVER(parse->nErr) || trigger == NULL)
 		goto triggerfinish_cleanup;
-	zName = pTrig->zName;
-	pTrig->step_list = pStepList;
-	while (pStepList) {
-		pStepList->pTrig = pTrig;
-		pStepList = pStepList->pNext;
+	trigger_name = trigger->zName;
+	trigger->step_list = step_list;
+	while (step_list != NULL) {
+		step_list->trigger = trigger;
+		step_list = step_list->pNext;
 	}
-	sqlite3TokenInit(&nameToken, pTrig->zName);
-	sqlite3FixInit(&sFix, pParse, "trigger", &nameToken);
-	if (sqlite3FixTriggerStep(&sFix, pTrig->step_list)
-	    || sqlite3FixExpr(&sFix, pTrig->pWhen)
-	    ) {
+
+	/* Trigger name for error reporting. */
+	struct Token trigger_name_token;
+	/* Fixer object. */
+	struct DbFixer fixdb;
+	sqlite3TokenInit(&trigger_name_token, trigger->zName);
+	sqlite3FixInit(&fixdb, parse, "trigger", &trigger_name_token);
+	if (sqlite3FixTriggerStep(&fixdb, trigger->step_list)
+	    || sqlite3FixExpr(&fixdb, trigger->pWhen))
 		goto triggerfinish_cleanup;
-	}
 
 	/*
 	 * Generate byte code to insert a new trigger into
 	 * Tarantool for non-parsing mode or export trigger.
 	 */
-	if (!pParse->parse_only) {
-		Vdbe *v;
-		int zOptsSz;
-		Table *pSysTrigger;
-		int iFirstCol;
-		int iCursor = pParse->nTab++;
-		int iRecord;
-
-		/* Make an entry in the _trigger space.  */
-		v = sqlite3GetVdbe(pParse);
+	if (!parse->parse_only) {
+		/* Make an entry in the _trigger space. */
+		struct Vdbe *v = sqlite3GetVdbe(parse);
 		if (v == 0)
 			goto triggerfinish_cleanup;
 
-		pSysTrigger = sqlite3HashFind(&pParse->db->pSchema->tblHash,
-					      TARANTOOL_SYS_TRIGGER_NAME);
-		if (NEVER(!pSysTrigger))
+		struct Table *sys_trigger =
+			sqlite3HashFind(&parse->db->pSchema->tblHash,
+					TARANTOOL_SYS_TRIGGER_NAME);
+		if (NEVER(sys_trigger == NULL))
 			goto triggerfinish_cleanup;
 
-		zSql = sqlite3MPrintf(db, "CREATE TRIGGER %s", pAll->z);
+		sql_str = sqlite3MPrintf(db, "CREATE TRIGGER %s", token->z);
 		if (db->mallocFailed)
 			goto triggerfinish_cleanup;
 
-		sqlite3OpenTable(pParse, iCursor, pSysTrigger, OP_OpenWrite);
+		int cursor = parse->nTab++;
+		sqlite3OpenTable(parse, cursor, sys_trigger, OP_OpenWrite);
 
-		/* makerecord(cursor(iRecord), [reg(iFirstCol), reg(iFirstCol+1)])  */
-		iFirstCol = pParse->nMem + 1;
-		pParse->nMem += 3;
-		iRecord = ++pParse->nMem;
+		/*
+		 * makerecord(cursor(iRecord),
+		 * [reg(first_col), reg(first_col+1)]).
+		 */
+		int first_col = parse->nMem + 1;
+		parse->nMem += 3;
+		int record = ++parse->nMem;
 
-		zOpts = sqlite3DbMallocRaw(pParse->db,
+		opts_buff =
+			sqlite3DbMallocRaw(parse->db,
 					   tarantoolSqlite3MakeTableOpts(0,
-									 zSql,
+									 sql_str,
 									 NULL) +
 					   1);
 		if (db->mallocFailed)
 			goto triggerfinish_cleanup;
 
-		zOptsSz = tarantoolSqlite3MakeTableOpts(0, zSql, zOpts);
+		int opts_buff_sz =
+			tarantoolSqlite3MakeTableOpts(0, sql_str, opts_buff);
 
-		zName = sqlite3DbStrDup(pParse->db, zName);
+		trigger_name = sqlite3DbStrDup(parse->db, trigger_name);
 		if (db->mallocFailed)
 			goto triggerfinish_cleanup;
 
 		sqlite3VdbeAddOp4(v,
-				  OP_String8, 0, iFirstCol, 0,
-				  zName, P4_DYNAMIC);
-		sqlite3VdbeAddOp2(v, OP_Integer, pTrig->space_id, iFirstCol + 1);
-		sqlite3VdbeAddOp4(v, OP_Blob, zOptsSz, iFirstCol + 2,
-				  MSGPACK_SUBTYPE, zOpts, P4_DYNAMIC);
-		sqlite3VdbeAddOp3(v, OP_MakeRecord, iFirstCol, 3, iRecord);
-		sqlite3VdbeAddOp2(v, OP_IdxInsert, iCursor, iRecord);
-		/* Do not account nested operations: the count of such
-		 * operations depends on Tarantool data dictionary internals,
-		 * such as data layout in system spaces.
+				  OP_String8, 0, first_col, 0,
+				  trigger_name, P4_DYNAMIC);
+		sqlite3VdbeAddOp2(v, OP_Integer, trigger->space_id,
+				  first_col + 1);
+		sqlite3VdbeAddOp4(v, OP_Blob, opts_buff_sz, first_col + 2,
+				  MSGPACK_SUBTYPE, opts_buff, P4_DYNAMIC);
+		sqlite3VdbeAddOp3(v, OP_MakeRecord, first_col, 3, record);
+		sqlite3VdbeAddOp2(v, OP_IdxInsert, cursor, record);
+		/*
+		 * Do not account nested operations: the count of
+		 * such operations depends on Tarantool data
+		 * dictionary internals, such as data layout in
+		 * system spaces.
 		 */
-		if (!pParse->nested)
+		if (!parse->nested)
 			sqlite3VdbeChangeP5(v, OPFLAG_NCHANGE);
-		sqlite3VdbeAddOp1(v, OP_Close, iCursor);
+		sqlite3VdbeAddOp1(v, OP_Close, cursor);
 
-		sql_set_multi_write(pParse, false);
-		sqlite3ChangeCookie(pParse);
+		sql_set_multi_write(parse, false);
+		sqlite3ChangeCookie(parse);
 	} else {
-		pParse->parsed_ast.trigger = pTrig;
-		pParse->parsed_ast_type = AST_TYPE_TRIGGER;
-		pTrig = NULL;
+		parse->parsed_ast.trigger = trigger;
+		parse->parsed_ast_type = AST_TYPE_TRIGGER;
+		trigger = NULL;
 	}
 
  triggerfinish_cleanup:
 	if (db->mallocFailed) {
-		sqlite3DbFree(db, zSql);
-		sqlite3DbFree(db, zOpts);
-		/* No need to free zName sinceif we reach this point
-		   alloc for it either wasn't called at all or failed.  */
+		sqlite3DbFree(db, sql_str);
+		sqlite3DbFree(db, opts_buff);
 	}
-	sql_trigger_delete(db, pTrig);
-	assert(pParse->parsed_ast.trigger == NULL || pParse->parse_only);
-	sqlite3DeleteTriggerStep(db, pStepList);
+	sql_trigger_delete(db, trigger);
+	assert(parse->parsed_ast.trigger == NULL || parse->parse_only);
+	sqlite3DeleteTriggerStep(db, step_list);
 }
 
 /*
@@ -439,7 +430,7 @@ sqlite3TriggerDeleteStep(sqlite3 * db,	/* Database connection */
 }
 
 void
-sql_trigger_delete(struct sqlite3 *db, struct Trigger *trigger)
+sql_trigger_delete(struct sqlite3 *db, struct sql_trigger *trigger)
 {
 	if (trigger == NULL)
 		return;
@@ -451,17 +442,18 @@ sql_trigger_delete(struct sqlite3 *db, struct Trigger *trigger)
 }
 
 /*
- * This function is called to drop a trigger from the database schema.
+ * 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.
+ * This may be called directly from the parser and therefore
+ * identifies the trigger by name.  The sql_drop_trigger_ptr()
+ * routine does the same job as this routine except it takes a
+ * pointer to the trigger instead of the trigger name.
  */
 void
 sqlite3DropTrigger(Parse * pParse, SrcList * pName, int noErr)
 {
-	Trigger *pTrigger = 0;
+	struct sql_trigger *trigger = NULL;
 	const char *zName;
 	sqlite3 *db = pParse->db;
 
@@ -483,8 +475,8 @@ sqlite3DropTrigger(Parse * pParse, SrcList * pName, int noErr)
 
 	assert(pName->nSrc == 1);
 	zName = pName->a[0].zName;
-	pTrigger = sqlite3HashFind(&(db->pSchema->trigHash), zName);
-	if (!pTrigger) {
+	trigger = sqlite3HashFind(&(db->pSchema->trigHash), zName);
+	if (trigger == NULL) {
 		if (!noErr) {
 			sqlite3ErrorMsg(pParse, "no such trigger: %S", pName,
 					0);
@@ -492,48 +484,47 @@ sqlite3DropTrigger(Parse * pParse, SrcList * pName, int noErr)
 		pParse->checkSchema = 1;
 		goto drop_trigger_cleanup;
 	}
-	sqlite3DropTriggerPtr(pParse, pTrigger);
+	vdbe_code_drop_trigger_ptr(pParse, trigger);
 
  drop_trigger_cleanup:
 	sqlite3SrcListDelete(db, pName);
 }
 
-/*
- * Drop a trigger given a pointer to that trigger.
- */
 void
-sqlite3DropTriggerPtr(Parse * pParse, Trigger * pTrigger)
+vdbe_code_drop_trigger_ptr(struct Parse *parser, struct sql_trigger *trigger)
 {
-	Vdbe *v;
-	/* Generate code to delete entry from _trigger and
+	struct Vdbe *v = sqlite3GetVdbe(parser);
+	if (v == NULL)
+		return;
+	/*
+	 * Generate code to delete entry from _trigger and
 	 * internal SQL structures.
 	 */
-	if ((v = sqlite3GetVdbe(pParse)) != 0) {
-		int trig_name_reg = ++pParse->nMem;
-		int record_to_delete = ++pParse->nMem;
-		sqlite3VdbeAddOp4(v, OP_String8, 0, trig_name_reg, 0,
-				  pTrigger->zName, P4_STATIC);
-		sqlite3VdbeAddOp3(v, OP_MakeRecord, trig_name_reg, 1,
-				  record_to_delete);
-		sqlite3VdbeAddOp2(v, OP_SDelete, BOX_TRIGGER_ID,
-				  record_to_delete);
-		if (!pParse->nested)
-			sqlite3VdbeChangeP5(v, OPFLAG_NCHANGE);
-
-		sqlite3ChangeCookie(pParse);
-	}
+	int trig_name_reg = ++parser->nMem;
+	int record_to_delete = ++parser->nMem;
+	sqlite3VdbeAddOp4(v, OP_String8, 0, trig_name_reg, 0,
+			  trigger->zName, P4_STATIC);
+	sqlite3VdbeAddOp3(v, OP_MakeRecord, trig_name_reg, 1,
+			  record_to_delete);
+	sqlite3VdbeAddOp2(v, OP_SDelete, BOX_TRIGGER_ID,
+			  record_to_delete);
+	if (!parser->nested)
+		sqlite3VdbeChangeP5(v, OPFLAG_NCHANGE);
+
+	sqlite3ChangeCookie(parser);
 }
 
 int
 sql_trigger_replace(struct sqlite3 *db, const char *name,
-		    struct Trigger *trigger, struct Trigger **old_trigger)
+		    struct sql_trigger *trigger,
+		    struct sql_trigger **old_trigger)
 {
 	assert(db->pSchema != NULL);
 	assert(trigger == NULL || strcmp(name, trigger->zName) == 0);
 
 	struct Hash *hash = &db->pSchema->trigHash;
 
-	struct Trigger *src_trigger =
+	struct sql_trigger *src_trigger =
 		trigger != NULL ? trigger : sqlite3HashFind(hash, name);
 	assert(src_trigger != NULL);
 	struct space *space = space_cache_find(src_trigger->space_id);
@@ -580,31 +571,31 @@ sql_trigger_replace(struct sqlite3 *db, const char *name,
 	}
 
 	if (*old_trigger != NULL) {
-		struct Trigger **pp;
+		struct sql_trigger **pp;
 		for (pp = &space->sql_triggers; *pp != *old_trigger;
-		     pp = &((*pp)->pNext));
-		*pp = (*pp)->pNext;
+		     pp = &((*pp)->next));
+		*pp = (*pp)->next;
 	}
 	if (trigger != NULL) {
-		trigger->pNext = space->sql_triggers;
+		trigger->next = space->sql_triggers;
 		space->sql_triggers = trigger;
 	}
 	return 0;
 }
 
 const char *
-sql_trigger_name(struct Trigger *trigger)
+sql_trigger_name(struct sql_trigger *trigger)
 {
 	return trigger->zName;
 }
 
 uint32_t
-sql_trigger_space_id(struct Trigger *trigger)
+sql_trigger_space_id(struct sql_trigger *trigger)
 {
 	return trigger->space_id;
 }
 
-struct Trigger *
+struct sql_trigger *
 space_trigger_list(uint32_t space_id)
 {
 	struct space *space = space_cache_find(space_id);
@@ -635,31 +626,22 @@ checkColumnOverlap(IdList * pIdList, ExprList * pEList)
 	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.
- */
-Trigger *
-sqlite3TriggersExist(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 */
-		     int *pMask	/* OUT: Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
-    )
+struct sql_trigger *
+sql_triggers_exist(struct Table *table, int op, struct ExprList *changes_list,
+		   int *mask_ptr)
 {
 	int mask = 0;
-	struct Trigger *trigger_list = NULL;
+	struct sql_trigger *trigger_list = NULL;
 	struct session *user_session = current_session();
 	if ((user_session->sql_flags & SQLITE_EnableTrigger) != 0)
-		trigger_list = space_trigger_list(pTab->def->id);
-	for (struct Trigger *p = trigger_list; p != NULL; p = p->pNext) {
+		trigger_list = space_trigger_list(table->def->id);
+	for (struct sql_trigger *p = trigger_list; p != NULL; p = p->next) {
 		if (p->op == op && checkColumnOverlap(p->pColumns,
-						      pChanges) != 0)
+						      changes_list) != 0)
 			mask |= p->tr_tm;
 	}
-	if (pMask != NULL)
-		*pMask = mask;
+	if (mask_ptr != NULL)
+		*mask_ptr = mask;
 	return mask != 0 ? trigger_list : NULL;
 }
 
@@ -829,28 +811,33 @@ transferParseError(Parse * pTo, Parse * pFrom)
 	pFrom->zErrMsg = NULL;
 }
 
-/*
+/**
  * Create and populate a new TriggerPrg object with a sub-program
  * implementing trigger pTrigger with ON CONFLICT policy orconf.
+ *
+ * @param parser Current parse context.
+ * @param trigger sql_trigger to code.
+ * @param table trigger is attached to.
+ * @param orconf ON CONFLICT policy to code trigger program with.
+ *
+ * @retval not NULL on success.
+ * @retval NULL on error.
  */
 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 */
-    )
+sql_row_trigger_program(struct Parse *parser, struct sql_trigger *trigger,
+			struct Table *table, int orconf)
 {
-	Parse *pTop = sqlite3ParseToplevel(pParse);
-	sqlite3 *db = pParse->db;	/* Database handle */
+	Parse *pTop = sqlite3ParseToplevel(parser);
+	/* Database handle. */
+	sqlite3 *db = parser->db;
 	TriggerPrg *pPrg;	/* Value to return */
 	Expr *pWhen = 0;	/* Duplicate of trigger WHEN expression */
-	Vdbe *v;		/* Temporary VM */
 	NameContext sNC;	/* Name context for sub-vdbe */
 	SubProgram *pProgram = 0;	/* Sub-vdbe for trigger program */
 	Parse *pSubParse;	/* Parse context for sub-vdbe */
 	int iEndTrigger = 0;	/* Label to jump to if WHEN is false */
 
-	assert(pTrigger->zName == NULL || pTab->def->id == pTrigger->space_id);
+	assert(trigger->zName == NULL || table->def->id == trigger->space_id);
 	assert(pTop->pVdbe);
 
 	/* Allocate the TriggerPrg and SubProgram objects. To ensure that they
@@ -866,13 +853,14 @@ codeRowTrigger(Parse * pParse,	/* Current parse context */
 	if (!pProgram)
 		return 0;
 	sqlite3VdbeLinkSubProgram(pTop->pVdbe, pProgram);
-	pPrg->pTrigger = pTrigger;
+	pPrg->trigger = trigger;
 	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.
+	/*
+	 * Allocate and populate a new Parse context to use for
+	 * coding the trigger sub-program.
 	 */
 	pSubParse = sqlite3StackAllocZero(db, sizeof(Parse));
 	if (!pSubParse)
@@ -880,34 +868,37 @@ codeRowTrigger(Parse * pParse,	/* Current parse context */
 	sql_parser_create(pSubParse, db);
 	memset(&sNC, 0, sizeof(sNC));
 	sNC.pParse = pSubParse;
-	pSubParse->pTriggerTab = pTab;
+	pSubParse->pTriggerTab = table;
 	pSubParse->pToplevel = pTop;
-	pSubParse->eTriggerOp = pTrigger->op;
-	pSubParse->nQueryLoop = pParse->nQueryLoop;
+	pSubParse->eTriggerOp = trigger->op;
+	pSubParse->nQueryLoop = parser->nQueryLoop;
 
-	v = sqlite3GetVdbe(pSubParse);
-	if (v) {
+	/* Temporary VM. */
+	struct Vdbe *v = sqlite3GetVdbe(pSubParse);
+	if (v != NULL) {
 		VdbeComment((v, "Start: %s.%s (%s %s%s%s ON %s)",
-			     pTrigger->zName, onErrorText(orconf),
-			     (pTrigger->tr_tm ==
+			     trigger->zName, onErrorText(orconf),
+			     (trigger->tr_tm ==
 			      TRIGGER_BEFORE ? "BEFORE" : "AFTER"),
-			     (pTrigger->op == TK_UPDATE ? "UPDATE" : ""),
-			     (pTrigger->op == TK_INSERT ? "INSERT" : ""),
-			     (pTrigger->op == TK_DELETE ? "DELETE" : ""),
-			     pTab->def->name));
+			     (trigger->op == TK_UPDATE ? "UPDATE" : ""),
+			     (trigger->op == TK_INSERT ? "INSERT" : ""),
+			     (trigger->op == TK_DELETE ? "DELETE" : ""),
+			      table->def->name));
 #ifndef SQLITE_OMIT_TRACE
 		sqlite3VdbeChangeP4(v, -1,
 				    sqlite3MPrintf(db, "-- TRIGGER %s",
-						   pTrigger->zName),
+						   trigger->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 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) {
-			pWhen = sqlite3ExprDup(db, pTrigger->pWhen, 0);
+		if (trigger->pWhen != NULL) {
+			pWhen = sqlite3ExprDup(db, trigger->pWhen, 0);
 			if (SQLITE_OK == sqlite3ResolveExprNames(&sNC, pWhen)
 			    && db->mallocFailed == 0) {
 				iEndTrigger = sqlite3VdbeMakeLabel(v);
@@ -919,17 +910,16 @@ codeRowTrigger(Parse * pParse,	/* Current parse context */
 		}
 
 		/* Code the trigger program into the sub-vdbe. */
-		codeTriggerProgram(pSubParse, pTrigger->step_list, orconf);
+		codeTriggerProgram(pSubParse, trigger->step_list, orconf);
 
 		/* Insert an OP_Halt at the end of the sub-program. */
-		if (iEndTrigger) {
+		if (iEndTrigger)
 			sqlite3VdbeResolveLabel(v, iEndTrigger);
-		}
 		sqlite3VdbeAddOp0(v, OP_Halt);
-		VdbeComment((v, "End: %s.%s", pTrigger->zName,
+		VdbeComment((v, "End: %s.%s", trigger->zName,
 			     onErrorText(orconf)));
 
-		transferParseError(pParse, pSubParse);
+		transferParseError(parser, pSubParse);
 		if (db->mallocFailed == 0) {
 			pProgram->aOp =
 			    sqlite3VdbeTakeOpArray(v, &pProgram->nOp,
@@ -937,7 +927,7 @@ codeRowTrigger(Parse * pParse,	/* Current parse context */
 		}
 		pProgram->nMem = pSubParse->nMem;
 		pProgram->nCsr = pSubParse->nTab;
-		pProgram->token = (void *)pTrigger;
+		pProgram->token = (void *)trigger;
 		pPrg->aColmask[0] = pSubParse->oldmask;
 		pPrg->aColmask[1] = pSubParse->newmask;
 		sqlite3VdbeDelete(v);
@@ -951,211 +941,130 @@ codeRowTrigger(Parse * pParse,	/* Current parse context */
 	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.
+/**
+ * Return a pointer to a TriggerPrg object containing the
+ * sub-program for trigger with default ON CONFLICT algorithm
+ * orconf. If no such TriggerPrg object exists, a new object is
+ * allocated and populated before being returned.
+ *
+ * @param parser Current parse context.
+ * @param trigger Trigger to code.
+ * @param table table trigger is attached to.
+ * @param orconf ON CONFLICT algorithm.
+ *
+ * @retval not NULL on success.
+ * @retval NULL on error.
  */
 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. */
-    )
+sql_row_trigger(struct Parse *parser, struct sql_trigger *trigger,
+		struct Table *table, int orconf)
 {
-	Parse *pRoot = sqlite3ParseToplevel(pParse);
+	Parse *pRoot = sqlite3ParseToplevel(parser);
 	TriggerPrg *pPrg;
 
-	assert(pTrigger->zName == NULL || pTab->def->id == pTrigger->space_id);
+	assert(trigger->zName == NULL || table->def->id == trigger->space_id);
 
-	/* 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.
+	/*
+	 * 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 && (pPrg->pTrigger != pTrigger || pPrg->orconf != orconf);
+	     pPrg && (pPrg->trigger != trigger || pPrg->orconf != orconf);
 	     pPrg = pPrg->pNext) ;
 
-	/* If an existing TriggerPrg could not be located, create a new one. */
-	if (!pPrg) {
-		pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf);
-	}
+	/*
+	 * If an existing TriggerPrg could not be located, create
+	 * a new one.
+	 */
+	if (pPrg == NULL)
+		pPrg = sql_row_trigger_program(parser, trigger, table, 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()
- */
 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_code_row_trigger_direct(struct Parse *parser, struct sql_trigger *trigger,
+			     struct Table *table, int reg, int orconf,
+			     int ignore_jump)
 {
-	Vdbe *v = sqlite3GetVdbe(pParse);	/* Main VM */
-	TriggerPrg *pPrg;
-	struct session *user_session = current_session();
+	/* Main VM. */
+	struct Vdbe *v = sqlite3GetVdbe(parser);
 
-	pPrg = getRowTrigger(pParse, p, pTab, orconf);
-	assert(pPrg || pParse->nErr || pParse->db->mallocFailed);
+	TriggerPrg *pPrg = sql_row_trigger(parser, trigger, table, orconf);
+	assert(pPrg != NULL || parser->nErr != 0 ||
+	       parser->db->mallocFailed != 0);
 
-	/* 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.
+	/*
+	 * 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) {
-		int bRecursive = (p->zName &&
-				  0 ==
-				  (user_session->
-				   sql_flags & SQLITE_RecTriggers));
-
-		sqlite3VdbeAddOp4(v, OP_Program, reg, ignoreJump,
-				  ++pParse->nMem, (const char *)pPrg->pProgram,
-				  P4_SUBPROGRAM);
-		VdbeComment((v, "Call: %s.%s", (p->zName ? p->zName : "fkey"),
-			     onErrorText(orconf)));
+	if (pPrg == NULL)
+		return;
 
-		/* 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);
-	}
+	struct session *user_session = current_session();
+	bool recursive = (trigger->zName && !(user_session->sql_flags &
+					      SQLITE_RecTriggers));
+
+	sqlite3VdbeAddOp4(v, OP_Program, reg, ignore_jump,
+			  ++parser->nMem, (const char *)pPrg->pProgram,
+			  P4_SUBPROGRAM);
+	VdbeComment((v, "Call: %s.%s", (trigger->zName ? trigger->zName :
+					"fkey"),
+		     onErrorText(orconf)));
+
+	/*
+	 * 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)recursive);
 }
 
-/*
- * 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 parameter. 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.PK
- *   reg+1          OLD.* value of left-most column of pTab
- *   ...            ...
- *   reg+N          OLD.* value of right-most column of pTab
- *   reg+N+1        NEW.PK
- *   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.
- */
 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) */
-    )
+vdbe_code_row_trigger(struct Parse *parser, struct sql_trigger *trigger,
+		      int op, struct ExprList *changes_list, int tr_tm,
+		      struct Table *table, int reg, int orconf, int ignore_jump)
 {
-	Trigger *p;		/* Used to iterate through pTrigger list */
-
 	assert(op == TK_UPDATE || op == TK_INSERT || op == TK_DELETE);
 	assert(tr_tm == TRIGGER_BEFORE || tr_tm == TRIGGER_AFTER);
-	assert((op == TK_UPDATE) == (pChanges != 0));
-
-	for (p = pTrigger; p; p = p->pNext) {
-		/* Determine whether we should code this trigger */
-		if (p->op == op
-		    && p->tr_tm == tr_tm
-		    && checkColumnOverlap(p->pColumns, pChanges)
-		    ) {
-			sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg,
-						    orconf, ignoreJump);
+	assert((op == TK_UPDATE) == (changes_list != NULL));
+
+	for (struct sql_trigger *p = trigger; p != NULL; p = p->next) {
+		/* Determine whether we should code trigger. */
+		if (p->op == op && p->tr_tm == tr_tm &&
+		    checkColumnOverlap(p->pColumns, changes_list)) {
+			vdbe_code_row_trigger_direct(parser, p, table, reg,
+						     orconf, ignore_jump);
 		}
 	}
 }
 
-/*
- * 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.PK or new.PK 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.
- */
 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 */
-    )
+sql_trigger_colmask(Parse *parser, struct sql_trigger *trigger,
+		    ExprList *changes_list, int new, int tr_tm,
+		    Table *table, int orconf)
 {
-	const int op = pChanges ? TK_UPDATE : TK_DELETE;
+	const int op = changes_list != NULL ? TK_UPDATE : TK_DELETE;
 	u32 mask = 0;
-	Trigger *p;
 
-	assert(isNew == 1 || isNew == 0);
-	for (p = pTrigger; p; p = p->pNext) {
+	assert(new == 1 || new == 0);
+	for (struct sql_trigger *p = trigger; p != NULL; p = p->next) {
 		if (p->op == op && (tr_tm & p->tr_tm)
-		    && checkColumnOverlap(p->pColumns, pChanges)
-		    ) {
-			TriggerPrg *pPrg;
-			pPrg = getRowTrigger(pParse, p, pTab, orconf);
-			if (pPrg) {
-				mask |= pPrg->aColmask[isNew];
-			}
+		    && checkColumnOverlap(p->pColumns, changes_list)) {
+			TriggerPrg *prg =
+				sql_row_trigger(parser, p, table, orconf);
+			if (prg != NULL)
+				mask |= prg->aColmask[new];
 		}
 	}
 
 	return mask;
 }
-
-#endif				/* !defined(SQLITE_OMIT_TRIGGER) */
diff --git a/src/box/sql/update.c b/src/box/sql/update.c
index 10385eb..212adbc 100644
--- a/src/box/sql/update.c
+++ b/src/box/sql/update.c
@@ -106,7 +106,8 @@ sqlite3Update(Parse * pParse,		/* The parser context */
 	struct session *user_session = current_session();
 
 	bool is_view;		/* True when updating a view (INSTEAD OF trigger) */
-	Trigger *pTrigger;	/* List of triggers on pTab, if required */
+	/* List of triggers on pTab, if required. */
+	struct sql_trigger *trigger;
 	int tmask;		/* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
 	int newmask;		/* Mask of NEW.* columns accessed by BEFORE triggers */
 	int iEph = 0;		/* Ephemeral table holding all primary key values */
@@ -136,9 +137,9 @@ sqlite3Update(Parse * pParse,		/* The parser context */
 	/* Figure out if we have any triggers and if the table being
 	 * updated is a view.
 	 */
-	pTrigger = sqlite3TriggersExist(pTab, TK_UPDATE, pChanges, &tmask);
+	trigger = sql_triggers_exist(pTab, TK_UPDATE, pChanges, &tmask);
 	is_view = pTab->def->opts.is_view;
-	assert(pTrigger || tmask == 0);
+	assert(trigger != NULL || tmask == 0);
 
 	if (is_view &&
 	    sql_view_assign_cursors(pParse,pTab->def->opts.sql) != 0) {
@@ -269,11 +270,9 @@ sqlite3Update(Parse * pParse,		/* The parser context */
 	/* Allocate required registers. */
 	regOldPk = regNewPk = ++pParse->nMem;
 
-	if (chngPk || pTrigger || hasFK) {
+	if (chngPk != 0 || trigger != NULL || hasFK != 0) {
 		regOld = pParse->nMem + 1;
 		pParse->nMem += def->field_count;
-	}
-	if (chngPk || pTrigger || hasFK) {
 		regNewPk = ++pParse->nMem;
 	}
 	regNew = pParse->nMem + 1;
@@ -424,18 +423,18 @@ sqlite3Update(Parse * pParse,		/* The parser context */
 	 * then regNewPk is the same register as regOldPk, which is
 	 * already populated.
 	 */
-	assert(chngPk || pTrigger || hasFK || regOldPk == regNewPk);
+	assert(chngPk != 0 || trigger != NULL || hasFK != 0 ||
+	       regOldPk == regNewPk);
 
 
 	/* Compute the old pre-UPDATE content of the row being changed, if that
 	 * information is needed
 	 */
-	if (chngPk || hasFK || pTrigger) {
+	if (chngPk != 0 || hasFK != 0 || trigger != NULL) {
 		u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
-		oldmask |= sqlite3TriggerColmask(pParse,
-						 pTrigger, pChanges, 0,
-						 TRIGGER_BEFORE | TRIGGER_AFTER,
-						 pTab, on_error);
+		oldmask |= sql_trigger_colmask(pParse, trigger, pChanges, 0,
+					       TRIGGER_BEFORE | TRIGGER_AFTER,
+					       pTab, on_error);
 		for (i = 0; i < (int)def->field_count; i++) {
 			if (oldmask == 0xffffffff
 			    || (i < 32 && (oldmask & MASKBIT32(i)) != 0)
@@ -464,9 +463,8 @@ sqlite3Update(Parse * pParse,		/* The parser context */
 	 * may have modified them). So not loading those that are not going to
 	 * be used eliminates some redundant opcodes.
 	 */
-	newmask =
-	    sqlite3TriggerColmask(pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE,
-				  pTab, on_error);
+	newmask = sql_trigger_colmask(pParse, trigger, pChanges, 1,
+				      TRIGGER_BEFORE, pTab, on_error);
 	for (i = 0; i < (int)def->field_count; i++) {
 		if (i == pTab->iPKey) {
 			sqlite3VdbeAddOp2(v, OP_Null, 0, regNew + i);
@@ -498,7 +496,7 @@ sqlite3Update(Parse * pParse,		/* The parser context */
 	 */
 	if (tmask & TRIGGER_BEFORE) {
 		sqlite3TableAffinity(v, pTab, regNew);
-		sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
+		vdbe_code_row_trigger(pParse, trigger, TK_UPDATE, pChanges,
 				      TRIGGER_BEFORE, pTab, regOldPk,
 				      on_error, labelContinue);
 
@@ -611,7 +609,7 @@ sqlite3Update(Parse * pParse,		/* The parser context */
 		sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
 	}
 
-	sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
+	vdbe_code_row_trigger(pParse, trigger, TK_UPDATE, pChanges,
 			      TRIGGER_AFTER, pTab, regOldPk, on_error,
 			      labelContinue);
 
diff --git a/src/box/sql/vdbe.c b/src/box/sql/vdbe.c
index cac1ad3..b0ab916 100644
--- a/src/box/sql/vdbe.c
+++ b/src/box/sql/vdbe.c
@@ -4733,7 +4733,7 @@ case OP_RenameTable: {
 	space = space_by_id(space_id);
 	assert(space);
 	/* Rename space op doesn't change triggers. */
-	struct Trigger *triggers = space->sql_triggers;
+	struct sql_trigger *triggers = space->sql_triggers;
 	zOldTableName = space_name(space);
 	assert(zOldTableName);
 	pTab = sqlite3HashFind(&db->pSchema->tblHash, zOldTableName);
@@ -4784,9 +4784,9 @@ case OP_RenameTable: {
 	 * due to lack of transactional DDL, but just do the best
 	 * effort.
 	 */
-	for (struct Trigger *trigger = triggers; trigger != NULL; ) {
+	for (struct sql_trigger *trigger = triggers; trigger != NULL; ) {
 		/* Store pointer as trigger will be destructed. */
-		struct Trigger *next_trigger = trigger->pNext;
+		struct sql_trigger *next_trigger = trigger->next;
 		rc = tarantoolSqlite3RenameTrigger(trigger->zName,
 						   zOldTableName, zNewTableName);
 		if (rc != SQLITE_OK) {
@@ -4849,8 +4849,6 @@ case OP_DropIndex: {
 	break;
 }
 
-#ifndef SQLITE_OMIT_TRIGGER
-
 /* Opcode: Program P1 P2 P3 P4 P5
  *
  * Execute the trigger program passed as P4 (type P4_SUBPROGRAM).
@@ -5006,8 +5004,6 @@ case OP_Param: {           /* out2 */
 	break;
 }
 
-#endif /* #ifndef SQLITE_OMIT_TRIGGER */
-
 #ifndef SQLITE_OMIT_FOREIGN_KEY
 /* Opcode: FkCounter P1 P2 * * *
  * Synopsis: fkctr[P1]+=P2
diff --git a/src/box/sql/vdbe.h b/src/box/sql/vdbe.h
index 45a89d9..03ae44e 100644
--- a/src/box/sql/vdbe.h
+++ b/src/box/sql/vdbe.h
@@ -302,9 +302,7 @@ UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(struct sqlite3 *,
 					       struct key_def *);
 int sql_vdbe_mem_alloc_region(Mem *, uint32_t);
 
-#ifndef SQLITE_OMIT_TRIGGER
 void sqlite3VdbeLinkSubProgram(Vdbe *, SubProgram *);
-#endif
 
 /* Use SQLITE_ENABLE_COMMENTS to enable generation of extra comments on
  * each VDBE opcode.
-- 
2.7.4

       reply	other threads:[~2018-06-26 16:13 UTC|newest]

Thread overview: 12+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
     [not found] <cover.1530029141.git.kshcherbatov@tarantool.org>
2018-06-26 16:13 ` Kirill Shcherbatov [this message]
2018-06-27 15:57   ` [tarantool-patches] " n.pettik
2018-06-27 16:35     ` Kirill Shcherbatov
2018-06-27 17:41       ` n.pettik
2018-06-27 18:04         ` Kirill Shcherbatov
2018-06-26 16:13 ` [tarantool-patches] [PATCH v4 8/8] sql: remove global sql_trigger hash Kirill Shcherbatov
2018-06-27 17:28   ` [tarantool-patches] " n.pettik
2018-06-27 18:04     ` Kirill Shcherbatov
2018-06-28 19:17       ` Vladislav Shpilevoy
2018-06-29 13:28         ` Kirill Shcherbatov
2018-06-29 13:31           ` Vladislav Shpilevoy
2018-06-29 13:54             ` Kirill Yukhin

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=81986d1f9307191bd3d3e37514dc32fadb7e6970.1530029141.git.kshcherbatov@tarantool.org \
    --to=kshcherbatov@tarantool.org \
    --cc=n.pettik@corp.mail.ru \
    --cc=tarantool-patches@freelists.org \
    --subject='Re: [tarantool-patches] [PATCH v4 6/8] sql: refactor AST trigger object name' \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox