785 lines
No EOL
26 KiB
C#
785 lines
No EOL
26 KiB
C#
using System;
|
|
using System.Diagnostics;
|
|
|
|
using u32 = System.UInt32;
|
|
|
|
namespace Community.CsharpSqlite
|
|
{
|
|
using sqlite3_value = Sqlite3.Mem;
|
|
|
|
public partial class Sqlite3
|
|
{
|
|
/*
|
|
** 2001 September 15
|
|
**
|
|
** The author disclaims copyright to this source code. In place of
|
|
** a legal notice, here is a blessing:
|
|
**
|
|
** May you do good and not evil.
|
|
** May you find forgiveness for yourself and forgive others.
|
|
** May you share freely, never taking more than you give.
|
|
**
|
|
*************************************************************************
|
|
** This file contains C code routines that are called by the parser
|
|
** to handle UPDATE statements.
|
|
*************************************************************************
|
|
** Included in SQLite3 port to C#-SQLite; 2008 Noah B Hart
|
|
** C#-SQLite is an independent reimplementation of the SQLite software library
|
|
**
|
|
** SQLITE_SOURCE_ID: 2011-06-23 19:49:22 4374b7e83ea0a3fbc3691f9c0c936272862f32f2
|
|
**
|
|
*************************************************************************
|
|
*/
|
|
//#include "sqliteInt.h"
|
|
|
|
#if !SQLITE_OMIT_VIRTUALTABLE
|
|
/* Forward declaration */
|
|
//static void updateVirtualTable(
|
|
//Parse pParse, /* The parsing context */
|
|
//SrcList pSrc, /* The virtual table to be modified */
|
|
//Table pTab, /* The virtual table */
|
|
//ExprList pChanges, /* The columns to change in the UPDATE statement */
|
|
//Expr pRowidExpr, /* Expression used to recompute the rowid */
|
|
//int aXRef, /* Mapping from columns of pTab to entries in pChanges */
|
|
//Expr *pWhere, /* WHERE clause of the UPDATE statement */
|
|
//int onError /* ON CONFLICT strategy */
|
|
//);
|
|
#endif // * SQLITE_OMIT_VIRTUALTABLE */
|
|
|
|
/*
|
|
** The most recently coded instruction was an OP_Column to retrieve the
|
|
** i-th column of table pTab. This routine sets the P4 parameter of the
|
|
** OP_Column to the default value, if any.
|
|
**
|
|
** The default value of a column is specified by a DEFAULT clause in the
|
|
** column definition. This was either supplied by the user when the table
|
|
** was created, or added later to the table definition by an ALTER TABLE
|
|
** command. If the latter, then the row-records in the table btree on disk
|
|
** may not contain a value for the column and the default value, taken
|
|
** from the P4 parameter of the OP_Column instruction, is returned instead.
|
|
** If the former, then all row-records are guaranteed to include a value
|
|
** for the column and the P4 value is not required.
|
|
**
|
|
** Column definitions created by an ALTER TABLE command may only have
|
|
** literal default values specified: a number, null or a string. (If a more
|
|
** complicated default expression value was provided, it is evaluated
|
|
** when the ALTER TABLE is executed and one of the literal values written
|
|
** into the sqlite_master table.)
|
|
**
|
|
** Therefore, the P4 parameter is only required if the default value for
|
|
** the column is a literal number, string or null. The sqlite3ValueFromExpr()
|
|
** function is capable of transforming these types of expressions into
|
|
** sqlite3_value objects.
|
|
**
|
|
** If parameter iReg is not negative, code an OP_RealAffinity instruction
|
|
** on register iReg. This is used when an equivalent integer value is
|
|
** stored in place of an 8-byte floating point value in order to save
|
|
** space.
|
|
*/
|
|
|
|
private static void sqlite3ColumnDefault(Vdbe v, Table pTab, int i, int iReg)
|
|
{
|
|
Debug.Assert(pTab != null);
|
|
if (null == pTab.pSelect)
|
|
{
|
|
sqlite3_value pValue = new sqlite3_value();
|
|
int enc = ENC(sqlite3VdbeDb(v));
|
|
Column pCol = pTab.aCol[i];
|
|
#if SQLITE_DEBUG
|
|
VdbeComment(v, "%s.%s", pTab.zName, pCol.zName);
|
|
#endif
|
|
Debug.Assert(i < pTab.nCol);
|
|
sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol.pDflt, enc,
|
|
pCol.affinity, ref pValue);
|
|
if (pValue != null)
|
|
{
|
|
sqlite3VdbeChangeP4(v, -1, pValue, P4_MEM);
|
|
}
|
|
#if !SQLITE_OMIT_FLOATING_POINT
|
|
if (iReg >= 0 && pTab.aCol[i].affinity == SQLITE_AFF_REAL)
|
|
{
|
|
sqlite3VdbeAddOp1(v, OP_RealAffinity, iReg);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Process an UPDATE statement.
|
|
**
|
|
** UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL;
|
|
** \_______/ \________/ \______/ \________________/
|
|
* onError pTabList pChanges pWhere
|
|
*/
|
|
|
|
private static void sqlite3Update(
|
|
Parse pParse, /* The parser context */
|
|
SrcList pTabList, /* The table in which we should change things */
|
|
ExprList pChanges, /* Things to be changed */
|
|
Expr pWhere, /* The WHERE clause. May be null */
|
|
int onError /* How to handle constraint errors */
|
|
)
|
|
{
|
|
int i, j; /* Loop counters */
|
|
Table pTab; /* The table to be updated */
|
|
int addr = 0; /* VDBE instruction address of the start of the loop */
|
|
WhereInfo pWInfo; /* Information about the WHERE clause */
|
|
Vdbe v; /* The virtual database engine */
|
|
Index pIdx; /* For looping over indices */
|
|
int nIdx; /* Number of indices that need updating */
|
|
int iCur; /* VDBE Cursor number of pTab */
|
|
sqlite3 db; /* The database structure */
|
|
int[] aRegIdx = null; /* One register assigned to each index to be updated */
|
|
int[] aXRef = null; /* aXRef[i] is the index in pChanges.a[] of the
|
|
** an expression for the i-th column of the table.
|
|
** aXRef[i]==-1 if the i-th column is not changed. */
|
|
bool chngRowid; /* True if the record number is being changed */
|
|
Expr pRowidExpr = null; /* Expression defining the new record number */
|
|
bool openAll = false; /* True if all indices need to be opened */
|
|
AuthContext sContext; /* The authorization context */
|
|
NameContext sNC; /* The name-context to resolve expressions in */
|
|
int iDb; /* Database containing the table being updated */
|
|
bool okOnePass; /* True for one-pass algorithm without the FIFO */
|
|
bool hasFK; /* True if foreign key processing is required */
|
|
|
|
#if !SQLITE_OMIT_TRIGGER
|
|
bool isView; /* True when updating a view (INSTEAD OF trigger) */
|
|
Trigger pTrigger; /* List of triggers on pTab, if required */
|
|
int tmask = 0; /* Mask of TRIGGER_BEFORE|TRIGGER_AFTER */
|
|
#endif
|
|
int newmask; /* Mask of NEW.* columns accessed by BEFORE triggers */
|
|
|
|
/* Register Allocations */
|
|
int regRowCount = 0; /* A count of rows changed */
|
|
int regOldRowid; /* The old rowid */
|
|
int regNewRowid; /* The new rowid */
|
|
int regNew;
|
|
int regOld = 0;
|
|
int regRowSet = 0; /* Rowset of rows to be updated */
|
|
|
|
sContext = new AuthContext(); //memset( &sContext, 0, sizeof( sContext ) );
|
|
db = pParse.db;
|
|
if (pParse.nErr != 0 /*|| db.mallocFailed != 0 */ )
|
|
{
|
|
goto update_cleanup;
|
|
}
|
|
Debug.Assert(pTabList.nSrc == 1);
|
|
|
|
/* Locate the table which we want to update.
|
|
*/
|
|
pTab = sqlite3SrcListLookup(pParse, pTabList);
|
|
if (pTab == null)
|
|
goto update_cleanup;
|
|
iDb = sqlite3SchemaToIndex(pParse.db, pTab.pSchema);
|
|
|
|
/* Figure out if we have any triggers and if the table being
|
|
** updated is a view.
|
|
*/
|
|
#if !SQLITE_OMIT_TRIGGER
|
|
pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, out tmask);
|
|
isView = pTab.pSelect != null;
|
|
Debug.Assert(pTrigger != null || tmask == 0);
|
|
#else
|
|
const Trigger pTrigger = null;//# define pTrigger 0
|
|
const int tmask = 0; //# define tmask 0
|
|
#endif
|
|
#if SQLITE_OMIT_TRIGGER || SQLITE_OMIT_VIEW
|
|
// # undef isView
|
|
const bool isView = false; //# define isView 0
|
|
#endif
|
|
|
|
if (sqlite3ViewGetColumnNames(pParse, pTab) != 0)
|
|
{
|
|
goto update_cleanup;
|
|
}
|
|
if (sqlite3IsReadOnly(pParse, pTab, tmask))
|
|
{
|
|
goto update_cleanup;
|
|
}
|
|
aXRef = new int[pTab.nCol];// sqlite3DbMallocRaw(db, sizeof(int) * pTab.nCol);
|
|
//if ( aXRef == null ) goto update_cleanup;
|
|
for (i = 0; i < pTab.nCol; i++)
|
|
aXRef[i] = -1;
|
|
|
|
/* Allocate a cursors for the main database table and for all indices.
|
|
** The index cursors might not be used, but if they are used they
|
|
** need to occur right after the database cursor. So go ahead and
|
|
** allocate enough space, just in case.
|
|
*/
|
|
pTabList.a[0].iCursor = iCur = pParse.nTab++;
|
|
for (pIdx = pTab.pIndex; pIdx != null; pIdx = pIdx.pNext)
|
|
{
|
|
pParse.nTab++;
|
|
}
|
|
|
|
/* Initialize the name-context */
|
|
sNC = new NameContext();// memset(&sNC, 0, sNC).Length;
|
|
sNC.pParse = pParse;
|
|
sNC.pSrcList = pTabList;
|
|
|
|
/* Resolve the column names in all the expressions of the
|
|
** of the UPDATE statement. Also find the column index
|
|
** for each column to be updated in the pChanges array. For each
|
|
** column to be updated, make sure we have authorization to change
|
|
** that column.
|
|
*/
|
|
chngRowid = false;
|
|
for (i = 0; i < pChanges.nExpr; i++)
|
|
{
|
|
if (sqlite3ResolveExprNames(sNC, ref pChanges.a[i].pExpr) != 0)
|
|
{
|
|
goto update_cleanup;
|
|
}
|
|
for (j = 0; j < pTab.nCol; j++)
|
|
{
|
|
if (pTab.aCol[j].zName.Equals(pChanges.a[i].zName, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
if (j == pTab.iPKey)
|
|
{
|
|
chngRowid = true;
|
|
pRowidExpr = pChanges.a[i].pExpr;
|
|
}
|
|
aXRef[j] = i;
|
|
break;
|
|
}
|
|
}
|
|
if (j >= pTab.nCol)
|
|
{
|
|
if (sqlite3IsRowid(pChanges.a[i].zName))
|
|
{
|
|
chngRowid = true;
|
|
pRowidExpr = pChanges.a[i].pExpr;
|
|
}
|
|
else
|
|
{
|
|
sqlite3ErrorMsg(pParse, "no such column: %s", pChanges.a[i].zName);
|
|
pParse.checkSchema = 1;
|
|
goto update_cleanup;
|
|
}
|
|
}
|
|
#if !SQLITE_OMIT_AUTHORIZATION
|
|
{
|
|
int rc;
|
|
rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab.zName,
|
|
pTab.aCol[j].zName, db.aDb[iDb].zName);
|
|
if( rc==SQLITE_DENY ){
|
|
goto update_cleanup;
|
|
}else if( rc==SQLITE_IGNORE ){
|
|
aXRef[j] = -1;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngRowid ? 1 : 0) != 0;
|
|
|
|
/* Allocate memory for the array aRegIdx[]. There is one entry in the
|
|
** array for each index associated with table being updated. Fill in
|
|
** the value with a register number for indices that are to be used
|
|
** and with zero for unused indices.
|
|
*/
|
|
for (nIdx = 0, pIdx = pTab.pIndex; pIdx != null; pIdx = pIdx.pNext, nIdx++)
|
|
{
|
|
}
|
|
if (nIdx > 0)
|
|
{
|
|
aRegIdx = new int[nIdx]; // sqlite3DbMallocRaw(db, Index*.Length * nIdx);
|
|
if (aRegIdx == null)
|
|
goto update_cleanup;
|
|
}
|
|
for (j = 0, pIdx = pTab.pIndex; pIdx != null; pIdx = pIdx.pNext, j++)
|
|
{
|
|
int reg;
|
|
if (hasFK || chngRowid)
|
|
{
|
|
reg = ++pParse.nMem;
|
|
}
|
|
else
|
|
{
|
|
reg = 0;
|
|
for (i = 0; i < pIdx.nColumn; i++)
|
|
{
|
|
if (aXRef[pIdx.aiColumn[i]] >= 0)
|
|
{
|
|
reg = ++pParse.nMem;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
aRegIdx[j] = reg;
|
|
}
|
|
|
|
/* Begin generating code. */
|
|
v = sqlite3GetVdbe(pParse);
|
|
if (v == null)
|
|
goto update_cleanup;
|
|
if (pParse.nested == 0)
|
|
sqlite3VdbeCountChanges(v);
|
|
sqlite3BeginWriteOperation(pParse, 1, iDb);
|
|
|
|
#if !SQLITE_OMIT_VIRTUALTABLE
|
|
/* Virtual tables must be handled separately */
|
|
if (IsVirtual(pTab))
|
|
{
|
|
updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
|
|
pWhere, onError);
|
|
pWhere = null;
|
|
pTabList = null;
|
|
goto update_cleanup;
|
|
}
|
|
#endif
|
|
|
|
/* Allocate required registers. */
|
|
regOldRowid = regNewRowid = ++pParse.nMem;
|
|
if (pTrigger != null || hasFK)
|
|
{
|
|
regOld = pParse.nMem + 1;
|
|
pParse.nMem += pTab.nCol;
|
|
}
|
|
if (chngRowid || pTrigger != null || hasFK)
|
|
{
|
|
regNewRowid = ++pParse.nMem;
|
|
}
|
|
regNew = pParse.nMem + 1;
|
|
pParse.nMem += pTab.nCol;
|
|
|
|
/* Start the view context. */
|
|
if (isView)
|
|
{
|
|
sqlite3AuthContextPush(pParse, sContext, pTab.zName);
|
|
}
|
|
|
|
/* If we are trying to update a view, realize that view into
|
|
** a ephemeral table.
|
|
*/
|
|
#if !(SQLITE_OMIT_VIEW) && !(SQLITE_OMIT_TRIGGER)
|
|
if (isView)
|
|
{
|
|
sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
|
|
}
|
|
#endif
|
|
|
|
/* Resolve the column names in all the expressions in the
|
|
** WHERE clause.
|
|
*/
|
|
if (sqlite3ResolveExprNames(sNC, ref pWhere) != 0)
|
|
{
|
|
goto update_cleanup;
|
|
}
|
|
|
|
/* Begin the database scan
|
|
*/
|
|
sqlite3VdbeAddOp2(v, OP_Null, 0, regOldRowid);
|
|
ExprList NullOrderby = null;
|
|
pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, ref NullOrderby, WHERE_ONEPASS_DESIRED);
|
|
if (pWInfo == null)
|
|
goto update_cleanup;
|
|
okOnePass = pWInfo.okOnePass != 0;
|
|
|
|
/* Remember the rowid of every item to be updated.
|
|
*/
|
|
sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regOldRowid);
|
|
if (!okOnePass)
|
|
{
|
|
regRowSet = ++pParse.nMem;
|
|
sqlite3VdbeAddOp2(v, OP_RowSetAdd, regRowSet, regOldRowid);
|
|
}
|
|
|
|
/* End the database scan loop.
|
|
*/
|
|
sqlite3WhereEnd(pWInfo);
|
|
|
|
/* Initialize the count of updated rows
|
|
*/
|
|
if ((db.flags & SQLITE_CountRows) != 0 && null == pParse.pTriggerTab)
|
|
{
|
|
regRowCount = ++pParse.nMem;
|
|
sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
|
|
}
|
|
|
|
if (!isView)
|
|
{
|
|
/*
|
|
** Open every index that needs updating. Note that if any
|
|
** index could potentially invoke a REPLACE conflict resolution
|
|
** action, then we need to open all indices because we might need
|
|
** to be deleting some records.
|
|
*/
|
|
if (!okOnePass)
|
|
sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
|
|
if (onError == OE_Replace)
|
|
{
|
|
openAll = true;
|
|
}
|
|
else
|
|
{
|
|
openAll = false;
|
|
for (pIdx = pTab.pIndex; pIdx != null; pIdx = pIdx.pNext)
|
|
{
|
|
if (pIdx.onError == OE_Replace)
|
|
{
|
|
openAll = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
for (i = 0, pIdx = pTab.pIndex; pIdx != null; pIdx = pIdx.pNext, i++)
|
|
{
|
|
if (openAll || aRegIdx[i] > 0)
|
|
{
|
|
KeyInfo pKey = sqlite3IndexKeyinfo(pParse, pIdx);
|
|
sqlite3VdbeAddOp4(v, OP_OpenWrite, iCur + i + 1, pIdx.tnum, iDb,
|
|
pKey, P4_KEYINFO_HANDOFF);
|
|
Debug.Assert(pParse.nTab > iCur + i + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Top of the update loop */
|
|
if (okOnePass)
|
|
{
|
|
int a1 = sqlite3VdbeAddOp1(v, OP_NotNull, regOldRowid);
|
|
addr = sqlite3VdbeAddOp0(v, OP_Goto);
|
|
sqlite3VdbeJumpHere(v, a1);
|
|
}
|
|
else
|
|
{
|
|
addr = sqlite3VdbeAddOp3(v, OP_RowSetRead, regRowSet, 0, regOldRowid);
|
|
}
|
|
|
|
/* Make cursor iCur point to the record that is being updated. If
|
|
** this record does not exist for some reason (deleted by a trigger,
|
|
** for example, then jump to the next iteration of the RowSet loop. */
|
|
sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
|
|
|
|
/* If the record number will change, set register regNewRowid to
|
|
** contain the new value. If the record number is not being modified,
|
|
** then regNewRowid is the same register as regOldRowid, which is
|
|
** already populated. */
|
|
Debug.Assert(chngRowid || pTrigger != null || hasFK || regOldRowid == regNewRowid);
|
|
if (chngRowid)
|
|
{
|
|
sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
|
|
sqlite3VdbeAddOp1(v, OP_MustBeInt, regNewRowid);
|
|
}
|
|
|
|
/* If there are triggers on this table, populate an array of registers
|
|
** with the required old.* column data. */
|
|
if (hasFK || pTrigger != null)
|
|
{
|
|
u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
|
|
oldmask |= sqlite3TriggerColmask(pParse,
|
|
pTrigger, pChanges, 0, TRIGGER_BEFORE | TRIGGER_AFTER, pTab, onError
|
|
);
|
|
for (i = 0; i < pTab.nCol; i++)
|
|
{
|
|
if (aXRef[i] < 0 || oldmask == 0xffffffff || (i < 32 && 0 != (oldmask & (1 << i))))
|
|
{
|
|
sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOld + i);
|
|
}
|
|
else
|
|
{
|
|
sqlite3VdbeAddOp2(v, OP_Null, 0, regOld + i);
|
|
}
|
|
}
|
|
if (chngRowid == false)
|
|
{
|
|
sqlite3VdbeAddOp2(v, OP_Copy, regOldRowid, regNewRowid);
|
|
}
|
|
}
|
|
|
|
/* Populate the array of registers beginning at regNew with the new
|
|
** row data. This array is used to check constaints, create the new
|
|
** table and index records, and as the values for any new.* references
|
|
** made by triggers.
|
|
**
|
|
** If there are one or more BEFORE triggers, then do not populate the
|
|
** registers associated with columns that are (a) not modified by
|
|
** this UPDATE statement and (b) not accessed by new.* references. The
|
|
** values for registers not modified by the UPDATE must be reloaded from
|
|
** the database after the BEFORE triggers are fired anyway (as the trigger
|
|
** may have modified them). So not loading those that are not going to
|
|
** be used eliminates some redundant opcodes.
|
|
*/
|
|
newmask = (int)sqlite3TriggerColmask(
|
|
pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
|
|
);
|
|
for (i = 0; i < pTab.nCol; i++)
|
|
{
|
|
if (i == pTab.iPKey)
|
|
{
|
|
sqlite3VdbeAddOp2(v, OP_Null, 0, regNew + i);
|
|
}
|
|
else
|
|
{
|
|
j = aXRef[i];
|
|
if (j >= 0)
|
|
{
|
|
sqlite3ExprCode(pParse, pChanges.a[j].pExpr, regNew + i);
|
|
}
|
|
else if (0 == (tmask & TRIGGER_BEFORE) || i > 31 || (newmask & (1 << i)) != 0)
|
|
{
|
|
/* This branch loads the value of a column that will not be changed
|
|
** into a register. This is done if there are no BEFORE triggers, or
|
|
** if there are one or more BEFORE triggers that use this value via
|
|
** a new.* reference in a trigger program.
|
|
*/
|
|
testcase(i == 31);
|
|
testcase(i == 32);
|
|
sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regNew + i);
|
|
sqlite3ColumnDefault(v, pTab, i, regNew + i);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Fire any BEFORE UPDATE triggers. This happens before constraints are
|
|
** verified. One could argue that this is wrong.
|
|
*/
|
|
if ((tmask & TRIGGER_BEFORE) != 0)
|
|
{
|
|
sqlite3VdbeAddOp2(v, OP_Affinity, regNew, pTab.nCol);
|
|
sqlite3TableAffinityStr(v, pTab);
|
|
sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
|
|
TRIGGER_BEFORE, pTab, regOldRowid, onError, addr);
|
|
|
|
/* The row-trigger may have deleted the row being updated. In this
|
|
** case, jump to the next row. No updates or AFTER triggers are
|
|
** required. This behaviour - what happens when the row being updated
|
|
** is deleted or renamed by a BEFORE trigger - is left undefined in the
|
|
** documentation.
|
|
*/
|
|
sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addr, regOldRowid);
|
|
|
|
/* If it did not delete it, the row-trigger may still have modified
|
|
** some of the columns of the row being updated. Load the values for
|
|
** all columns not modified by the update statement into their
|
|
** registers in case this has happened.
|
|
*/
|
|
for (i = 0; i < pTab.nCol; i++)
|
|
{
|
|
if (aXRef[i] < 0 && i != pTab.iPKey)
|
|
{
|
|
sqlite3VdbeAddOp3(v, OP_Column, iCur, i, regNew + i);
|
|
sqlite3ColumnDefault(v, pTab, i, regNew + i);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!isView)
|
|
{
|
|
int j1; /* Address of jump instruction */
|
|
|
|
/* Do constraint checks. */
|
|
int iDummy;
|
|
sqlite3GenerateConstraintChecks(pParse, pTab, iCur, regNewRowid,
|
|
aRegIdx, (chngRowid ? regOldRowid : 0), true, onError, addr, out iDummy);
|
|
|
|
/* Do FK constraint checks. */
|
|
if (hasFK)
|
|
{
|
|
sqlite3FkCheck(pParse, pTab, regOldRowid, 0);
|
|
}
|
|
|
|
/* Delete the index entries associated with the current record. */
|
|
j1 = sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regOldRowid);
|
|
sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, aRegIdx);
|
|
|
|
/* If changing the record number, delete the old record. */
|
|
if (hasFK || chngRowid)
|
|
{
|
|
sqlite3VdbeAddOp2(v, OP_Delete, iCur, 0);
|
|
}
|
|
sqlite3VdbeJumpHere(v, j1);
|
|
|
|
if (hasFK)
|
|
{
|
|
sqlite3FkCheck(pParse, pTab, 0, regNewRowid);
|
|
}
|
|
|
|
/* Insert the new index entries and the new record. */
|
|
sqlite3CompleteInsertion(pParse, pTab, iCur, regNewRowid, aRegIdx, true, false, false);
|
|
|
|
/* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
|
|
** handle rows (possibly in other tables) that refer via a foreign key
|
|
** to the row just updated. */
|
|
if (hasFK)
|
|
{
|
|
sqlite3FkActions(pParse, pTab, pChanges, regOldRowid);
|
|
}
|
|
}
|
|
|
|
/* Increment the row counter
|
|
*/
|
|
if ((db.flags & SQLITE_CountRows) != 0 && null == pParse.pTriggerTab)
|
|
{
|
|
sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
|
|
}
|
|
|
|
sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
|
|
TRIGGER_AFTER, pTab, regOldRowid, onError, addr);
|
|
|
|
/* Repeat the above with the next record to be updated, until
|
|
** all record selected by the WHERE clause have been updated.
|
|
*/
|
|
sqlite3VdbeAddOp2(v, OP_Goto, 0, addr);
|
|
sqlite3VdbeJumpHere(v, addr);
|
|
|
|
/* Close all tables */
|
|
for (i = 0, pIdx = pTab.pIndex; pIdx != null; pIdx = pIdx.pNext, i++)
|
|
{
|
|
if (openAll || aRegIdx[i] > 0)
|
|
{
|
|
sqlite3VdbeAddOp2(v, OP_Close, iCur + i + 1, 0);
|
|
}
|
|
}
|
|
sqlite3VdbeAddOp2(v, OP_Close, iCur, 0);
|
|
|
|
/* Update the sqlite_sequence table by storing the content of the
|
|
** maximum rowid counter values recorded while inserting into
|
|
** autoincrement tables.
|
|
*/
|
|
if (pParse.nested == 0 && pParse.pTriggerTab == null)
|
|
{
|
|
sqlite3AutoincrementEnd(pParse);
|
|
}
|
|
|
|
/*
|
|
** Return the number of rows that were changed. If this routine is
|
|
** generating code because of a call to sqlite3NestedParse(), do not
|
|
** invoke the callback function.
|
|
*/
|
|
if ((db.flags & SQLITE_CountRows) != 0 && null == pParse.pTriggerTab && 0 == pParse.nested)
|
|
{
|
|
sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
|
|
sqlite3VdbeSetNumCols(v, 1);
|
|
sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows updated", SQLITE_STATIC);
|
|
}
|
|
|
|
update_cleanup:
|
|
#if !SQLITE_OMIT_AUTHORIZATION
|
|
sqlite3AuthContextPop(sContext);
|
|
#endif
|
|
sqlite3DbFree(db, ref aRegIdx);
|
|
sqlite3DbFree(db, ref aXRef);
|
|
sqlite3SrcListDelete(db, ref pTabList);
|
|
sqlite3ExprListDelete(db, ref pChanges);
|
|
sqlite3ExprDelete(db, ref pWhere);
|
|
return;
|
|
}
|
|
|
|
/* Make sure "isView" and other macros defined above are undefined. Otherwise
|
|
** thely may interfere with compilation of other functions in this file
|
|
** (or in another file, if this file becomes part of the amalgamation). */
|
|
//#if isView
|
|
// #undef isView
|
|
//#endif
|
|
//#if pTrigger
|
|
// #undef pTrigger
|
|
//#endif
|
|
|
|
#if !SQLITE_OMIT_VIRTUALTABLE
|
|
/*
|
|
** Generate code for an UPDATE of a virtual table.
|
|
**
|
|
** The strategy is that we create an ephemerial table that contains
|
|
** for each row to be changed:
|
|
**
|
|
** (A) The original rowid of that row.
|
|
** (B) The revised rowid for the row. (note1)
|
|
** (C) The content of every column in the row.
|
|
**
|
|
** Then we loop over this ephemeral table and for each row in
|
|
** the ephermeral table call VUpdate.
|
|
**
|
|
** When finished, drop the ephemeral table.
|
|
**
|
|
** (note1) Actually, if we know in advance that (A) is always the same
|
|
** as (B) we only store (A), then duplicate (A) when pulling
|
|
** it out of the ephemeral table before calling VUpdate.
|
|
*/
|
|
|
|
private static void updateVirtualTable(
|
|
Parse pParse, /* The parsing context */
|
|
SrcList pSrc, /* The virtual table to be modified */
|
|
Table pTab, /* The virtual table */
|
|
ExprList pChanges, /* The columns to change in the UPDATE statement */
|
|
Expr pRowid, /* Expression used to recompute the rowid */
|
|
int[] aXRef, /* Mapping from columns of pTab to entries in pChanges */
|
|
Expr pWhere, /* WHERE clause of the UPDATE statement */
|
|
int onError /* ON CONFLICT strategy */
|
|
)
|
|
{
|
|
Vdbe v = pParse.pVdbe; /* Virtual machine under construction */
|
|
ExprList pEList = null; /* The result set of the SELECT statement */
|
|
Select pSelect = null; /* The SELECT statement */
|
|
Expr pExpr; /* Temporary expression */
|
|
int ephemTab; /* Table holding the result of the SELECT */
|
|
int i; /* Loop counter */
|
|
int addr; /* Address of top of loop */
|
|
int iReg; /* First register in set passed to OP_VUpdate */
|
|
sqlite3 db = pParse.db; /* Database connection */
|
|
VTable pVTab = sqlite3GetVTable(db, pTab);
|
|
SelectDest dest = new SelectDest();
|
|
|
|
/* Construct the SELECT statement that will find the new values for
|
|
** all updated rows.
|
|
*/
|
|
pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, "_rowid_"));
|
|
if (pRowid != null)
|
|
{
|
|
pEList = sqlite3ExprListAppend(pParse, pEList,
|
|
sqlite3ExprDup(db, pRowid, 0));
|
|
}
|
|
Debug.Assert(pTab.iPKey < 0);
|
|
for (i = 0; i < pTab.nCol; i++)
|
|
{
|
|
if (aXRef[i] >= 0)
|
|
{
|
|
pExpr = sqlite3ExprDup(db, pChanges.a[aXRef[i]].pExpr, 0);
|
|
}
|
|
else
|
|
{
|
|
pExpr = sqlite3Expr(db, TK_ID, pTab.aCol[i].zName);
|
|
}
|
|
pEList = sqlite3ExprListAppend(pParse, pEList, pExpr);
|
|
}
|
|
pSelect = sqlite3SelectNew(pParse, pEList, pSrc, pWhere, null, null, null, 0, null, null);
|
|
|
|
/* Create the ephemeral table into which the update results will
|
|
** be stored.
|
|
*/
|
|
Debug.Assert(v != null);
|
|
ephemTab = pParse.nTab++;
|
|
sqlite3VdbeAddOp2(v, OP_OpenEphemeral, ephemTab, pTab.nCol + 1 + ((pRowid != null) ? 1 : 0));
|
|
sqlite3VdbeChangeP5(v, BTREE_UNORDERED);
|
|
|
|
/* fill the ephemeral table
|
|
*/
|
|
sqlite3SelectDestInit(dest, SRT_Table, ephemTab);
|
|
sqlite3Select(pParse, pSelect, ref dest);
|
|
|
|
/* Generate code to scan the ephemeral table and call VUpdate. */
|
|
iReg = ++pParse.nMem;
|
|
pParse.nMem += pTab.nCol + 1;
|
|
addr = sqlite3VdbeAddOp2(v, OP_Rewind, ephemTab, 0);
|
|
sqlite3VdbeAddOp3(v, OP_Column, ephemTab, 0, iReg);
|
|
sqlite3VdbeAddOp3(v, OP_Column, ephemTab, (pRowid != null ? 1 : 0), iReg + 1);
|
|
for (i = 0; i < pTab.nCol; i++)
|
|
{
|
|
sqlite3VdbeAddOp3(v, OP_Column, ephemTab, i + 1 + ((pRowid != null) ? 1 : 0), iReg + 2 + i);
|
|
}
|
|
sqlite3VtabMakeWritable(pParse, pTab);
|
|
sqlite3VdbeAddOp4(v, OP_VUpdate, 0, pTab.nCol + 2, iReg, pVTab, P4_VTAB);
|
|
sqlite3VdbeChangeP5(v, (byte)(onError == OE_Default ? OE_Abort : onError));
|
|
sqlite3MayAbort(pParse);
|
|
sqlite3VdbeAddOp2(v, OP_Next, ephemTab, addr + 1);
|
|
sqlite3VdbeJumpHere(v, addr);
|
|
sqlite3VdbeAddOp2(v, OP_Close, ephemTab, 0);
|
|
|
|
/* Cleanup */
|
|
sqlite3SelectDelete(db, ref pSelect);
|
|
}
|
|
|
|
#endif // * SQLITE_OMIT_VIRTUALTABLE */
|
|
}
|
|
} |