-C Replace\sthe\sOP_IsUnique\sopcode\swith\sOP_NoConflict.\s\sThis\scode\ssimplification\nmight\sbe\suseful\sto\smove\sonto\strunk\seven\sif\sthis\sbranch\sis\snever\smerged.
-D 2013-10-26T13:36:51.811
+C Work\son\sthe\sUPDATE\sand\sINSERT\slogic.\s\sThis\sis\san\sincremental\scheck-in\sso\sthat\ncan\sswitch\sover\sto\strunk\sto\swork\son\san\sunrelated\sissue\sthere.
+D 2013-10-26T15:40:48.224
F Makefile.arm-wince-mingw32ce-gcc d6df77f1f48d690bd73162294bbba7f59507c72f
F Makefile.in 0522b53cdc1fcfc18f3a98e0246add129136c654
F Makefile.linux-gcc 91d710bdc4998cb015f39edf3cb314ec4f4d7e23
F src/hash.c ac3470bbf1ca4ae4e306a8ecb0fdf1731810ffe4
F src/hash.h 8890a25af81fb85a9ad7790d32eedab4b994da22
F src/hwtime.h d32741c8f4df852c7d959236615444e2b1063b08
-F src/insert.c e87728415d32d6f572f5578c2107e382d1dd8203
+F src/insert.c 14ae816acbebd927bc070bf684de638f78cfccba
F src/journal.c b4124532212b6952f42eb2c12fa3c25701d8ba8d
F src/legacy.c 0df0b1550b9cc1f58229644735e317ac89131f12
F src/lempar.c cdf0a000315332fc9b50b62f3b5e22e080a0952b
F src/utf.c 6fc6c88d50448c469c5c196acf21617a24f90269
F src/util.c 2fa6c821d28bbdbeec1b2a7b091a281c9ef8f918
F src/vacuum.c 3728d74919d4fb1356f9e9a13e27773db60b7179
-F src/vdbe.c 115f2c06e4d943d289599a46634514bf94479db4
+F src/vdbe.c 7d23d61c84cb1116e36a70b050f2a4ae1a2aaae3
F src/vdbe.h 4f554b5627f26710c4c36d919110a3fc611ca5c4
-F src/vdbeInt.h ff57f67aee1ba26a3a47e786533dab155ab6dad6
+F src/vdbeInt.h 42dcff74dbeb2b071e569b53f885fc9c2e4b4cb0
F src/vdbeapi.c 93a22a9ba2abe292d5c2cf304d7eb2e894dde0ed
F src/vdbeaux.c 4ccdfd27f97fec98385f53fc8c880f1873137d95
F src/vdbeblob.c ef973d8d9f8170015343dd8824f795da675caa87
F tool/warnings-clang.sh f6aa929dc20ef1f856af04a730772f59283631d4
F tool/warnings.sh d1a6de74685f360ab718efda6265994b99bbea01
F tool/win/sqlite.vsix 030f3eeaf2cb811a3692ab9c14d021a75ce41fff
-P ae61a34378d3ed2f454ba8768029d6f5fef849e4
-R 4e2e179014c5b2ce47e50b4ad5c73b59
+P e6650e16dd11327afd25961b2feb29ec8778c2ca
+R bb18c22d259a405d56d9b91ea7100e63
U drh
-Z bf09176aa6b2dce2a1f786b527e72d8e
+Z 6434b0048c9e4cb6010b12b4a2aa5b2d
#undef tmask
#endif
+/*
+** If regFirst is a set of value for a table row in table order and pPk
+** is the PRIMARY KEY index for that table, then return the index of the
+** first register in a contiguous array of registers that are the primary
+** key values for the table row.
+**
+** For the common cases where the PRIMARY KEY has only a single value or
+** where a multi-value PRIMARY KEY is contiguous in table order, this
+** routine simply returns a pointer into the regFirst array. But if there
+** is a multi-value PRIMARY KEY with the values out-of-order, this routine
+** has to generate code that will copy PRIMARY KEY values into newly
+** allocated contiguous registers.
+*/
+static int sqlite3PrimaryKeyRegisters(Parse *pParse, Index *pPk, int regFirst){
+ int i;
+ int nKeyCol = pPk->nKeyCol;
+ int regPk;
+ assert( pParse->pVdbe!=0 );
+ if( nKeyCol==1 ){
+ return regFirst + pPk->aiColumn[0];
+ }
+ for(i=1; i<nKeyCol; i++){
+ if( pPk->aiColumn[i-1]+1!=pPk->aiColumn[i] ) break;
+ }
+ if( i==nKeyCol ){
+ return regFirst + pPk->aiColumn[0];
+ }
+ regPk = pParse->nMem+1;
+ pParse->nMem += nKeyCol;
+ for(i=0; i<nKeyCol; i++){
+ int x = pPk->aiColumn[i];
+ sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, regFirst+x, regPk+i);
+ }
+ return regPk;
+}
+
/*
** Generate code to do constraint checks prior to an INSERT or an UPDATE.
**
** The input is a range of consecutive registers as follows:
**
-** 1. The rowid of the row after the update. (This register
-** contains a NULL for WITHOUT ROWID tables.)
+** 1. The rowid of the row after the update, or NULL
+** for WITHOUT ROWID tables.
**
** 2. The data in the first column of the entry after the update.
**
int baseCur, /* A read/write cursor pointing at pTab */
int regRowid, /* First register in a range holding values to insert */
int *aRegIdx, /* Register used by each index. 0 for unused indices */
- int pkChng, /* Non-zero if the PRIMARY KEY might collide */
+ int pkChng, /* Non-zero if the rowid or PRIMARY KEY changed */
int isUpdate, /* True for UPDATE, False for INSERT */
int overrideError, /* Override onError to this if not OE_Default */
int ignoreDest, /* Jump to this label on an OE_Ignore resolution */
int nCol; /* Number of columns */
int onError; /* Conflict resolution strategy */
int j1; /* Addresss of jump instruction */
- int j2 = 0, j3; /* Addresses of jump instructions */
int regData; /* Register containing first data column */
int iCur; /* Table cursor number */
Index *pIdx; /* Pointer to one of the indices */
+ Index *pPk = 0; /* The PRIMARY KEY index */
sqlite3 *db; /* Database connection */
int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */
- int regOldRowid = (pkChng && isUpdate) ? pkChng : regRowid;
+ int regOldPk; /* Previous rowid or PRIMARY KEY value */
+ int regNewPk = 0; /* New PRIMARY KEY value */
+ int pkCur = 0; /* Cursor used by the PRIMARY KEY */
+ regOldPk = (pkChng && isUpdate) ? pkChng : regRowid;
db = pParse->db;
v = sqlite3GetVdbe(pParse);
assert( v!=0 );
nCol = pTab->nCol;
regData = regRowid + 1;
+ /* For WITHOUT ROWID tables, we'll need to know the Index and the cursor
+ ** number for the PRIMARY KEY index */
+ if( !HasRowid(pTab) ){
+ pkCur = baseCur+1;
+ pPk = pTab->pIndex;
+ while( ALWAYS(pPk) && pPk->autoIndex!=2 ){
+ pPk=pPk->pNext;
+ pkCur++;
+ }
+ }
+
/* Test all NOT NULL constraints.
*/
for(i=0; i<nCol; i++){
/* If we have an INTEGER PRIMARY KEY, make sure the primary key
** of the new record does not previously exist. Except, if this
** is an UPDATE and the primary key is not changing, that is OK.
+ **
+ ** This block only runs for tables that have a rowid.
*/
- if( pkChng ){
+ if( pkChng && pkCur==0 ){
+ int addrRowidOk = sqlite3VdbeMakeLabel(v);
+
onError = pTab->keyConf;
if( overrideError!=OE_Default ){
onError = overrideError;
}else if( onError==OE_Default ){
onError = OE_Abort;
}
-
+
if( isUpdate ){
- j2 = sqlite3VdbeAddOp3(v, OP_Eq, regRowid, 0, pkChng);
+ sqlite3VdbeAddOp3(v, OP_Eq, regRowid, addrRowidOk, pkChng);
}
- j3 = sqlite3VdbeAddOp3(v, OP_NotExists, baseCur, 0, regRowid);
+ sqlite3VdbeAddOp3(v, OP_NotExists, baseCur, addrRowidOk, regRowid);
switch( onError ){
default: {
onError = OE_Abort;
break;
}
}
- sqlite3VdbeJumpHere(v, j3);
- if( isUpdate ){
- sqlite3VdbeJumpHere(v, j2);
- }
+ sqlite3VdbeResolveLabel(v, addrRowidOk);
}
/* Test all UNIQUE constraints by creating entries for each UNIQUE
** index and making sure that duplicate entries do not already exist.
- ** Add the new records to the indices as we go.
+ ** Compute the revised record entries for indices as we go.
*/
for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
int regIdx;
int regR;
- int addrSkipRow = sqlite3VdbeMakeLabel(v);
+ int idxCur = baseCur+iCur+1;
+ int addrUniqueOk = sqlite3VdbeMakeLabel(v);
if( aRegIdx[iCur]==0 ) continue; /* Skip unused indices */
if( pIdx->pPartIdxWhere ){
sqlite3VdbeAddOp2(v, OP_Null, 0, aRegIdx[iCur]);
pParse->ckBase = regData;
- sqlite3ExprIfFalse(pParse, pIdx->pPartIdxWhere, addrSkipRow,
+ sqlite3ExprIfFalse(pParse, pIdx->pPartIdxWhere, addrUniqueOk,
SQLITE_JUMPIFNULL);
pParse->ckBase = 0;
}
/* Create a key for accessing the index entry */
- regIdx = sqlite3GetTempRange(pParse, pIdx->nColumn+1);
+ regIdx = sqlite3GetTempRange(pParse, pIdx->nColumn);
for(i=0; i<pIdx->nColumn; i++){
i16 idx = pIdx->aiColumn[i];
if( idx<0 || idx==pTab->iPKey ){
onError = pIdx->onError;
if( onError==OE_None ){
sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nKeyCol+1);
- sqlite3VdbeResolveLabel(v, addrSkipRow);
+ sqlite3VdbeResolveLabel(v, addrUniqueOk);
continue; /* pIdx is not a UNIQUE index */
}
if( overrideError!=OE_Default ){
/* Check to see if the new index entry will be unique */
regR = sqlite3GetTempReg(pParse);
- sqlite3VdbeAddOp4Int(v, OP_NoConflict, baseCur+iCur+1, addrSkipRow,
+ sqlite3VdbeAddOp4Int(v, OP_NoConflict, idxCur, addrUniqueOk,
regIdx, pIdx->nKeyCol);
- sqlite3VdbeAddOp2(v, OP_IdxRowid, baseCur+iCur+1, regR);
- sqlite3VdbeAddOp3(v, OP_Eq, regR, addrSkipRow, regOldRowid);
- sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nKeyCol+1);
+ if( HasRowid(pTab) ){
+ /* Conflict only if the rowid of the existing entry with the matching
+ ** key is different from old-rowid */
+ sqlite3VdbeAddOp2(v, OP_IdxRowid, idxCur, regR);
+ sqlite3VdbeAddOp3(v, OP_Eq, regR, addrUniqueOk, regOldPk);
+ }else if( pIdx->autoIndex==2 ){
+ /* If there is a matching entry on the PRIMARY KEY index ... */
+ int addrPkConflict = sqlite3VdbeCurrentAddr(v)+pPk->nKeyCol;
+ for(i=0; i<pPk->nKeyCol-1; i++){
+ sqlite3VdbeAddOp3(v, OP_Ne,
+ regOldPk+pPk->aiColumn[i], addrPkConflict, regIdx+i);
+ }
+ sqlite3VdbeAddOp3(v, OP_Eq,
+ regOldPk+pPk->aiColumn[i], addrUniqueOk, regIdx+i);
+ }else{
+ int addrConflict = sqlite3VdbeCurrentAddr(v)+pPk->nKeyCol*2;
+ assert( pIdx->nKeyCol + pPk->nKeyCol == pIdx->nColumn );
+ for(i=0; i<pPk->nKeyCol-1; i++){
+ sqlite3VdbeAddOp3(v, OP_Column, idxCur, pIdx->nKeyCol+i, regR);
+ sqlite3VdbeAddOp3(v, OP_Ne,
+ regOldPk+pPk->aiColumn[i], addrConflict, regR);
+ }
+ sqlite3VdbeAddOp3(v, OP_Column, idxCur, pIdx->nKeyCol+i, regR);
+ sqlite3VdbeAddOp3(v, OP_Eq,
+ regOldPk+pPk->aiColumn[i], addrUniqueOk, regR);
+ }
+ sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn);
/* Generate code that executes if the new index entry is not unique */
assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
break;
}
}
- sqlite3VdbeResolveLabel(v, addrSkipRow);
+ sqlite3VdbeResolveLabel(v, addrUniqueOk);
sqlite3ReleaseTempReg(pParse, regR);
}
projects / thirdparty / sqlite.git / commitdiff
