public static void BeginTrigger(Parse parse, Token name1, Token name2, TK trTm, TK op, IdList columns, SrcList tableName, Expr when, bool isTemp, int noErr)
{
Context ctx = parse.Ctx; // The database connection
Debug.Assert(name1 != null); // pName1.z might be NULL, but not pName1 itself
Debug.Assert(name2 != null);
Debug.Assert(op == TK.INSERT || op == TK.UPDATE || op == TK.DELETE);
Debug.Assert(op > 0 && op < (TK)0xff);
Trigger trigger = null; // The new trigger
int db; // The database to store the trigger in
Token name = null; // The unqualified db name
if (isTemp)
{
// If TEMP was specified, then the trigger name may not be qualified.
if (name2.length > 0)
{
parse.ErrorMsg("temporary trigger may not have qualified name");
goto trigger_cleanup;
}
db = 1;
name = name1;
}
else
{
// Figure out the db that the the trigger will be created in
db = parse.TwoPartName(name1, name2, ref name);
if (db < 0)
{
goto trigger_cleanup;
}
}
if (tableName == null || ctx.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 (ctx.Init.Busy && db != 1)
{
C._tagfree(ctx, ref tableName.Ids[0].Database);
tableName.Ids[0].Database = 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 (tableName == null) goto trigger_cleanup;
Table table = Delete.SrcListLookup(parse, tableName); // Table that the trigger fires off of
if (ctx.Init.Busy == null && name2.length == 0 && table != null && table.Schema == ctx.DBs[1].Schema)
{
db = 1;
}
// Ensure the table name matches database name and that the table exists
if (ctx.MallocFailed)
{
goto trigger_cleanup;
}
Debug.Assert(tableName.Srcs == 1);
DbFixer sFix = new DbFixer(); // State vector for the DB fixer
if (sFix.FixInit(parse, db, "trigger", name) && sFix.FixSrcList(tableName))
{
goto trigger_cleanup;
}
table = Delete.SrcListLookup(parse, tableName);
if (table == null)
{
// The table does not exist.
if (ctx.Init.DB == 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.
ctx.Init.OrphanTrigger = true;
}
goto trigger_cleanup;
}
if (E.IsVirtual(table))
{
parse.ErrorMsg("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
string nameAsString = Parse.NameFromToken(ctx, name);
if (nameAsString == null || parse.CheckObjectName(nameAsString) != RC.OK)
{
goto trigger_cleanup;
}
Debug.Assert(Btree.SchemaMutexHeld(ctx, db, null));
if (ctx.DBs[db].Schema.TriggerHash.Find(nameAsString, nameAsString.Length, (Trigger)null) != null)
{
if (noErr == 0)
{
parse.ErrorMsg("trigger %T already exists", name);
}
else
{
Debug.Assert(!ctx.Init.Busy);
parse.CodeVerifySchema(db);
}
goto trigger_cleanup;
}
// Do not create a trigger on a system table
if (table.Name.StartsWith("sqlite_", StringComparison.InvariantCultureIgnoreCase))
{
parse.ErrorMsg("cannot create trigger on system table");
parse.Errs++;
goto trigger_cleanup;
}
// INSTEAD of triggers are only for views and views only support INSTEAD of triggers.
if (table.Select != null && trTm != TK.INSTEAD)
{
parse.ErrorMsg("cannot create %s trigger on view: %S", (trTm == TK.BEFORE ? "BEFORE" : "AFTER"), tableName, 0);
goto trigger_cleanup;
}
if (table.Select == null && trTm == TK.INSTEAD)
{
parse.ErrorMsg("cannot create INSTEAD OF trigger on table: %S", tableName, 0);
goto trigger_cleanup;
}
#if !OMIT_AUTHORIZATION
{
int tabDb = Prepare.SchemaToIndex(ctx, table.Schema); // Index of the database holding pTab
AUTH code = AUTH.CREATE_TRIGGER;
string dbName = ctx.DBs[tabDb].Name;
string dbTrigName = (isTemp ? ctx.DBs[1].Name : dbName);
if (tabDb == 1 || isTemp)
{
code = AUTH.CREATE_TEMP_TRIGGER;
}
if (Auth.Check(parse, code, nameAsString, table.Name, dbTrigName) != 0 || Auth.Check(parse, AUTH.INSERT, E.SCHEMA_TABLE(tabDb), 0, dbName))
{
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 (trTm == TK.INSTEAD)
{
trTm = TK.BEFORE;
}
// Build the Trigger object
trigger = new Trigger(); //: (Trigger *)_tagalloc(db, sizeof(Trigger), true);
if (trigger == null)
{
goto trigger_cleanup;
}
trigger.Name = name;
trigger.Table = tableName.Ids[0].Name; //: _tagstrdup(ctx, tableName->Ids[0].Name);
trigger.Schema = ctx.DBs[db].Schema;
trigger.TabSchema = table.Schema;
trigger.OP = op;
trigger.TRtm = (trTm == TK.BEFORE ? TRIGGER.BEFORE : TRIGGER.AFTER);
trigger.When = Expr.Dup(db, when, E.EXPRDUP_REDUCE);
trigger.Columns = Expr.IdListDup(ctx, columns);
Debug.Assert(parse.NewTrigger == null);
parse.NewTrigger = trigger;
trigger_cleanup:
C._tagfree(ctx, ref name);
Expr.SrcListDelete(ctx, ref tableName);
Expr.IdListDelete(ctx, ref columns);
Expr.Delete(ctx, ref when);
if (parse.NewTrigger == null)
{
DeleteTrigger(ctx, ref trigger);
}
else
{
Debug.Assert(parse.NewTrigger == trigger);
}
}
static WRC ResolveExprStep(Walker walker, Expr expr)
{
NameContext nc = walker.u.NC;
Debug.Assert(nc != null);
Parse parse = nc.Parse;
Debug.Assert(parse == walker.Parse);
if (E.ExprHasAnyProperty(expr, EP.Resolved))
{
return(WRC.Prune);
}
E.ExprSetProperty(expr, EP.Resolved);
#if !NDEBUG
if (nc.SrcList != null && nc.SrcList.Allocs > 0)
{
SrcList srcList = nc.SrcList;
for (int i = 0; i < nc.SrcList.Srcs; i++)
{
Debug.Assert(srcList.Ids[i].Cursor >= 0 && srcList.Ids[i].Cursor < parse.Tabs);
}
}
#endif
switch (expr.OP)
{
#if ENABLE_UPDATE_DELETE_LIMIT && !OMIT_SUBQUERY
// The special operator TK_ROW means use the rowid for the first column in the FROM clause. This is used by the LIMIT and ORDER BY
// clause processing on UPDATE and DELETE statements.
case TK.ROW:
{
SrcList srcList = nc.SrcList;
Debug.Assert(srcList != null && srcList.Srcs == 1);
SrcList.SrcListItem item = srcList.Ids[0];
expr.OP = TK.COLUMN;
expr.Table = item.Table;
expr.TableId = item.Cursor;
expr.ColumnId = -1;
expr.Aff = AFF.INTEGER;
break;
}
#endif
case TK.ID: // A lone identifier is the name of a column.
{
return(LookupName(parse, null, null, expr.u.Token, nc, expr));
}
case TK.DOT: // A table name and column name: ID.ID Or a database, table and column: ID.ID.ID
{
string columnName;
string tableName;
string dbName;
// if (srcList == nullptr) break;
Expr right = expr.Right;
if (right.OP == TK.ID)
{
dbName = null;
tableName = expr.Left.u.Token;
columnName = right.u.Token;
}
else
{
Debug.Assert(right.OP == TK.DOT);
dbName = expr.Left.u.Token;
tableName = right.Left.u.Token;
columnName = right.Right.u.Token;
}
return(LookupName(parse, dbName, tableName, columnName, nc, expr));
}
case TK.CONST_FUNC:
case TK.FUNCTION: // Resolve function names
{
ExprList list = expr.x.List; // The argument list
int n = (list != null ? list.Exprs : 0); // Number of arguments
bool noSuchFunc = false; // True if no such function exists
bool wrongNumArgs = false; // True if wrong number of arguments
bool isAgg = false; // True if is an aggregate function
TEXTENCODE encode = E.CTXENCODE(parse.Ctx); // The database encoding
C.ASSERTCOVERAGE(expr.OP == TK.CONST_FUNC);
Debug.Assert(!E.ExprHasProperty(expr, EP.xIsSelect));
string id = expr.u.Token; // The function name.
int idLength = id.Length; // Number of characters in function name
FuncDef def = Callback.FindFunction(parse.Ctx, id, idLength, n, encode, false); // Information about the function
if (def == null)
{
def = Callback.FindFunction(parse.Ctx, id, idLength, -2, encode, false);
if (def == null)
{
noSuchFunc = true;
}
else
{
wrongNumArgs = true;
}
}
else
{
isAgg = (def.Func == null);
}
#if !OMIT_AUTHORIZATION
if (def != null)
{
ARC auth = Auth.Check(parse, AUTH.FUNCTION, null, def.Name, null); // Authorization to use the function
if (auth != ARC.OK)
{
if (auth == ARC.DENY)
{
parse.ErrorMsg("not authorized to use function: %s", def.Name);
nc.Errs++;
}
expr.OP = TK.NULL;
return(WRC.Prune);
}
}
#endif
if (isAgg && (nc.NCFlags & NC.AllowAgg) == 0)
{
parse.ErrorMsg("misuse of aggregate function %.*s()", idLength, id);
nc.Errs++;
isAgg = false;
}
else if (noSuchFunc && !ctx.Init.Busy)
{
parse.ErrorMsg("no such function: %.*s", idLength, id);
nc.Errs++;
}
else if (wrongNumArgs)
{
parse.ErrorMsg("wrong number of arguments to function %.*s()", idLength, id);
nc.Errs++;
}
if (isAgg)
{
nc.NCFlags &= ~NC.AllowAgg;
}
walker.WalkExprList(list);
if (isAgg)
{
NameContext nc2 = nc;
expr.OP = TK.AGG_FUNCTION;
expr.OP2 = 0;
while (nc2 != null && !expr.FunctionUsesThisSrc(nc2.SrcList))
{
expr.OP2++;
nc2 = nc2.Next;
}
if (nc2 != null)
{
nc2.NCFlags |= NC.HasAgg;
}
nc.NCFlags |= NC.AllowAgg;
}
// FIX ME: Compute pExpr->affinity based on the expected return type of the function
return(WRC.Prune);
}
#if !OMIT_SUBQUERY
case TK.SELECT:
case TK.EXISTS:
{
C.ASSERTCOVERAGE(expr.OP == TK.EXISTS);
goto case TK.IN;
}
#endif
case TK.IN:
{
C.ASSERTCOVERAGE(expr.OP == TK.IN);
if (E.ExprHasProperty(expr, EP.xIsSelect))
{
int refs = nc.Refs;
#if !OMIT_CHECK
if ((nc.NCFlags & NC.IsCheck) != 0)
{
parse.ErrorMsg("subqueries prohibited in CHECK constraints");
}
#endif
walker.WalkSelect(expr.x.Select);
Debug.Assert(nc.Refs >= refs);
if (refs != nc.Refs)
{
E.ExprSetProperty(expr, EP.VarSelect);
}
}
break;
}
#if !OMIT_CHECK
case TK.VARIABLE:
{
if ((nc.NCFlags & NC.IsCheck) != 0)
{
parse.ErrorMsg("parameters prohibited in CHECK constraints");
}
break;
}
#endif
}
return(parse.Errs != 0 || parse.Ctx.MallocFailed ? WRC.Abort : WRC.Continue);
}
public void FKCheck(Table table, int regOld, int regNew)
{
Context ctx = Ctx; // Database handle
bool isIgnoreErrors = DisableTriggers;
// Exactly one of regOld and regNew should be non-zero.
Debug.Assert((regOld == 0) != (regNew == 0));
// If foreign-keys are disabled, this function is a no-op.
if ((ctx.Flags & Context.FLAG.ForeignKeys) == 0)
{
return;
}
int db = SchemaToIndex(ctx, table.Schema); // Index of database containing pTab
string dbName = ctx.DBs[db].Name; // Name of database containing pTab
// Loop through all the foreign key constraints for which pTab is the child table (the table that the foreign key definition is part of).
FKey fkey; // Used to iterate through FKs
for (fkey = table.FKeys; fkey != null; fkey = fkey.NextFrom)
{
bool isIgnore = false;
// Find the parent table of this foreign key. Also find a unique index on the parent key columns in the parent table. If either of these
// schema items cannot be located, set an error in pParse and return early.
Table to = (DisableTriggers ? FindTable(ctx, fkey.To, dbName) : LocateTable(false, fkey.To, dbName)); // Parent table of foreign key pFKey
Index index = null; // Index on key columns in pTo
int[] frees = null;
if (to == null || LocateFkeyIndex(to, fkey, out index, out frees) != 0)
{
Debug.Assert(!isIgnoreErrors || (regOld != 0 && regNew == 0));
if (!isIgnoreErrors || ctx.MallocFailed)
{
return;
}
if (to == null)
{
// If isIgnoreErrors is true, then a table is being dropped. In this se SQLite runs a "DELETE FROM xxx" on the table being dropped
// before actually dropping it in order to check FK constraints. If the parent table of an FK constraint on the current table is
// missing, behave as if it is empty. i.e. decrement the FK counter for each row of the current table with non-NULL keys.
Vdbe v = GetVdbe();
int jumpId = v.CurrentAddr() + fkey.Cols.length + 1;
for (int i = 0; i < fkey.Cols.length; i++)
{
int regId = fkey.Cols[i].From + regOld + 1;
v.AddOp2(OP.IsNull, regId, jumpId);
}
v.AddOp2(OP.FkCounter, fkey.IsDeferred, -1);
}
continue;
}
Debug.Assert(fkey.Cols.length == 1 || (frees != null && index != null));
int[] cols;
if (frees != null)
{
cols = frees;
}
else
{
int col = fkey.Cols[0].From;
cols = new int[1];
cols[0] = col;
}
for (int i = 0; i < fkey.Cols.length; i++)
{
if (cols[i] == table.PKey)
{
cols[i] = -1;
}
#if !OMIT_AUTHORIZATION
// Request permission to read the parent key columns. If the authorization callback returns SQLITE_IGNORE, behave as if any
// values read from the parent table are NULL.
if (ctx.Auth != null)
{
string colName = to.Cols[index != null ? index.Columns[i] : to.PKey].Name;
ARC rcauth = Auth.ReadColumn(this, to.Name, colName, db);
isIgnore = (rcauth == ARC.IGNORE);
}
#endif
}
// Take a shared-cache advisory read-lock on the parent table. Allocate a cursor to use to search the unique index on the parent key columns
// in the parent table.
TableLock(db, to.Id, false, to.Name);
Tabs++;
if (regOld != 0) // A row is being removed from the child table. Search for the parent. If the parent does not exist, removing the child row resolves an outstanding foreign key constraint violation.
{
FKLookupParent(this, db, to, index, fkey, cols, regOld, -1, isIgnore);
}
if (regNew != 0) // A row is being added to the child table. If a parent row cannot be found, adding the child row has violated the FK constraint.
{
FKLookupParent(this, db, to, index, fkey, cols, regNew, +1, isIgnore);
}
C._tagfree(ctx, ref frees);
}
// Loop through all the foreign key constraints that refer to this table
for (fkey = FKReferences(table); fkey != null; fkey = fkey.NextTo)
{
if (!fkey.IsDeferred && Toplevel == null && !IsMultiWrite)
{
Debug.Assert(regOld == 0 && regNew != 0);
// Inserting a single row into a parent table cannot cause an immediate foreign key violation. So do nothing in this case.
continue;
}
Index index = null; // Foreign key index for pFKey
int[] cols = null;
if (LocateFkeyIndex(table, fkey, out index, out cols) != 0)
{
if (isIgnoreErrors || ctx.MallocFailed)
{
return;
}
continue;
}
Debug.Assert(cols != null || fkey.Cols.length == 1);
// Create a SrcList structure containing a single table (the table the foreign key that refers to this table is attached to). This
// is required for the sqlite3WhereXXX() interface.
SrcList src = SrcListAppend(ctx, null, null, null);
if (src != null)
{
SrcList.SrcListItem item = src.Ids[0];
item.Table = fkey.From;
item.Name = fkey.From.Name;
item.Table.Refs++;
item.Cursor = Tabs++;
if (regNew != 0)
{
FKScanChildren(this, src, table, index, fkey, cols, regNew, -1);
}
if (regOld != 0)
{
// If there is a RESTRICT action configured for the current operation on the parent table of this FK, then throw an exception
// immediately if the FK constraint is violated, even if this is a deferred trigger. That's what RESTRICT means. To defer checking
// the constraint, the FK should specify NO ACTION (represented using OE_None). NO ACTION is the default.
FKScanChildren(this, src, table, index, fkey, cols, regOld, 1);
}
item.Name = null;
SrcListDelete(ctx, ref src);
}
C._tagfree(ctx, ref cols);
}
}
static WRC LookupName(Parse parse, string dbName, string tableName, string colName, NameContext nc, Expr expr)
{
int cnt = 0; // Number of matching column names
int cntTab = 0; // Number of matching table names
int subquerys = 0; // How many levels of subquery
Context ctx = parse.Ctx; // The database connection
SrcList.SrcListItem item; // Use for looping over pSrcList items
SrcList.SrcListItem match = null; // The matching pSrcList item
NameContext topNC = nc; // First namecontext in the list
Schema schema = null; // Schema of the expression
bool isTrigger = false;
int i, j;
Debug.Assert(nc != null); // the name context cannot be NULL.
Debug.Assert(colName != null); // The Z in X.Y.Z cannot be NULL
Debug.Assert(!E.ExprHasAnyProperty(expr, EP.TokenOnly | EP.Reduced));
// Initialize the node to no-match
expr.TableId = -1;
expr.Table = null;
E.ExprSetIrreducible(expr);
// Translate the schema name in zDb into a pointer to the corresponding schema. If not found, pSchema will remain NULL and nothing will match
// resulting in an appropriate error message toward the end of this routine
if (dbName != null)
{
for (i = 0; i < ctx.DBs.length; i++)
{
Debug.Assert(ctx.DBs[i].Name != null);
if (string.Compare(ctx.DBs[i].Name, dbName) == 0)
{
schema = ctx.DBs[i].Schema;
break;
}
}
}
// Start at the inner-most context and move outward until a match is found
while (nc != null && cnt == 0)
{
ExprList list;
SrcList srcList = nc.SrcList;
if (srcList != null)
{
for (i = 0; i < srcList.Srcs; i++)
{
item = srcList.Ids[i];
Table table = item.Table;
Debug.Assert(table != null && table.Name != null);
Debug.Assert(table.Cols.length > 0);
if (item.Select != null && (item.Select.SelFlags & SF.NestedFrom) != 0)
{
bool hit = false;
list = item.Select.EList;
for (j = 0; j < list.Exprs; j++)
{
if (Walker.MatchSpanName(list.Ids[j].Span, colName, tableName, dbName))
{
cnt++;
cntTab = 2;
match = item;
expr.ColumnId = j;
hit = true;
}
}
if (hit || table == null)
{
continue;
}
}
if (dbName != null && table.Schema != schema)
{
continue;
}
if (tableName != null)
{
string tableName2 = (item.Alias != null ? item.Alias : table.Name);
Debug.Assert(tableName2 != null);
if (!string.Equals(tableName2, tableName, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
if (cntTab++ == 0)
{
match = item;
}
Column col;
for (j = 0; j < table.Cols.length; j++)
{
col = table.Cols[j];
if (string.Equals(col.Name, colName, StringComparison.InvariantCultureIgnoreCase))
{
// If there has been exactly one prior match and this match is for the right-hand table of a NATURAL JOIN or is in a
// USING clause, then skip this match.
if (cnt == 1)
{
if ((item.Jointype & JT.NATURAL) != 0)
{
continue;
}
if (NameInUsingClause(item.Using, colName))
{
continue;
}
}
cnt++;
match = item;
// Substitute the rowid (column -1) for the INTEGER PRIMARY KEY
expr.ColumnId = (j == table.PKey ? -1 : (short)j);
break;
}
}
}
if (match != null)
{
expr.TableId = match.Cursor;
expr.Table = match.Table;
schema = expr.Table.Schema;
}
}
#if !OMIT_TRIGGER
// If we have not already resolved the name, then maybe it is a new.* or old.* trigger argument reference
if (dbName == null && tableName != null && cnt == 0 && parse.TriggerTab != null)
{
TK op = parse.TriggerOp;
Table table = null;
Debug.Assert(op == TK.DELETE || op == TK.UPDATE || op == TK.INSERT);
if (op != TK.DELETE && string.Equals("new", tableName, StringComparison.InvariantCultureIgnoreCase))
{
expr.TableId = 1;
table = parse.TriggerTab;
}
else if (op != TK.INSERT && string.Equals("old", tableName, StringComparison.InvariantCultureIgnoreCase))
{
expr.TableId = 0;
table = parse.TriggerTab;
}
if (table != null)
{
int colId;
schema = table.Schema;
cntTab++;
for (colId = 0; colId < table.Cols.length; colId++)
{
Column col = table.Cols[colId];
if (string.Equals(col.Name, colName, StringComparison.InvariantCultureIgnoreCase))
{
if (colId == table.PKey)
{
colId = -1;
}
break;
}
}
if (colId >= table.Cols.length && Expr.IsRowid(colName))
{
colId = -1; // IMP: R-44911-55124
}
if (colId < table.Cols.length)
{
cnt++;
if (colId < 0)
{
expr.Aff = AFF.INTEGER;
}
else if (expr.TableId == 0)
{
C.ASSERTCOVERAGE(colId == 31);
C.ASSERTCOVERAGE(colId == 32);
parse.Oldmask |= (colId >= 32 ? 0xffffffff : (((uint)1) << colId));
}
else
{
C.ASSERTCOVERAGE(colId == 31);
C.ASSERTCOVERAGE(colId == 32);
parse.Newmask |= (colId >= 32 ? 0xffffffff : (((uint)1) << colId));
}
expr.ColumnId = (short)colId;
expr.Table = table;
isTrigger = true;
}
}
}
#endif
// Perhaps the name is a reference to the ROWID
if (cnt == 0 && cntTab == 1 && Expr.IsRowid(colName))
{
cnt = 1;
expr.ColumnId = -1; // IMP: R-44911-55124
expr.Aff = AFF.INTEGER;
}
// If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z might refer to an result-set alias. This happens, for example, when
// we are resolving names in the WHERE clause of the following command:
//
// SELECT a+b AS x FROM table WHERE x<10;
//
// In cases like this, replace pExpr with a copy of the expression that forms the result set entry ("a+b" in the example) and return immediately.
// Note that the expression in the result set should have already been resolved by the time the WHERE clause is resolved.
if (cnt == 0 && (list = nc.EList) != null && tableName == null)
{
for (j = 0; j < list.Exprs; j++)
{
string asName = list.Ids[j].Name;
if (asName != null && string.Equals(asName, colName, StringComparison.InvariantCultureIgnoreCase))
{
Debug.Assert(expr.Left == null && expr.Right == null);
Debug.Assert(expr.x.List == null);
Debug.Assert(expr.x.Select == null);
Expr orig = list.Ids[j].Expr;
if ((nc.NCFlags & NC.AllowAgg) == 0 && E.ExprHasProperty(orig, EP.Agg))
{
parse.ErrorMsg("misuse of aliased aggregate %s", asName);
return(WRC.Abort);
}
ResolveAlias(parse, list, j, expr, "", subquerys);
cnt = 1;
match = null;
Debug.Assert(tableName == null && dbName == null);
goto lookupname_end;
}
}
}
// Advance to the next name context. The loop will exit when either we have a match (cnt>0) or when we run out of name contexts.
if (cnt == 0)
{
nc = nc.Next;
subquerys++;
}
}
// If X and Y are NULL (in other words if only the column name Z is supplied) and the value of Z is enclosed in double-quotes, then
// Z is a string literal if it doesn't match any column names. In that case, we need to return right away and not make any changes to
// pExpr.
//
// Because no reference was made to outer contexts, the pNC->nRef fields are not changed in any context.
if (cnt == 0 && tableName == null && E.ExprHasProperty(expr, EP.DblQuoted))
{
expr.OP = TK.STRING;
expr.Table = null;
return(WRC.Prune);
}
// cnt==0 means there was not match. cnt>1 means there were two or more matches. Either way, we have an error.
if (cnt != 1)
{
string err = (cnt == 0 ? "no such column" : "ambiguous column name");
if (dbName != null)
{
parse.ErrorMsg("%s: %s.%s.%s", err, dbName, tableName, colName);
}
else if (tableName != null)
{
parse.ErrorMsg("%s: %s.%s", err, tableName, colName);
}
else
{
parse.ErrorMsg("%s: %s", err, colName);
}
parse.CheckSchema = 1;
topNC.Errs++;
}
// If a column from a table in pSrcList is referenced, then record this fact in the pSrcList.a[].colUsed bitmask. Column 0 causes
// bit 0 to be set. Column 1 sets bit 1. And so forth. If the column number is greater than the number of bits in the bitmask
// then set the high-order bit of the bitmask.
if (expr.ColumnId >= 0 && match != null)
{
int n = expr.ColumnId;
C.ASSERTCOVERAGE(n == BMS - 1);
if (n >= BMS)
{
n = BMS - 1;
}
Debug.Assert(match.Cursor == expr.TableId);
match.ColUsed |= ((Bitmask)1) << n;
}
// Clean up and return
Expr.Delete(ctx, ref expr.Left);
expr.Left = null;
Expr.Delete(ctx, ref expr.Right);
expr.Right = null;
expr.OP = (isTrigger ? TK.TRIGGER : TK.COLUMN);
lookupname_end:
if (cnt == 1)
{
Debug.Assert(nc != null);
Auth.Read(parse, expr, schema, nc.SrcList);
// Increment the nRef value on all name contexts from TopNC up to the point where the name matched.
for (; ;)
{
Debug.Assert(topNC != null);
topNC.Refs++;
if (topNC == nc)
{
break;
}
topNC = topNC.Next;
}
return(WRC.Prune);
}
return(WRC.Abort);
}
