Annotation of embedaddon/sqlite3/src/insert.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2001 September 15
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 7: ** May you do good and not evil.
! 8: ** May you find forgiveness for yourself and forgive others.
! 9: ** May you share freely, never taking more than you give.
! 10: **
! 11: *************************************************************************
! 12: ** This file contains C code routines that are called by the parser
! 13: ** to handle INSERT statements in SQLite.
! 14: */
! 15: #include "sqliteInt.h"
! 16:
! 17: /*
! 18: ** Generate code that will open a table for reading.
! 19: */
! 20: void sqlite3OpenTable(
! 21: Parse *p, /* Generate code into this VDBE */
! 22: int iCur, /* The cursor number of the table */
! 23: int iDb, /* The database index in sqlite3.aDb[] */
! 24: Table *pTab, /* The table to be opened */
! 25: int opcode /* OP_OpenRead or OP_OpenWrite */
! 26: ){
! 27: Vdbe *v;
! 28: if( IsVirtual(pTab) ) return;
! 29: v = sqlite3GetVdbe(p);
! 30: assert( opcode==OP_OpenWrite || opcode==OP_OpenRead );
! 31: sqlite3TableLock(p, iDb, pTab->tnum, (opcode==OP_OpenWrite)?1:0, pTab->zName);
! 32: sqlite3VdbeAddOp3(v, opcode, iCur, pTab->tnum, iDb);
! 33: sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(pTab->nCol), P4_INT32);
! 34: VdbeComment((v, "%s", pTab->zName));
! 35: }
! 36:
! 37: /*
! 38: ** Return a pointer to the column affinity string associated with index
! 39: ** pIdx. A column affinity string has one character for each column in
! 40: ** the table, according to the affinity of the column:
! 41: **
! 42: ** Character Column affinity
! 43: ** ------------------------------
! 44: ** 'a' TEXT
! 45: ** 'b' NONE
! 46: ** 'c' NUMERIC
! 47: ** 'd' INTEGER
! 48: ** 'e' REAL
! 49: **
! 50: ** An extra 'd' is appended to the end of the string to cover the
! 51: ** rowid that appears as the last column in every index.
! 52: **
! 53: ** Memory for the buffer containing the column index affinity string
! 54: ** is managed along with the rest of the Index structure. It will be
! 55: ** released when sqlite3DeleteIndex() is called.
! 56: */
! 57: const char *sqlite3IndexAffinityStr(Vdbe *v, Index *pIdx){
! 58: if( !pIdx->zColAff ){
! 59: /* The first time a column affinity string for a particular index is
! 60: ** required, it is allocated and populated here. It is then stored as
! 61: ** a member of the Index structure for subsequent use.
! 62: **
! 63: ** The column affinity string will eventually be deleted by
! 64: ** sqliteDeleteIndex() when the Index structure itself is cleaned
! 65: ** up.
! 66: */
! 67: int n;
! 68: Table *pTab = pIdx->pTable;
! 69: sqlite3 *db = sqlite3VdbeDb(v);
! 70: pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+2);
! 71: if( !pIdx->zColAff ){
! 72: db->mallocFailed = 1;
! 73: return 0;
! 74: }
! 75: for(n=0; n<pIdx->nColumn; n++){
! 76: pIdx->zColAff[n] = pTab->aCol[pIdx->aiColumn[n]].affinity;
! 77: }
! 78: pIdx->zColAff[n++] = SQLITE_AFF_INTEGER;
! 79: pIdx->zColAff[n] = 0;
! 80: }
! 81:
! 82: return pIdx->zColAff;
! 83: }
! 84:
! 85: /*
! 86: ** Set P4 of the most recently inserted opcode to a column affinity
! 87: ** string for table pTab. A column affinity string has one character
! 88: ** for each column indexed by the index, according to the affinity of the
! 89: ** column:
! 90: **
! 91: ** Character Column affinity
! 92: ** ------------------------------
! 93: ** 'a' TEXT
! 94: ** 'b' NONE
! 95: ** 'c' NUMERIC
! 96: ** 'd' INTEGER
! 97: ** 'e' REAL
! 98: */
! 99: void sqlite3TableAffinityStr(Vdbe *v, Table *pTab){
! 100: /* The first time a column affinity string for a particular table
! 101: ** is required, it is allocated and populated here. It is then
! 102: ** stored as a member of the Table structure for subsequent use.
! 103: **
! 104: ** The column affinity string will eventually be deleted by
! 105: ** sqlite3DeleteTable() when the Table structure itself is cleaned up.
! 106: */
! 107: if( !pTab->zColAff ){
! 108: char *zColAff;
! 109: int i;
! 110: sqlite3 *db = sqlite3VdbeDb(v);
! 111:
! 112: zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
! 113: if( !zColAff ){
! 114: db->mallocFailed = 1;
! 115: return;
! 116: }
! 117:
! 118: for(i=0; i<pTab->nCol; i++){
! 119: zColAff[i] = pTab->aCol[i].affinity;
! 120: }
! 121: zColAff[pTab->nCol] = '\0';
! 122:
! 123: pTab->zColAff = zColAff;
! 124: }
! 125:
! 126: sqlite3VdbeChangeP4(v, -1, pTab->zColAff, P4_TRANSIENT);
! 127: }
! 128:
! 129: /*
! 130: ** Return non-zero if the table pTab in database iDb or any of its indices
! 131: ** have been opened at any point in the VDBE program beginning at location
! 132: ** iStartAddr throught the end of the program. This is used to see if
! 133: ** a statement of the form "INSERT INTO <iDb, pTab> SELECT ..." can
! 134: ** run without using temporary table for the results of the SELECT.
! 135: */
! 136: static int readsTable(Parse *p, int iStartAddr, int iDb, Table *pTab){
! 137: Vdbe *v = sqlite3GetVdbe(p);
! 138: int i;
! 139: int iEnd = sqlite3VdbeCurrentAddr(v);
! 140: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 141: VTable *pVTab = IsVirtual(pTab) ? sqlite3GetVTable(p->db, pTab) : 0;
! 142: #endif
! 143:
! 144: for(i=iStartAddr; i<iEnd; i++){
! 145: VdbeOp *pOp = sqlite3VdbeGetOp(v, i);
! 146: assert( pOp!=0 );
! 147: if( pOp->opcode==OP_OpenRead && pOp->p3==iDb ){
! 148: Index *pIndex;
! 149: int tnum = pOp->p2;
! 150: if( tnum==pTab->tnum ){
! 151: return 1;
! 152: }
! 153: for(pIndex=pTab->pIndex; pIndex; pIndex=pIndex->pNext){
! 154: if( tnum==pIndex->tnum ){
! 155: return 1;
! 156: }
! 157: }
! 158: }
! 159: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 160: if( pOp->opcode==OP_VOpen && pOp->p4.pVtab==pVTab ){
! 161: assert( pOp->p4.pVtab!=0 );
! 162: assert( pOp->p4type==P4_VTAB );
! 163: return 1;
! 164: }
! 165: #endif
! 166: }
! 167: return 0;
! 168: }
! 169:
! 170: #ifndef SQLITE_OMIT_AUTOINCREMENT
! 171: /*
! 172: ** Locate or create an AutoincInfo structure associated with table pTab
! 173: ** which is in database iDb. Return the register number for the register
! 174: ** that holds the maximum rowid.
! 175: **
! 176: ** There is at most one AutoincInfo structure per table even if the
! 177: ** same table is autoincremented multiple times due to inserts within
! 178: ** triggers. A new AutoincInfo structure is created if this is the
! 179: ** first use of table pTab. On 2nd and subsequent uses, the original
! 180: ** AutoincInfo structure is used.
! 181: **
! 182: ** Three memory locations are allocated:
! 183: **
! 184: ** (1) Register to hold the name of the pTab table.
! 185: ** (2) Register to hold the maximum ROWID of pTab.
! 186: ** (3) Register to hold the rowid in sqlite_sequence of pTab
! 187: **
! 188: ** The 2nd register is the one that is returned. That is all the
! 189: ** insert routine needs to know about.
! 190: */
! 191: static int autoIncBegin(
! 192: Parse *pParse, /* Parsing context */
! 193: int iDb, /* Index of the database holding pTab */
! 194: Table *pTab /* The table we are writing to */
! 195: ){
! 196: int memId = 0; /* Register holding maximum rowid */
! 197: if( pTab->tabFlags & TF_Autoincrement ){
! 198: Parse *pToplevel = sqlite3ParseToplevel(pParse);
! 199: AutoincInfo *pInfo;
! 200:
! 201: pInfo = pToplevel->pAinc;
! 202: while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
! 203: if( pInfo==0 ){
! 204: pInfo = sqlite3DbMallocRaw(pParse->db, sizeof(*pInfo));
! 205: if( pInfo==0 ) return 0;
! 206: pInfo->pNext = pToplevel->pAinc;
! 207: pToplevel->pAinc = pInfo;
! 208: pInfo->pTab = pTab;
! 209: pInfo->iDb = iDb;
! 210: pToplevel->nMem++; /* Register to hold name of table */
! 211: pInfo->regCtr = ++pToplevel->nMem; /* Max rowid register */
! 212: pToplevel->nMem++; /* Rowid in sqlite_sequence */
! 213: }
! 214: memId = pInfo->regCtr;
! 215: }
! 216: return memId;
! 217: }
! 218:
! 219: /*
! 220: ** This routine generates code that will initialize all of the
! 221: ** register used by the autoincrement tracker.
! 222: */
! 223: void sqlite3AutoincrementBegin(Parse *pParse){
! 224: AutoincInfo *p; /* Information about an AUTOINCREMENT */
! 225: sqlite3 *db = pParse->db; /* The database connection */
! 226: Db *pDb; /* Database only autoinc table */
! 227: int memId; /* Register holding max rowid */
! 228: int addr; /* A VDBE address */
! 229: Vdbe *v = pParse->pVdbe; /* VDBE under construction */
! 230:
! 231: /* This routine is never called during trigger-generation. It is
! 232: ** only called from the top-level */
! 233: assert( pParse->pTriggerTab==0 );
! 234: assert( pParse==sqlite3ParseToplevel(pParse) );
! 235:
! 236: assert( v ); /* We failed long ago if this is not so */
! 237: for(p = pParse->pAinc; p; p = p->pNext){
! 238: pDb = &db->aDb[p->iDb];
! 239: memId = p->regCtr;
! 240: assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
! 241: sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
! 242: sqlite3VdbeAddOp3(v, OP_Null, 0, memId, memId+1);
! 243: addr = sqlite3VdbeCurrentAddr(v);
! 244: sqlite3VdbeAddOp4(v, OP_String8, 0, memId-1, 0, p->pTab->zName, 0);
! 245: sqlite3VdbeAddOp2(v, OP_Rewind, 0, addr+9);
! 246: sqlite3VdbeAddOp3(v, OP_Column, 0, 0, memId);
! 247: sqlite3VdbeAddOp3(v, OP_Ne, memId-1, addr+7, memId);
! 248: sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
! 249: sqlite3VdbeAddOp2(v, OP_Rowid, 0, memId+1);
! 250: sqlite3VdbeAddOp3(v, OP_Column, 0, 1, memId);
! 251: sqlite3VdbeAddOp2(v, OP_Goto, 0, addr+9);
! 252: sqlite3VdbeAddOp2(v, OP_Next, 0, addr+2);
! 253: sqlite3VdbeAddOp2(v, OP_Integer, 0, memId);
! 254: sqlite3VdbeAddOp0(v, OP_Close);
! 255: }
! 256: }
! 257:
! 258: /*
! 259: ** Update the maximum rowid for an autoincrement calculation.
! 260: **
! 261: ** This routine should be called when the top of the stack holds a
! 262: ** new rowid that is about to be inserted. If that new rowid is
! 263: ** larger than the maximum rowid in the memId memory cell, then the
! 264: ** memory cell is updated. The stack is unchanged.
! 265: */
! 266: static void autoIncStep(Parse *pParse, int memId, int regRowid){
! 267: if( memId>0 ){
! 268: sqlite3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid);
! 269: }
! 270: }
! 271:
! 272: /*
! 273: ** This routine generates the code needed to write autoincrement
! 274: ** maximum rowid values back into the sqlite_sequence register.
! 275: ** Every statement that might do an INSERT into an autoincrement
! 276: ** table (either directly or through triggers) needs to call this
! 277: ** routine just before the "exit" code.
! 278: */
! 279: void sqlite3AutoincrementEnd(Parse *pParse){
! 280: AutoincInfo *p;
! 281: Vdbe *v = pParse->pVdbe;
! 282: sqlite3 *db = pParse->db;
! 283:
! 284: assert( v );
! 285: for(p = pParse->pAinc; p; p = p->pNext){
! 286: Db *pDb = &db->aDb[p->iDb];
! 287: int j1, j2, j3, j4, j5;
! 288: int iRec;
! 289: int memId = p->regCtr;
! 290:
! 291: iRec = sqlite3GetTempReg(pParse);
! 292: assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
! 293: sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
! 294: j1 = sqlite3VdbeAddOp1(v, OP_NotNull, memId+1);
! 295: j2 = sqlite3VdbeAddOp0(v, OP_Rewind);
! 296: j3 = sqlite3VdbeAddOp3(v, OP_Column, 0, 0, iRec);
! 297: j4 = sqlite3VdbeAddOp3(v, OP_Eq, memId-1, 0, iRec);
! 298: sqlite3VdbeAddOp2(v, OP_Next, 0, j3);
! 299: sqlite3VdbeJumpHere(v, j2);
! 300: sqlite3VdbeAddOp2(v, OP_NewRowid, 0, memId+1);
! 301: j5 = sqlite3VdbeAddOp0(v, OP_Goto);
! 302: sqlite3VdbeJumpHere(v, j4);
! 303: sqlite3VdbeAddOp2(v, OP_Rowid, 0, memId+1);
! 304: sqlite3VdbeJumpHere(v, j1);
! 305: sqlite3VdbeJumpHere(v, j5);
! 306: sqlite3VdbeAddOp3(v, OP_MakeRecord, memId-1, 2, iRec);
! 307: sqlite3VdbeAddOp3(v, OP_Insert, 0, iRec, memId+1);
! 308: sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
! 309: sqlite3VdbeAddOp0(v, OP_Close);
! 310: sqlite3ReleaseTempReg(pParse, iRec);
! 311: }
! 312: }
! 313: #else
! 314: /*
! 315: ** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines
! 316: ** above are all no-ops
! 317: */
! 318: # define autoIncBegin(A,B,C) (0)
! 319: # define autoIncStep(A,B,C)
! 320: #endif /* SQLITE_OMIT_AUTOINCREMENT */
! 321:
! 322:
! 323: /* Forward declaration */
! 324: static int xferOptimization(
! 325: Parse *pParse, /* Parser context */
! 326: Table *pDest, /* The table we are inserting into */
! 327: Select *pSelect, /* A SELECT statement to use as the data source */
! 328: int onError, /* How to handle constraint errors */
! 329: int iDbDest /* The database of pDest */
! 330: );
! 331:
! 332: /*
! 333: ** This routine is call to handle SQL of the following forms:
! 334: **
! 335: ** insert into TABLE (IDLIST) values(EXPRLIST)
! 336: ** insert into TABLE (IDLIST) select
! 337: **
! 338: ** The IDLIST following the table name is always optional. If omitted,
! 339: ** then a list of all columns for the table is substituted. The IDLIST
! 340: ** appears in the pColumn parameter. pColumn is NULL if IDLIST is omitted.
! 341: **
! 342: ** The pList parameter holds EXPRLIST in the first form of the INSERT
! 343: ** statement above, and pSelect is NULL. For the second form, pList is
! 344: ** NULL and pSelect is a pointer to the select statement used to generate
! 345: ** data for the insert.
! 346: **
! 347: ** The code generated follows one of four templates. For a simple
! 348: ** select with data coming from a VALUES clause, the code executes
! 349: ** once straight down through. Pseudo-code follows (we call this
! 350: ** the "1st template"):
! 351: **
! 352: ** open write cursor to <table> and its indices
! 353: ** puts VALUES clause expressions onto the stack
! 354: ** write the resulting record into <table>
! 355: ** cleanup
! 356: **
! 357: ** The three remaining templates assume the statement is of the form
! 358: **
! 359: ** INSERT INTO <table> SELECT ...
! 360: **
! 361: ** If the SELECT clause is of the restricted form "SELECT * FROM <table2>" -
! 362: ** in other words if the SELECT pulls all columns from a single table
! 363: ** and there is no WHERE or LIMIT or GROUP BY or ORDER BY clauses, and
! 364: ** if <table2> and <table1> are distinct tables but have identical
! 365: ** schemas, including all the same indices, then a special optimization
! 366: ** is invoked that copies raw records from <table2> over to <table1>.
! 367: ** See the xferOptimization() function for the implementation of this
! 368: ** template. This is the 2nd template.
! 369: **
! 370: ** open a write cursor to <table>
! 371: ** open read cursor on <table2>
! 372: ** transfer all records in <table2> over to <table>
! 373: ** close cursors
! 374: ** foreach index on <table>
! 375: ** open a write cursor on the <table> index
! 376: ** open a read cursor on the corresponding <table2> index
! 377: ** transfer all records from the read to the write cursors
! 378: ** close cursors
! 379: ** end foreach
! 380: **
! 381: ** The 3rd template is for when the second template does not apply
! 382: ** and the SELECT clause does not read from <table> at any time.
! 383: ** The generated code follows this template:
! 384: **
! 385: ** EOF <- 0
! 386: ** X <- A
! 387: ** goto B
! 388: ** A: setup for the SELECT
! 389: ** loop over the rows in the SELECT
! 390: ** load values into registers R..R+n
! 391: ** yield X
! 392: ** end loop
! 393: ** cleanup after the SELECT
! 394: ** EOF <- 1
! 395: ** yield X
! 396: ** goto A
! 397: ** B: open write cursor to <table> and its indices
! 398: ** C: yield X
! 399: ** if EOF goto D
! 400: ** insert the select result into <table> from R..R+n
! 401: ** goto C
! 402: ** D: cleanup
! 403: **
! 404: ** The 4th template is used if the insert statement takes its
! 405: ** values from a SELECT but the data is being inserted into a table
! 406: ** that is also read as part of the SELECT. In the third form,
! 407: ** we have to use a intermediate table to store the results of
! 408: ** the select. The template is like this:
! 409: **
! 410: ** EOF <- 0
! 411: ** X <- A
! 412: ** goto B
! 413: ** A: setup for the SELECT
! 414: ** loop over the tables in the SELECT
! 415: ** load value into register R..R+n
! 416: ** yield X
! 417: ** end loop
! 418: ** cleanup after the SELECT
! 419: ** EOF <- 1
! 420: ** yield X
! 421: ** halt-error
! 422: ** B: open temp table
! 423: ** L: yield X
! 424: ** if EOF goto M
! 425: ** insert row from R..R+n into temp table
! 426: ** goto L
! 427: ** M: open write cursor to <table> and its indices
! 428: ** rewind temp table
! 429: ** C: loop over rows of intermediate table
! 430: ** transfer values form intermediate table into <table>
! 431: ** end loop
! 432: ** D: cleanup
! 433: */
! 434: void sqlite3Insert(
! 435: Parse *pParse, /* Parser context */
! 436: SrcList *pTabList, /* Name of table into which we are inserting */
! 437: ExprList *pList, /* List of values to be inserted */
! 438: Select *pSelect, /* A SELECT statement to use as the data source */
! 439: IdList *pColumn, /* Column names corresponding to IDLIST. */
! 440: int onError /* How to handle constraint errors */
! 441: ){
! 442: sqlite3 *db; /* The main database structure */
! 443: Table *pTab; /* The table to insert into. aka TABLE */
! 444: char *zTab; /* Name of the table into which we are inserting */
! 445: const char *zDb; /* Name of the database holding this table */
! 446: int i, j, idx; /* Loop counters */
! 447: Vdbe *v; /* Generate code into this virtual machine */
! 448: Index *pIdx; /* For looping over indices of the table */
! 449: int nColumn; /* Number of columns in the data */
! 450: int nHidden = 0; /* Number of hidden columns if TABLE is virtual */
! 451: int baseCur = 0; /* VDBE Cursor number for pTab */
! 452: int keyColumn = -1; /* Column that is the INTEGER PRIMARY KEY */
! 453: int endOfLoop; /* Label for the end of the insertion loop */
! 454: int useTempTable = 0; /* Store SELECT results in intermediate table */
! 455: int srcTab = 0; /* Data comes from this temporary cursor if >=0 */
! 456: int addrInsTop = 0; /* Jump to label "D" */
! 457: int addrCont = 0; /* Top of insert loop. Label "C" in templates 3 and 4 */
! 458: int addrSelect = 0; /* Address of coroutine that implements the SELECT */
! 459: SelectDest dest; /* Destination for SELECT on rhs of INSERT */
! 460: int iDb; /* Index of database holding TABLE */
! 461: Db *pDb; /* The database containing table being inserted into */
! 462: int appendFlag = 0; /* True if the insert is likely to be an append */
! 463:
! 464: /* Register allocations */
! 465: int regFromSelect = 0;/* Base register for data coming from SELECT */
! 466: int regAutoinc = 0; /* Register holding the AUTOINCREMENT counter */
! 467: int regRowCount = 0; /* Memory cell used for the row counter */
! 468: int regIns; /* Block of regs holding rowid+data being inserted */
! 469: int regRowid; /* registers holding insert rowid */
! 470: int regData; /* register holding first column to insert */
! 471: int regEof = 0; /* Register recording end of SELECT data */
! 472: int *aRegIdx = 0; /* One register allocated to each index */
! 473:
! 474: #ifndef SQLITE_OMIT_TRIGGER
! 475: int isView; /* True if attempting to insert into a view */
! 476: Trigger *pTrigger; /* List of triggers on pTab, if required */
! 477: int tmask; /* Mask of trigger times */
! 478: #endif
! 479:
! 480: db = pParse->db;
! 481: memset(&dest, 0, sizeof(dest));
! 482: if( pParse->nErr || db->mallocFailed ){
! 483: goto insert_cleanup;
! 484: }
! 485:
! 486: /* Locate the table into which we will be inserting new information.
! 487: */
! 488: assert( pTabList->nSrc==1 );
! 489: zTab = pTabList->a[0].zName;
! 490: if( NEVER(zTab==0) ) goto insert_cleanup;
! 491: pTab = sqlite3SrcListLookup(pParse, pTabList);
! 492: if( pTab==0 ){
! 493: goto insert_cleanup;
! 494: }
! 495: iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
! 496: assert( iDb<db->nDb );
! 497: pDb = &db->aDb[iDb];
! 498: zDb = pDb->zName;
! 499: if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
! 500: goto insert_cleanup;
! 501: }
! 502:
! 503: /* Figure out if we have any triggers and if the table being
! 504: ** inserted into is a view
! 505: */
! 506: #ifndef SQLITE_OMIT_TRIGGER
! 507: pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
! 508: isView = pTab->pSelect!=0;
! 509: #else
! 510: # define pTrigger 0
! 511: # define tmask 0
! 512: # define isView 0
! 513: #endif
! 514: #ifdef SQLITE_OMIT_VIEW
! 515: # undef isView
! 516: # define isView 0
! 517: #endif
! 518: assert( (pTrigger && tmask) || (pTrigger==0 && tmask==0) );
! 519:
! 520: /* If pTab is really a view, make sure it has been initialized.
! 521: ** ViewGetColumnNames() is a no-op if pTab is not a view (or virtual
! 522: ** module table).
! 523: */
! 524: if( sqlite3ViewGetColumnNames(pParse, pTab) ){
! 525: goto insert_cleanup;
! 526: }
! 527:
! 528: /* Ensure that:
! 529: * (a) the table is not read-only,
! 530: * (b) that if it is a view then ON INSERT triggers exist
! 531: */
! 532: if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
! 533: goto insert_cleanup;
! 534: }
! 535:
! 536: /* Allocate a VDBE
! 537: */
! 538: v = sqlite3GetVdbe(pParse);
! 539: if( v==0 ) goto insert_cleanup;
! 540: if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
! 541: sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
! 542:
! 543: #ifndef SQLITE_OMIT_XFER_OPT
! 544: /* If the statement is of the form
! 545: **
! 546: ** INSERT INTO <table1> SELECT * FROM <table2>;
! 547: **
! 548: ** Then special optimizations can be applied that make the transfer
! 549: ** very fast and which reduce fragmentation of indices.
! 550: **
! 551: ** This is the 2nd template.
! 552: */
! 553: if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){
! 554: assert( !pTrigger );
! 555: assert( pList==0 );
! 556: goto insert_end;
! 557: }
! 558: #endif /* SQLITE_OMIT_XFER_OPT */
! 559:
! 560: /* If this is an AUTOINCREMENT table, look up the sequence number in the
! 561: ** sqlite_sequence table and store it in memory cell regAutoinc.
! 562: */
! 563: regAutoinc = autoIncBegin(pParse, iDb, pTab);
! 564:
! 565: /* Figure out how many columns of data are supplied. If the data
! 566: ** is coming from a SELECT statement, then generate a co-routine that
! 567: ** produces a single row of the SELECT on each invocation. The
! 568: ** co-routine is the common header to the 3rd and 4th templates.
! 569: */
! 570: if( pSelect ){
! 571: /* Data is coming from a SELECT. Generate code to implement that SELECT
! 572: ** as a co-routine. The code is common to both the 3rd and 4th
! 573: ** templates:
! 574: **
! 575: ** EOF <- 0
! 576: ** X <- A
! 577: ** goto B
! 578: ** A: setup for the SELECT
! 579: ** loop over the tables in the SELECT
! 580: ** load value into register R..R+n
! 581: ** yield X
! 582: ** end loop
! 583: ** cleanup after the SELECT
! 584: ** EOF <- 1
! 585: ** yield X
! 586: ** halt-error
! 587: **
! 588: ** On each invocation of the co-routine, it puts a single row of the
! 589: ** SELECT result into registers dest.iMem...dest.iMem+dest.nMem-1.
! 590: ** (These output registers are allocated by sqlite3Select().) When
! 591: ** the SELECT completes, it sets the EOF flag stored in regEof.
! 592: */
! 593: int rc, j1;
! 594:
! 595: regEof = ++pParse->nMem;
! 596: sqlite3VdbeAddOp2(v, OP_Integer, 0, regEof); /* EOF <- 0 */
! 597: VdbeComment((v, "SELECT eof flag"));
! 598: sqlite3SelectDestInit(&dest, SRT_Coroutine, ++pParse->nMem);
! 599: addrSelect = sqlite3VdbeCurrentAddr(v)+2;
! 600: sqlite3VdbeAddOp2(v, OP_Integer, addrSelect-1, dest.iParm);
! 601: j1 = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
! 602: VdbeComment((v, "Jump over SELECT coroutine"));
! 603:
! 604: /* Resolve the expressions in the SELECT statement and execute it. */
! 605: rc = sqlite3Select(pParse, pSelect, &dest);
! 606: assert( pParse->nErr==0 || rc );
! 607: if( rc || NEVER(pParse->nErr) || db->mallocFailed ){
! 608: goto insert_cleanup;
! 609: }
! 610: sqlite3VdbeAddOp2(v, OP_Integer, 1, regEof); /* EOF <- 1 */
! 611: sqlite3VdbeAddOp1(v, OP_Yield, dest.iParm); /* yield X */
! 612: sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_INTERNAL, OE_Abort);
! 613: VdbeComment((v, "End of SELECT coroutine"));
! 614: sqlite3VdbeJumpHere(v, j1); /* label B: */
! 615:
! 616: regFromSelect = dest.iMem;
! 617: assert( pSelect->pEList );
! 618: nColumn = pSelect->pEList->nExpr;
! 619: assert( dest.nMem==nColumn );
! 620:
! 621: /* Set useTempTable to TRUE if the result of the SELECT statement
! 622: ** should be written into a temporary table (template 4). Set to
! 623: ** FALSE if each* row of the SELECT can be written directly into
! 624: ** the destination table (template 3).
! 625: **
! 626: ** A temp table must be used if the table being updated is also one
! 627: ** of the tables being read by the SELECT statement. Also use a
! 628: ** temp table in the case of row triggers.
! 629: */
! 630: if( pTrigger || readsTable(pParse, addrSelect, iDb, pTab) ){
! 631: useTempTable = 1;
! 632: }
! 633:
! 634: if( useTempTable ){
! 635: /* Invoke the coroutine to extract information from the SELECT
! 636: ** and add it to a transient table srcTab. The code generated
! 637: ** here is from the 4th template:
! 638: **
! 639: ** B: open temp table
! 640: ** L: yield X
! 641: ** if EOF goto M
! 642: ** insert row from R..R+n into temp table
! 643: ** goto L
! 644: ** M: ...
! 645: */
! 646: int regRec; /* Register to hold packed record */
! 647: int regTempRowid; /* Register to hold temp table ROWID */
! 648: int addrTop; /* Label "L" */
! 649: int addrIf; /* Address of jump to M */
! 650:
! 651: srcTab = pParse->nTab++;
! 652: regRec = sqlite3GetTempReg(pParse);
! 653: regTempRowid = sqlite3GetTempReg(pParse);
! 654: sqlite3VdbeAddOp2(v, OP_OpenEphemeral, srcTab, nColumn);
! 655: addrTop = sqlite3VdbeAddOp1(v, OP_Yield, dest.iParm);
! 656: addrIf = sqlite3VdbeAddOp1(v, OP_If, regEof);
! 657: sqlite3VdbeAddOp3(v, OP_MakeRecord, regFromSelect, nColumn, regRec);
! 658: sqlite3VdbeAddOp2(v, OP_NewRowid, srcTab, regTempRowid);
! 659: sqlite3VdbeAddOp3(v, OP_Insert, srcTab, regRec, regTempRowid);
! 660: sqlite3VdbeAddOp2(v, OP_Goto, 0, addrTop);
! 661: sqlite3VdbeJumpHere(v, addrIf);
! 662: sqlite3ReleaseTempReg(pParse, regRec);
! 663: sqlite3ReleaseTempReg(pParse, regTempRowid);
! 664: }
! 665: }else{
! 666: /* This is the case if the data for the INSERT is coming from a VALUES
! 667: ** clause
! 668: */
! 669: NameContext sNC;
! 670: memset(&sNC, 0, sizeof(sNC));
! 671: sNC.pParse = pParse;
! 672: srcTab = -1;
! 673: assert( useTempTable==0 );
! 674: nColumn = pList ? pList->nExpr : 0;
! 675: for(i=0; i<nColumn; i++){
! 676: if( sqlite3ResolveExprNames(&sNC, pList->a[i].pExpr) ){
! 677: goto insert_cleanup;
! 678: }
! 679: }
! 680: }
! 681:
! 682: /* Make sure the number of columns in the source data matches the number
! 683: ** of columns to be inserted into the table.
! 684: */
! 685: if( IsVirtual(pTab) ){
! 686: for(i=0; i<pTab->nCol; i++){
! 687: nHidden += (IsHiddenColumn(&pTab->aCol[i]) ? 1 : 0);
! 688: }
! 689: }
! 690: if( pColumn==0 && nColumn && nColumn!=(pTab->nCol-nHidden) ){
! 691: sqlite3ErrorMsg(pParse,
! 692: "table %S has %d columns but %d values were supplied",
! 693: pTabList, 0, pTab->nCol-nHidden, nColumn);
! 694: goto insert_cleanup;
! 695: }
! 696: if( pColumn!=0 && nColumn!=pColumn->nId ){
! 697: sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
! 698: goto insert_cleanup;
! 699: }
! 700:
! 701: /* If the INSERT statement included an IDLIST term, then make sure
! 702: ** all elements of the IDLIST really are columns of the table and
! 703: ** remember the column indices.
! 704: **
! 705: ** If the table has an INTEGER PRIMARY KEY column and that column
! 706: ** is named in the IDLIST, then record in the keyColumn variable
! 707: ** the index into IDLIST of the primary key column. keyColumn is
! 708: ** the index of the primary key as it appears in IDLIST, not as
! 709: ** is appears in the original table. (The index of the primary
! 710: ** key in the original table is pTab->iPKey.)
! 711: */
! 712: if( pColumn ){
! 713: for(i=0; i<pColumn->nId; i++){
! 714: pColumn->a[i].idx = -1;
! 715: }
! 716: for(i=0; i<pColumn->nId; i++){
! 717: for(j=0; j<pTab->nCol; j++){
! 718: if( sqlite3StrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){
! 719: pColumn->a[i].idx = j;
! 720: if( j==pTab->iPKey ){
! 721: keyColumn = i;
! 722: }
! 723: break;
! 724: }
! 725: }
! 726: if( j>=pTab->nCol ){
! 727: if( sqlite3IsRowid(pColumn->a[i].zName) ){
! 728: keyColumn = i;
! 729: }else{
! 730: sqlite3ErrorMsg(pParse, "table %S has no column named %s",
! 731: pTabList, 0, pColumn->a[i].zName);
! 732: pParse->checkSchema = 1;
! 733: goto insert_cleanup;
! 734: }
! 735: }
! 736: }
! 737: }
! 738:
! 739: /* If there is no IDLIST term but the table has an integer primary
! 740: ** key, the set the keyColumn variable to the primary key column index
! 741: ** in the original table definition.
! 742: */
! 743: if( pColumn==0 && nColumn>0 ){
! 744: keyColumn = pTab->iPKey;
! 745: }
! 746:
! 747: /* Initialize the count of rows to be inserted
! 748: */
! 749: if( db->flags & SQLITE_CountRows ){
! 750: regRowCount = ++pParse->nMem;
! 751: sqlite3VdbeAddOp2(v, OP_Integer, 0, regRowCount);
! 752: }
! 753:
! 754: /* If this is not a view, open the table and and all indices */
! 755: if( !isView ){
! 756: int nIdx;
! 757:
! 758: baseCur = pParse->nTab;
! 759: nIdx = sqlite3OpenTableAndIndices(pParse, pTab, baseCur, OP_OpenWrite);
! 760: aRegIdx = sqlite3DbMallocRaw(db, sizeof(int)*(nIdx+1));
! 761: if( aRegIdx==0 ){
! 762: goto insert_cleanup;
! 763: }
! 764: for(i=0; i<nIdx; i++){
! 765: aRegIdx[i] = ++pParse->nMem;
! 766: }
! 767: }
! 768:
! 769: /* This is the top of the main insertion loop */
! 770: if( useTempTable ){
! 771: /* This block codes the top of loop only. The complete loop is the
! 772: ** following pseudocode (template 4):
! 773: **
! 774: ** rewind temp table
! 775: ** C: loop over rows of intermediate table
! 776: ** transfer values form intermediate table into <table>
! 777: ** end loop
! 778: ** D: ...
! 779: */
! 780: addrInsTop = sqlite3VdbeAddOp1(v, OP_Rewind, srcTab);
! 781: addrCont = sqlite3VdbeCurrentAddr(v);
! 782: }else if( pSelect ){
! 783: /* This block codes the top of loop only. The complete loop is the
! 784: ** following pseudocode (template 3):
! 785: **
! 786: ** C: yield X
! 787: ** if EOF goto D
! 788: ** insert the select result into <table> from R..R+n
! 789: ** goto C
! 790: ** D: ...
! 791: */
! 792: addrCont = sqlite3VdbeAddOp1(v, OP_Yield, dest.iParm);
! 793: addrInsTop = sqlite3VdbeAddOp1(v, OP_If, regEof);
! 794: }
! 795:
! 796: /* Allocate registers for holding the rowid of the new row,
! 797: ** the content of the new row, and the assemblied row record.
! 798: */
! 799: regRowid = regIns = pParse->nMem+1;
! 800: pParse->nMem += pTab->nCol + 1;
! 801: if( IsVirtual(pTab) ){
! 802: regRowid++;
! 803: pParse->nMem++;
! 804: }
! 805: regData = regRowid+1;
! 806:
! 807: /* Run the BEFORE and INSTEAD OF triggers, if there are any
! 808: */
! 809: endOfLoop = sqlite3VdbeMakeLabel(v);
! 810: if( tmask & TRIGGER_BEFORE ){
! 811: int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
! 812:
! 813: /* build the NEW.* reference row. Note that if there is an INTEGER
! 814: ** PRIMARY KEY into which a NULL is being inserted, that NULL will be
! 815: ** translated into a unique ID for the row. But on a BEFORE trigger,
! 816: ** we do not know what the unique ID will be (because the insert has
! 817: ** not happened yet) so we substitute a rowid of -1
! 818: */
! 819: if( keyColumn<0 ){
! 820: sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
! 821: }else{
! 822: int j1;
! 823: if( useTempTable ){
! 824: sqlite3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regCols);
! 825: }else{
! 826: assert( pSelect==0 ); /* Otherwise useTempTable is true */
! 827: sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regCols);
! 828: }
! 829: j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regCols);
! 830: sqlite3VdbeAddOp2(v, OP_Integer, -1, regCols);
! 831: sqlite3VdbeJumpHere(v, j1);
! 832: sqlite3VdbeAddOp1(v, OP_MustBeInt, regCols);
! 833: }
! 834:
! 835: /* Cannot have triggers on a virtual table. If it were possible,
! 836: ** this block would have to account for hidden column.
! 837: */
! 838: assert( !IsVirtual(pTab) );
! 839:
! 840: /* Create the new column data
! 841: */
! 842: for(i=0; i<pTab->nCol; i++){
! 843: if( pColumn==0 ){
! 844: j = i;
! 845: }else{
! 846: for(j=0; j<pColumn->nId; j++){
! 847: if( pColumn->a[j].idx==i ) break;
! 848: }
! 849: }
! 850: if( (!useTempTable && !pList) || (pColumn && j>=pColumn->nId) ){
! 851: sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regCols+i+1);
! 852: }else if( useTempTable ){
! 853: sqlite3VdbeAddOp3(v, OP_Column, srcTab, j, regCols+i+1);
! 854: }else{
! 855: assert( pSelect==0 ); /* Otherwise useTempTable is true */
! 856: sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr, regCols+i+1);
! 857: }
! 858: }
! 859:
! 860: /* If this is an INSERT on a view with an INSTEAD OF INSERT trigger,
! 861: ** do not attempt any conversions before assembling the record.
! 862: ** If this is a real table, attempt conversions as required by the
! 863: ** table column affinities.
! 864: */
! 865: if( !isView ){
! 866: sqlite3VdbeAddOp2(v, OP_Affinity, regCols+1, pTab->nCol);
! 867: sqlite3TableAffinityStr(v, pTab);
! 868: }
! 869:
! 870: /* Fire BEFORE or INSTEAD OF triggers */
! 871: sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_BEFORE,
! 872: pTab, regCols-pTab->nCol-1, onError, endOfLoop);
! 873:
! 874: sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
! 875: }
! 876:
! 877: /* Push the record number for the new entry onto the stack. The
! 878: ** record number is a randomly generate integer created by NewRowid
! 879: ** except when the table has an INTEGER PRIMARY KEY column, in which
! 880: ** case the record number is the same as that column.
! 881: */
! 882: if( !isView ){
! 883: if( IsVirtual(pTab) ){
! 884: /* The row that the VUpdate opcode will delete: none */
! 885: sqlite3VdbeAddOp2(v, OP_Null, 0, regIns);
! 886: }
! 887: if( keyColumn>=0 ){
! 888: if( useTempTable ){
! 889: sqlite3VdbeAddOp3(v, OP_Column, srcTab, keyColumn, regRowid);
! 890: }else if( pSelect ){
! 891: sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+keyColumn, regRowid);
! 892: }else{
! 893: VdbeOp *pOp;
! 894: sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regRowid);
! 895: pOp = sqlite3VdbeGetOp(v, -1);
! 896: if( ALWAYS(pOp) && pOp->opcode==OP_Null && !IsVirtual(pTab) ){
! 897: appendFlag = 1;
! 898: pOp->opcode = OP_NewRowid;
! 899: pOp->p1 = baseCur;
! 900: pOp->p2 = regRowid;
! 901: pOp->p3 = regAutoinc;
! 902: }
! 903: }
! 904: /* If the PRIMARY KEY expression is NULL, then use OP_NewRowid
! 905: ** to generate a unique primary key value.
! 906: */
! 907: if( !appendFlag ){
! 908: int j1;
! 909: if( !IsVirtual(pTab) ){
! 910: j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regRowid);
! 911: sqlite3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);
! 912: sqlite3VdbeJumpHere(v, j1);
! 913: }else{
! 914: j1 = sqlite3VdbeCurrentAddr(v);
! 915: sqlite3VdbeAddOp2(v, OP_IsNull, regRowid, j1+2);
! 916: }
! 917: sqlite3VdbeAddOp1(v, OP_MustBeInt, regRowid);
! 918: }
! 919: }else if( IsVirtual(pTab) ){
! 920: sqlite3VdbeAddOp2(v, OP_Null, 0, regRowid);
! 921: }else{
! 922: sqlite3VdbeAddOp3(v, OP_NewRowid, baseCur, regRowid, regAutoinc);
! 923: appendFlag = 1;
! 924: }
! 925: autoIncStep(pParse, regAutoinc, regRowid);
! 926:
! 927: /* Push onto the stack, data for all columns of the new entry, beginning
! 928: ** with the first column.
! 929: */
! 930: nHidden = 0;
! 931: for(i=0; i<pTab->nCol; i++){
! 932: int iRegStore = regRowid+1+i;
! 933: if( i==pTab->iPKey ){
! 934: /* The value of the INTEGER PRIMARY KEY column is always a NULL.
! 935: ** Whenever this column is read, the record number will be substituted
! 936: ** in its place. So will fill this column with a NULL to avoid
! 937: ** taking up data space with information that will never be used. */
! 938: sqlite3VdbeAddOp2(v, OP_Null, 0, iRegStore);
! 939: continue;
! 940: }
! 941: if( pColumn==0 ){
! 942: if( IsHiddenColumn(&pTab->aCol[i]) ){
! 943: assert( IsVirtual(pTab) );
! 944: j = -1;
! 945: nHidden++;
! 946: }else{
! 947: j = i - nHidden;
! 948: }
! 949: }else{
! 950: for(j=0; j<pColumn->nId; j++){
! 951: if( pColumn->a[j].idx==i ) break;
! 952: }
! 953: }
! 954: if( j<0 || nColumn==0 || (pColumn && j>=pColumn->nId) ){
! 955: sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, iRegStore);
! 956: }else if( useTempTable ){
! 957: sqlite3VdbeAddOp3(v, OP_Column, srcTab, j, iRegStore);
! 958: }else if( pSelect ){
! 959: sqlite3VdbeAddOp2(v, OP_SCopy, regFromSelect+j, iRegStore);
! 960: }else{
! 961: sqlite3ExprCode(pParse, pList->a[j].pExpr, iRegStore);
! 962: }
! 963: }
! 964:
! 965: /* Generate code to check constraints and generate index keys and
! 966: ** do the insertion.
! 967: */
! 968: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 969: if( IsVirtual(pTab) ){
! 970: const char *pVTab = (const char *)sqlite3GetVTable(db, pTab);
! 971: sqlite3VtabMakeWritable(pParse, pTab);
! 972: sqlite3VdbeAddOp4(v, OP_VUpdate, 1, pTab->nCol+2, regIns, pVTab, P4_VTAB);
! 973: sqlite3VdbeChangeP5(v, onError==OE_Default ? OE_Abort : onError);
! 974: sqlite3MayAbort(pParse);
! 975: }else
! 976: #endif
! 977: {
! 978: int isReplace; /* Set to true if constraints may cause a replace */
! 979: sqlite3GenerateConstraintChecks(pParse, pTab, baseCur, regIns, aRegIdx,
! 980: keyColumn>=0, 0, onError, endOfLoop, &isReplace
! 981: );
! 982: sqlite3FkCheck(pParse, pTab, 0, regIns);
! 983: sqlite3CompleteInsertion(
! 984: pParse, pTab, baseCur, regIns, aRegIdx, 0, appendFlag, isReplace==0
! 985: );
! 986: }
! 987: }
! 988:
! 989: /* Update the count of rows that are inserted
! 990: */
! 991: if( (db->flags & SQLITE_CountRows)!=0 ){
! 992: sqlite3VdbeAddOp2(v, OP_AddImm, regRowCount, 1);
! 993: }
! 994:
! 995: if( pTrigger ){
! 996: /* Code AFTER triggers */
! 997: sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_AFTER,
! 998: pTab, regData-2-pTab->nCol, onError, endOfLoop);
! 999: }
! 1000:
! 1001: /* The bottom of the main insertion loop, if the data source
! 1002: ** is a SELECT statement.
! 1003: */
! 1004: sqlite3VdbeResolveLabel(v, endOfLoop);
! 1005: if( useTempTable ){
! 1006: sqlite3VdbeAddOp2(v, OP_Next, srcTab, addrCont);
! 1007: sqlite3VdbeJumpHere(v, addrInsTop);
! 1008: sqlite3VdbeAddOp1(v, OP_Close, srcTab);
! 1009: }else if( pSelect ){
! 1010: sqlite3VdbeAddOp2(v, OP_Goto, 0, addrCont);
! 1011: sqlite3VdbeJumpHere(v, addrInsTop);
! 1012: }
! 1013:
! 1014: if( !IsVirtual(pTab) && !isView ){
! 1015: /* Close all tables opened */
! 1016: sqlite3VdbeAddOp1(v, OP_Close, baseCur);
! 1017: for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){
! 1018: sqlite3VdbeAddOp1(v, OP_Close, idx+baseCur);
! 1019: }
! 1020: }
! 1021:
! 1022: insert_end:
! 1023: /* Update the sqlite_sequence table by storing the content of the
! 1024: ** maximum rowid counter values recorded while inserting into
! 1025: ** autoincrement tables.
! 1026: */
! 1027: if( pParse->nested==0 && pParse->pTriggerTab==0 ){
! 1028: sqlite3AutoincrementEnd(pParse);
! 1029: }
! 1030:
! 1031: /*
! 1032: ** Return the number of rows inserted. If this routine is
! 1033: ** generating code because of a call to sqlite3NestedParse(), do not
! 1034: ** invoke the callback function.
! 1035: */
! 1036: if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
! 1037: sqlite3VdbeAddOp2(v, OP_ResultRow, regRowCount, 1);
! 1038: sqlite3VdbeSetNumCols(v, 1);
! 1039: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "rows inserted", SQLITE_STATIC);
! 1040: }
! 1041:
! 1042: insert_cleanup:
! 1043: sqlite3SrcListDelete(db, pTabList);
! 1044: sqlite3ExprListDelete(db, pList);
! 1045: sqlite3SelectDelete(db, pSelect);
! 1046: sqlite3IdListDelete(db, pColumn);
! 1047: sqlite3DbFree(db, aRegIdx);
! 1048: }
! 1049:
! 1050: /* Make sure "isView" and other macros defined above are undefined. Otherwise
! 1051: ** thely may interfere with compilation of other functions in this file
! 1052: ** (or in another file, if this file becomes part of the amalgamation). */
! 1053: #ifdef isView
! 1054: #undef isView
! 1055: #endif
! 1056: #ifdef pTrigger
! 1057: #undef pTrigger
! 1058: #endif
! 1059: #ifdef tmask
! 1060: #undef tmask
! 1061: #endif
! 1062:
! 1063:
! 1064: /*
! 1065: ** Generate code to do constraint checks prior to an INSERT or an UPDATE.
! 1066: **
! 1067: ** The input is a range of consecutive registers as follows:
! 1068: **
! 1069: ** 1. The rowid of the row after the update.
! 1070: **
! 1071: ** 2. The data in the first column of the entry after the update.
! 1072: **
! 1073: ** i. Data from middle columns...
! 1074: **
! 1075: ** N. The data in the last column of the entry after the update.
! 1076: **
! 1077: ** The regRowid parameter is the index of the register containing (1).
! 1078: **
! 1079: ** If isUpdate is true and rowidChng is non-zero, then rowidChng contains
! 1080: ** the address of a register containing the rowid before the update takes
! 1081: ** place. isUpdate is true for UPDATEs and false for INSERTs. If isUpdate
! 1082: ** is false, indicating an INSERT statement, then a non-zero rowidChng
! 1083: ** indicates that the rowid was explicitly specified as part of the
! 1084: ** INSERT statement. If rowidChng is false, it means that the rowid is
! 1085: ** computed automatically in an insert or that the rowid value is not
! 1086: ** modified by an update.
! 1087: **
! 1088: ** The code generated by this routine store new index entries into
! 1089: ** registers identified by aRegIdx[]. No index entry is created for
! 1090: ** indices where aRegIdx[i]==0. The order of indices in aRegIdx[] is
! 1091: ** the same as the order of indices on the linked list of indices
! 1092: ** attached to the table.
! 1093: **
! 1094: ** This routine also generates code to check constraints. NOT NULL,
! 1095: ** CHECK, and UNIQUE constraints are all checked. If a constraint fails,
! 1096: ** then the appropriate action is performed. There are five possible
! 1097: ** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE.
! 1098: **
! 1099: ** Constraint type Action What Happens
! 1100: ** --------------- ---------- ----------------------------------------
! 1101: ** any ROLLBACK The current transaction is rolled back and
! 1102: ** sqlite3_exec() returns immediately with a
! 1103: ** return code of SQLITE_CONSTRAINT.
! 1104: **
! 1105: ** any ABORT Back out changes from the current command
! 1106: ** only (do not do a complete rollback) then
! 1107: ** cause sqlite3_exec() to return immediately
! 1108: ** with SQLITE_CONSTRAINT.
! 1109: **
! 1110: ** any FAIL Sqlite3_exec() returns immediately with a
! 1111: ** return code of SQLITE_CONSTRAINT. The
! 1112: ** transaction is not rolled back and any
! 1113: ** prior changes are retained.
! 1114: **
! 1115: ** any IGNORE The record number and data is popped from
! 1116: ** the stack and there is an immediate jump
! 1117: ** to label ignoreDest.
! 1118: **
! 1119: ** NOT NULL REPLACE The NULL value is replace by the default
! 1120: ** value for that column. If the default value
! 1121: ** is NULL, the action is the same as ABORT.
! 1122: **
! 1123: ** UNIQUE REPLACE The other row that conflicts with the row
! 1124: ** being inserted is removed.
! 1125: **
! 1126: ** CHECK REPLACE Illegal. The results in an exception.
! 1127: **
! 1128: ** Which action to take is determined by the overrideError parameter.
! 1129: ** Or if overrideError==OE_Default, then the pParse->onError parameter
! 1130: ** is used. Or if pParse->onError==OE_Default then the onError value
! 1131: ** for the constraint is used.
! 1132: **
! 1133: ** The calling routine must open a read/write cursor for pTab with
! 1134: ** cursor number "baseCur". All indices of pTab must also have open
! 1135: ** read/write cursors with cursor number baseCur+i for the i-th cursor.
! 1136: ** Except, if there is no possibility of a REPLACE action then
! 1137: ** cursors do not need to be open for indices where aRegIdx[i]==0.
! 1138: */
! 1139: void sqlite3GenerateConstraintChecks(
! 1140: Parse *pParse, /* The parser context */
! 1141: Table *pTab, /* the table into which we are inserting */
! 1142: int baseCur, /* Index of a read/write cursor pointing at pTab */
! 1143: int regRowid, /* Index of the range of input registers */
! 1144: int *aRegIdx, /* Register used by each index. 0 for unused indices */
! 1145: int rowidChng, /* True if the rowid might collide with existing entry */
! 1146: int isUpdate, /* True for UPDATE, False for INSERT */
! 1147: int overrideError, /* Override onError to this if not OE_Default */
! 1148: int ignoreDest, /* Jump to this label on an OE_Ignore resolution */
! 1149: int *pbMayReplace /* OUT: Set to true if constraint may cause a replace */
! 1150: ){
! 1151: int i; /* loop counter */
! 1152: Vdbe *v; /* VDBE under constrution */
! 1153: int nCol; /* Number of columns */
! 1154: int onError; /* Conflict resolution strategy */
! 1155: int j1; /* Addresss of jump instruction */
! 1156: int j2 = 0, j3; /* Addresses of jump instructions */
! 1157: int regData; /* Register containing first data column */
! 1158: int iCur; /* Table cursor number */
! 1159: Index *pIdx; /* Pointer to one of the indices */
! 1160: int seenReplace = 0; /* True if REPLACE is used to resolve INT PK conflict */
! 1161: int regOldRowid = (rowidChng && isUpdate) ? rowidChng : regRowid;
! 1162:
! 1163: v = sqlite3GetVdbe(pParse);
! 1164: assert( v!=0 );
! 1165: assert( pTab->pSelect==0 ); /* This table is not a VIEW */
! 1166: nCol = pTab->nCol;
! 1167: regData = regRowid + 1;
! 1168:
! 1169: /* Test all NOT NULL constraints.
! 1170: */
! 1171: for(i=0; i<nCol; i++){
! 1172: if( i==pTab->iPKey ){
! 1173: continue;
! 1174: }
! 1175: onError = pTab->aCol[i].notNull;
! 1176: if( onError==OE_None ) continue;
! 1177: if( overrideError!=OE_Default ){
! 1178: onError = overrideError;
! 1179: }else if( onError==OE_Default ){
! 1180: onError = OE_Abort;
! 1181: }
! 1182: if( onError==OE_Replace && pTab->aCol[i].pDflt==0 ){
! 1183: onError = OE_Abort;
! 1184: }
! 1185: assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
! 1186: || onError==OE_Ignore || onError==OE_Replace );
! 1187: switch( onError ){
! 1188: case OE_Abort:
! 1189: sqlite3MayAbort(pParse);
! 1190: case OE_Rollback:
! 1191: case OE_Fail: {
! 1192: char *zMsg;
! 1193: sqlite3VdbeAddOp3(v, OP_HaltIfNull,
! 1194: SQLITE_CONSTRAINT, onError, regData+i);
! 1195: zMsg = sqlite3MPrintf(pParse->db, "%s.%s may not be NULL",
! 1196: pTab->zName, pTab->aCol[i].zName);
! 1197: sqlite3VdbeChangeP4(v, -1, zMsg, P4_DYNAMIC);
! 1198: break;
! 1199: }
! 1200: case OE_Ignore: {
! 1201: sqlite3VdbeAddOp2(v, OP_IsNull, regData+i, ignoreDest);
! 1202: break;
! 1203: }
! 1204: default: {
! 1205: assert( onError==OE_Replace );
! 1206: j1 = sqlite3VdbeAddOp1(v, OP_NotNull, regData+i);
! 1207: sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regData+i);
! 1208: sqlite3VdbeJumpHere(v, j1);
! 1209: break;
! 1210: }
! 1211: }
! 1212: }
! 1213:
! 1214: /* Test all CHECK constraints
! 1215: */
! 1216: #ifndef SQLITE_OMIT_CHECK
! 1217: if( pTab->pCheck && (pParse->db->flags & SQLITE_IgnoreChecks)==0 ){
! 1218: int allOk = sqlite3VdbeMakeLabel(v);
! 1219: pParse->ckBase = regData;
! 1220: sqlite3ExprIfTrue(pParse, pTab->pCheck, allOk, SQLITE_JUMPIFNULL);
! 1221: onError = overrideError!=OE_Default ? overrideError : OE_Abort;
! 1222: if( onError==OE_Ignore ){
! 1223: sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
! 1224: }else{
! 1225: if( onError==OE_Replace ) onError = OE_Abort; /* IMP: R-15569-63625 */
! 1226: sqlite3HaltConstraint(pParse, onError, 0, 0);
! 1227: }
! 1228: sqlite3VdbeResolveLabel(v, allOk);
! 1229: }
! 1230: #endif /* !defined(SQLITE_OMIT_CHECK) */
! 1231:
! 1232: /* If we have an INTEGER PRIMARY KEY, make sure the primary key
! 1233: ** of the new record does not previously exist. Except, if this
! 1234: ** is an UPDATE and the primary key is not changing, that is OK.
! 1235: */
! 1236: if( rowidChng ){
! 1237: onError = pTab->keyConf;
! 1238: if( overrideError!=OE_Default ){
! 1239: onError = overrideError;
! 1240: }else if( onError==OE_Default ){
! 1241: onError = OE_Abort;
! 1242: }
! 1243:
! 1244: if( isUpdate ){
! 1245: j2 = sqlite3VdbeAddOp3(v, OP_Eq, regRowid, 0, rowidChng);
! 1246: }
! 1247: j3 = sqlite3VdbeAddOp3(v, OP_NotExists, baseCur, 0, regRowid);
! 1248: switch( onError ){
! 1249: default: {
! 1250: onError = OE_Abort;
! 1251: /* Fall thru into the next case */
! 1252: }
! 1253: case OE_Rollback:
! 1254: case OE_Abort:
! 1255: case OE_Fail: {
! 1256: sqlite3HaltConstraint(
! 1257: pParse, onError, "PRIMARY KEY must be unique", P4_STATIC);
! 1258: break;
! 1259: }
! 1260: case OE_Replace: {
! 1261: /* If there are DELETE triggers on this table and the
! 1262: ** recursive-triggers flag is set, call GenerateRowDelete() to
! 1263: ** remove the conflicting row from the the table. This will fire
! 1264: ** the triggers and remove both the table and index b-tree entries.
! 1265: **
! 1266: ** Otherwise, if there are no triggers or the recursive-triggers
! 1267: ** flag is not set, but the table has one or more indexes, call
! 1268: ** GenerateRowIndexDelete(). This removes the index b-tree entries
! 1269: ** only. The table b-tree entry will be replaced by the new entry
! 1270: ** when it is inserted.
! 1271: **
! 1272: ** If either GenerateRowDelete() or GenerateRowIndexDelete() is called,
! 1273: ** also invoke MultiWrite() to indicate that this VDBE may require
! 1274: ** statement rollback (if the statement is aborted after the delete
! 1275: ** takes place). Earlier versions called sqlite3MultiWrite() regardless,
! 1276: ** but being more selective here allows statements like:
! 1277: **
! 1278: ** REPLACE INTO t(rowid) VALUES($newrowid)
! 1279: **
! 1280: ** to run without a statement journal if there are no indexes on the
! 1281: ** table.
! 1282: */
! 1283: Trigger *pTrigger = 0;
! 1284: if( pParse->db->flags&SQLITE_RecTriggers ){
! 1285: pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
! 1286: }
! 1287: if( pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0) ){
! 1288: sqlite3MultiWrite(pParse);
! 1289: sqlite3GenerateRowDelete(
! 1290: pParse, pTab, baseCur, regRowid, 0, pTrigger, OE_Replace
! 1291: );
! 1292: }else if( pTab->pIndex ){
! 1293: sqlite3MultiWrite(pParse);
! 1294: sqlite3GenerateRowIndexDelete(pParse, pTab, baseCur, 0);
! 1295: }
! 1296: seenReplace = 1;
! 1297: break;
! 1298: }
! 1299: case OE_Ignore: {
! 1300: assert( seenReplace==0 );
! 1301: sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
! 1302: break;
! 1303: }
! 1304: }
! 1305: sqlite3VdbeJumpHere(v, j3);
! 1306: if( isUpdate ){
! 1307: sqlite3VdbeJumpHere(v, j2);
! 1308: }
! 1309: }
! 1310:
! 1311: /* Test all UNIQUE constraints by creating entries for each UNIQUE
! 1312: ** index and making sure that duplicate entries do not already exist.
! 1313: ** Add the new records to the indices as we go.
! 1314: */
! 1315: for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){
! 1316: int regIdx;
! 1317: int regR;
! 1318:
! 1319: if( aRegIdx[iCur]==0 ) continue; /* Skip unused indices */
! 1320:
! 1321: /* Create a key for accessing the index entry */
! 1322: regIdx = sqlite3GetTempRange(pParse, pIdx->nColumn+1);
! 1323: for(i=0; i<pIdx->nColumn; i++){
! 1324: int idx = pIdx->aiColumn[i];
! 1325: if( idx==pTab->iPKey ){
! 1326: sqlite3VdbeAddOp2(v, OP_SCopy, regRowid, regIdx+i);
! 1327: }else{
! 1328: sqlite3VdbeAddOp2(v, OP_SCopy, regData+idx, regIdx+i);
! 1329: }
! 1330: }
! 1331: sqlite3VdbeAddOp2(v, OP_SCopy, regRowid, regIdx+i);
! 1332: sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn+1, aRegIdx[iCur]);
! 1333: sqlite3VdbeChangeP4(v, -1, sqlite3IndexAffinityStr(v, pIdx), P4_TRANSIENT);
! 1334: sqlite3ExprCacheAffinityChange(pParse, regIdx, pIdx->nColumn+1);
! 1335:
! 1336: /* Find out what action to take in case there is an indexing conflict */
! 1337: onError = pIdx->onError;
! 1338: if( onError==OE_None ){
! 1339: sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn+1);
! 1340: continue; /* pIdx is not a UNIQUE index */
! 1341: }
! 1342: if( overrideError!=OE_Default ){
! 1343: onError = overrideError;
! 1344: }else if( onError==OE_Default ){
! 1345: onError = OE_Abort;
! 1346: }
! 1347: if( seenReplace ){
! 1348: if( onError==OE_Ignore ) onError = OE_Replace;
! 1349: else if( onError==OE_Fail ) onError = OE_Abort;
! 1350: }
! 1351:
! 1352: /* Check to see if the new index entry will be unique */
! 1353: regR = sqlite3GetTempReg(pParse);
! 1354: sqlite3VdbeAddOp2(v, OP_SCopy, regOldRowid, regR);
! 1355: j3 = sqlite3VdbeAddOp4(v, OP_IsUnique, baseCur+iCur+1, 0,
! 1356: regR, SQLITE_INT_TO_PTR(regIdx),
! 1357: P4_INT32);
! 1358: sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn+1);
! 1359:
! 1360: /* Generate code that executes if the new index entry is not unique */
! 1361: assert( onError==OE_Rollback || onError==OE_Abort || onError==OE_Fail
! 1362: || onError==OE_Ignore || onError==OE_Replace );
! 1363: switch( onError ){
! 1364: case OE_Rollback:
! 1365: case OE_Abort:
! 1366: case OE_Fail: {
! 1367: int j;
! 1368: StrAccum errMsg;
! 1369: const char *zSep;
! 1370: char *zErr;
! 1371:
! 1372: sqlite3StrAccumInit(&errMsg, 0, 0, 200);
! 1373: errMsg.db = pParse->db;
! 1374: zSep = pIdx->nColumn>1 ? "columns " : "column ";
! 1375: for(j=0; j<pIdx->nColumn; j++){
! 1376: char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
! 1377: sqlite3StrAccumAppend(&errMsg, zSep, -1);
! 1378: zSep = ", ";
! 1379: sqlite3StrAccumAppend(&errMsg, zCol, -1);
! 1380: }
! 1381: sqlite3StrAccumAppend(&errMsg,
! 1382: pIdx->nColumn>1 ? " are not unique" : " is not unique", -1);
! 1383: zErr = sqlite3StrAccumFinish(&errMsg);
! 1384: sqlite3HaltConstraint(pParse, onError, zErr, 0);
! 1385: sqlite3DbFree(errMsg.db, zErr);
! 1386: break;
! 1387: }
! 1388: case OE_Ignore: {
! 1389: assert( seenReplace==0 );
! 1390: sqlite3VdbeAddOp2(v, OP_Goto, 0, ignoreDest);
! 1391: break;
! 1392: }
! 1393: default: {
! 1394: Trigger *pTrigger = 0;
! 1395: assert( onError==OE_Replace );
! 1396: sqlite3MultiWrite(pParse);
! 1397: if( pParse->db->flags&SQLITE_RecTriggers ){
! 1398: pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
! 1399: }
! 1400: sqlite3GenerateRowDelete(
! 1401: pParse, pTab, baseCur, regR, 0, pTrigger, OE_Replace
! 1402: );
! 1403: seenReplace = 1;
! 1404: break;
! 1405: }
! 1406: }
! 1407: sqlite3VdbeJumpHere(v, j3);
! 1408: sqlite3ReleaseTempReg(pParse, regR);
! 1409: }
! 1410:
! 1411: if( pbMayReplace ){
! 1412: *pbMayReplace = seenReplace;
! 1413: }
! 1414: }
! 1415:
! 1416: /*
! 1417: ** This routine generates code to finish the INSERT or UPDATE operation
! 1418: ** that was started by a prior call to sqlite3GenerateConstraintChecks.
! 1419: ** A consecutive range of registers starting at regRowid contains the
! 1420: ** rowid and the content to be inserted.
! 1421: **
! 1422: ** The arguments to this routine should be the same as the first six
! 1423: ** arguments to sqlite3GenerateConstraintChecks.
! 1424: */
! 1425: void sqlite3CompleteInsertion(
! 1426: Parse *pParse, /* The parser context */
! 1427: Table *pTab, /* the table into which we are inserting */
! 1428: int baseCur, /* Index of a read/write cursor pointing at pTab */
! 1429: int regRowid, /* Range of content */
! 1430: int *aRegIdx, /* Register used by each index. 0 for unused indices */
! 1431: int isUpdate, /* True for UPDATE, False for INSERT */
! 1432: int appendBias, /* True if this is likely to be an append */
! 1433: int useSeekResult /* True to set the USESEEKRESULT flag on OP_[Idx]Insert */
! 1434: ){
! 1435: int i;
! 1436: Vdbe *v;
! 1437: int nIdx;
! 1438: Index *pIdx;
! 1439: u8 pik_flags;
! 1440: int regData;
! 1441: int regRec;
! 1442:
! 1443: v = sqlite3GetVdbe(pParse);
! 1444: assert( v!=0 );
! 1445: assert( pTab->pSelect==0 ); /* This table is not a VIEW */
! 1446: for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){}
! 1447: for(i=nIdx-1; i>=0; i--){
! 1448: if( aRegIdx[i]==0 ) continue;
! 1449: sqlite3VdbeAddOp2(v, OP_IdxInsert, baseCur+i+1, aRegIdx[i]);
! 1450: if( useSeekResult ){
! 1451: sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT);
! 1452: }
! 1453: }
! 1454: regData = regRowid + 1;
! 1455: regRec = sqlite3GetTempReg(pParse);
! 1456: sqlite3VdbeAddOp3(v, OP_MakeRecord, regData, pTab->nCol, regRec);
! 1457: sqlite3TableAffinityStr(v, pTab);
! 1458: sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
! 1459: if( pParse->nested ){
! 1460: pik_flags = 0;
! 1461: }else{
! 1462: pik_flags = OPFLAG_NCHANGE;
! 1463: pik_flags |= (isUpdate?OPFLAG_ISUPDATE:OPFLAG_LASTROWID);
! 1464: }
! 1465: if( appendBias ){
! 1466: pik_flags |= OPFLAG_APPEND;
! 1467: }
! 1468: if( useSeekResult ){
! 1469: pik_flags |= OPFLAG_USESEEKRESULT;
! 1470: }
! 1471: sqlite3VdbeAddOp3(v, OP_Insert, baseCur, regRec, regRowid);
! 1472: if( !pParse->nested ){
! 1473: sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
! 1474: }
! 1475: sqlite3VdbeChangeP5(v, pik_flags);
! 1476: }
! 1477:
! 1478: /*
! 1479: ** Generate code that will open cursors for a table and for all
! 1480: ** indices of that table. The "baseCur" parameter is the cursor number used
! 1481: ** for the table. Indices are opened on subsequent cursors.
! 1482: **
! 1483: ** Return the number of indices on the table.
! 1484: */
! 1485: int sqlite3OpenTableAndIndices(
! 1486: Parse *pParse, /* Parsing context */
! 1487: Table *pTab, /* Table to be opened */
! 1488: int baseCur, /* Cursor number assigned to the table */
! 1489: int op /* OP_OpenRead or OP_OpenWrite */
! 1490: ){
! 1491: int i;
! 1492: int iDb;
! 1493: Index *pIdx;
! 1494: Vdbe *v;
! 1495:
! 1496: if( IsVirtual(pTab) ) return 0;
! 1497: iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
! 1498: v = sqlite3GetVdbe(pParse);
! 1499: assert( v!=0 );
! 1500: sqlite3OpenTable(pParse, baseCur, iDb, pTab, op);
! 1501: for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
! 1502: KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
! 1503: assert( pIdx->pSchema==pTab->pSchema );
! 1504: sqlite3VdbeAddOp4(v, op, i+baseCur, pIdx->tnum, iDb,
! 1505: (char*)pKey, P4_KEYINFO_HANDOFF);
! 1506: VdbeComment((v, "%s", pIdx->zName));
! 1507: }
! 1508: if( pParse->nTab<baseCur+i ){
! 1509: pParse->nTab = baseCur+i;
! 1510: }
! 1511: return i-1;
! 1512: }
! 1513:
! 1514:
! 1515: #ifdef SQLITE_TEST
! 1516: /*
! 1517: ** The following global variable is incremented whenever the
! 1518: ** transfer optimization is used. This is used for testing
! 1519: ** purposes only - to make sure the transfer optimization really
! 1520: ** is happening when it is suppose to.
! 1521: */
! 1522: int sqlite3_xferopt_count;
! 1523: #endif /* SQLITE_TEST */
! 1524:
! 1525:
! 1526: #ifndef SQLITE_OMIT_XFER_OPT
! 1527: /*
! 1528: ** Check to collation names to see if they are compatible.
! 1529: */
! 1530: static int xferCompatibleCollation(const char *z1, const char *z2){
! 1531: if( z1==0 ){
! 1532: return z2==0;
! 1533: }
! 1534: if( z2==0 ){
! 1535: return 0;
! 1536: }
! 1537: return sqlite3StrICmp(z1, z2)==0;
! 1538: }
! 1539:
! 1540:
! 1541: /*
! 1542: ** Check to see if index pSrc is compatible as a source of data
! 1543: ** for index pDest in an insert transfer optimization. The rules
! 1544: ** for a compatible index:
! 1545: **
! 1546: ** * The index is over the same set of columns
! 1547: ** * The same DESC and ASC markings occurs on all columns
! 1548: ** * The same onError processing (OE_Abort, OE_Ignore, etc)
! 1549: ** * The same collating sequence on each column
! 1550: */
! 1551: static int xferCompatibleIndex(Index *pDest, Index *pSrc){
! 1552: int i;
! 1553: assert( pDest && pSrc );
! 1554: assert( pDest->pTable!=pSrc->pTable );
! 1555: if( pDest->nColumn!=pSrc->nColumn ){
! 1556: return 0; /* Different number of columns */
! 1557: }
! 1558: if( pDest->onError!=pSrc->onError ){
! 1559: return 0; /* Different conflict resolution strategies */
! 1560: }
! 1561: for(i=0; i<pSrc->nColumn; i++){
! 1562: if( pSrc->aiColumn[i]!=pDest->aiColumn[i] ){
! 1563: return 0; /* Different columns indexed */
! 1564: }
! 1565: if( pSrc->aSortOrder[i]!=pDest->aSortOrder[i] ){
! 1566: return 0; /* Different sort orders */
! 1567: }
! 1568: if( !xferCompatibleCollation(pSrc->azColl[i],pDest->azColl[i]) ){
! 1569: return 0; /* Different collating sequences */
! 1570: }
! 1571: }
! 1572:
! 1573: /* If no test above fails then the indices must be compatible */
! 1574: return 1;
! 1575: }
! 1576:
! 1577: /*
! 1578: ** Attempt the transfer optimization on INSERTs of the form
! 1579: **
! 1580: ** INSERT INTO tab1 SELECT * FROM tab2;
! 1581: **
! 1582: ** The xfer optimization transfers raw records from tab2 over to tab1.
! 1583: ** Columns are not decoded and reassemblied, which greatly improves
! 1584: ** performance. Raw index records are transferred in the same way.
! 1585: **
! 1586: ** The xfer optimization is only attempted if tab1 and tab2 are compatible.
! 1587: ** There are lots of rules for determining compatibility - see comments
! 1588: ** embedded in the code for details.
! 1589: **
! 1590: ** This routine returns TRUE if the optimization is guaranteed to be used.
! 1591: ** Sometimes the xfer optimization will only work if the destination table
! 1592: ** is empty - a factor that can only be determined at run-time. In that
! 1593: ** case, this routine generates code for the xfer optimization but also
! 1594: ** does a test to see if the destination table is empty and jumps over the
! 1595: ** xfer optimization code if the test fails. In that case, this routine
! 1596: ** returns FALSE so that the caller will know to go ahead and generate
! 1597: ** an unoptimized transfer. This routine also returns FALSE if there
! 1598: ** is no chance that the xfer optimization can be applied.
! 1599: **
! 1600: ** This optimization is particularly useful at making VACUUM run faster.
! 1601: */
! 1602: static int xferOptimization(
! 1603: Parse *pParse, /* Parser context */
! 1604: Table *pDest, /* The table we are inserting into */
! 1605: Select *pSelect, /* A SELECT statement to use as the data source */
! 1606: int onError, /* How to handle constraint errors */
! 1607: int iDbDest /* The database of pDest */
! 1608: ){
! 1609: ExprList *pEList; /* The result set of the SELECT */
! 1610: Table *pSrc; /* The table in the FROM clause of SELECT */
! 1611: Index *pSrcIdx, *pDestIdx; /* Source and destination indices */
! 1612: struct SrcList_item *pItem; /* An element of pSelect->pSrc */
! 1613: int i; /* Loop counter */
! 1614: int iDbSrc; /* The database of pSrc */
! 1615: int iSrc, iDest; /* Cursors from source and destination */
! 1616: int addr1, addr2; /* Loop addresses */
! 1617: int emptyDestTest; /* Address of test for empty pDest */
! 1618: int emptySrcTest; /* Address of test for empty pSrc */
! 1619: Vdbe *v; /* The VDBE we are building */
! 1620: KeyInfo *pKey; /* Key information for an index */
! 1621: int regAutoinc; /* Memory register used by AUTOINC */
! 1622: int destHasUniqueIdx = 0; /* True if pDest has a UNIQUE index */
! 1623: int regData, regRowid; /* Registers holding data and rowid */
! 1624:
! 1625: if( pSelect==0 ){
! 1626: return 0; /* Must be of the form INSERT INTO ... SELECT ... */
! 1627: }
! 1628: if( sqlite3TriggerList(pParse, pDest) ){
! 1629: return 0; /* tab1 must not have triggers */
! 1630: }
! 1631: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 1632: if( pDest->tabFlags & TF_Virtual ){
! 1633: return 0; /* tab1 must not be a virtual table */
! 1634: }
! 1635: #endif
! 1636: if( onError==OE_Default ){
! 1637: if( pDest->iPKey>=0 ) onError = pDest->keyConf;
! 1638: if( onError==OE_Default ) onError = OE_Abort;
! 1639: }
! 1640: assert(pSelect->pSrc); /* allocated even if there is no FROM clause */
! 1641: if( pSelect->pSrc->nSrc!=1 ){
! 1642: return 0; /* FROM clause must have exactly one term */
! 1643: }
! 1644: if( pSelect->pSrc->a[0].pSelect ){
! 1645: return 0; /* FROM clause cannot contain a subquery */
! 1646: }
! 1647: if( pSelect->pWhere ){
! 1648: return 0; /* SELECT may not have a WHERE clause */
! 1649: }
! 1650: if( pSelect->pOrderBy ){
! 1651: return 0; /* SELECT may not have an ORDER BY clause */
! 1652: }
! 1653: /* Do not need to test for a HAVING clause. If HAVING is present but
! 1654: ** there is no ORDER BY, we will get an error. */
! 1655: if( pSelect->pGroupBy ){
! 1656: return 0; /* SELECT may not have a GROUP BY clause */
! 1657: }
! 1658: if( pSelect->pLimit ){
! 1659: return 0; /* SELECT may not have a LIMIT clause */
! 1660: }
! 1661: assert( pSelect->pOffset==0 ); /* Must be so if pLimit==0 */
! 1662: if( pSelect->pPrior ){
! 1663: return 0; /* SELECT may not be a compound query */
! 1664: }
! 1665: if( pSelect->selFlags & SF_Distinct ){
! 1666: return 0; /* SELECT may not be DISTINCT */
! 1667: }
! 1668: pEList = pSelect->pEList;
! 1669: assert( pEList!=0 );
! 1670: if( pEList->nExpr!=1 ){
! 1671: return 0; /* The result set must have exactly one column */
! 1672: }
! 1673: assert( pEList->a[0].pExpr );
! 1674: if( pEList->a[0].pExpr->op!=TK_ALL ){
! 1675: return 0; /* The result set must be the special operator "*" */
! 1676: }
! 1677:
! 1678: /* At this point we have established that the statement is of the
! 1679: ** correct syntactic form to participate in this optimization. Now
! 1680: ** we have to check the semantics.
! 1681: */
! 1682: pItem = pSelect->pSrc->a;
! 1683: pSrc = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
! 1684: if( pSrc==0 ){
! 1685: return 0; /* FROM clause does not contain a real table */
! 1686: }
! 1687: if( pSrc==pDest ){
! 1688: return 0; /* tab1 and tab2 may not be the same table */
! 1689: }
! 1690: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 1691: if( pSrc->tabFlags & TF_Virtual ){
! 1692: return 0; /* tab2 must not be a virtual table */
! 1693: }
! 1694: #endif
! 1695: if( pSrc->pSelect ){
! 1696: return 0; /* tab2 may not be a view */
! 1697: }
! 1698: if( pDest->nCol!=pSrc->nCol ){
! 1699: return 0; /* Number of columns must be the same in tab1 and tab2 */
! 1700: }
! 1701: if( pDest->iPKey!=pSrc->iPKey ){
! 1702: return 0; /* Both tables must have the same INTEGER PRIMARY KEY */
! 1703: }
! 1704: for(i=0; i<pDest->nCol; i++){
! 1705: if( pDest->aCol[i].affinity!=pSrc->aCol[i].affinity ){
! 1706: return 0; /* Affinity must be the same on all columns */
! 1707: }
! 1708: if( !xferCompatibleCollation(pDest->aCol[i].zColl, pSrc->aCol[i].zColl) ){
! 1709: return 0; /* Collating sequence must be the same on all columns */
! 1710: }
! 1711: if( pDest->aCol[i].notNull && !pSrc->aCol[i].notNull ){
! 1712: return 0; /* tab2 must be NOT NULL if tab1 is */
! 1713: }
! 1714: }
! 1715: for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
! 1716: if( pDestIdx->onError!=OE_None ){
! 1717: destHasUniqueIdx = 1;
! 1718: }
! 1719: for(pSrcIdx=pSrc->pIndex; pSrcIdx; pSrcIdx=pSrcIdx->pNext){
! 1720: if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
! 1721: }
! 1722: if( pSrcIdx==0 ){
! 1723: return 0; /* pDestIdx has no corresponding index in pSrc */
! 1724: }
! 1725: }
! 1726: #ifndef SQLITE_OMIT_CHECK
! 1727: if( pDest->pCheck && sqlite3ExprCompare(pSrc->pCheck, pDest->pCheck) ){
! 1728: return 0; /* Tables have different CHECK constraints. Ticket #2252 */
! 1729: }
! 1730: #endif
! 1731: #ifndef SQLITE_OMIT_FOREIGN_KEY
! 1732: /* Disallow the transfer optimization if the destination table constains
! 1733: ** any foreign key constraints. This is more restrictive than necessary.
! 1734: ** But the main beneficiary of the transfer optimization is the VACUUM
! 1735: ** command, and the VACUUM command disables foreign key constraints. So
! 1736: ** the extra complication to make this rule less restrictive is probably
! 1737: ** not worth the effort. Ticket [6284df89debdfa61db8073e062908af0c9b6118e]
! 1738: */
! 1739: if( (pParse->db->flags & SQLITE_ForeignKeys)!=0 && pDest->pFKey!=0 ){
! 1740: return 0;
! 1741: }
! 1742: #endif
! 1743: if( (pParse->db->flags & SQLITE_CountRows)!=0 ){
! 1744: return 0; /* xfer opt does not play well with PRAGMA count_changes */
! 1745: }
! 1746:
! 1747: /* If we get this far, it means that the xfer optimization is at
! 1748: ** least a possibility, though it might only work if the destination
! 1749: ** table (tab1) is initially empty.
! 1750: */
! 1751: #ifdef SQLITE_TEST
! 1752: sqlite3_xferopt_count++;
! 1753: #endif
! 1754: iDbSrc = sqlite3SchemaToIndex(pParse->db, pSrc->pSchema);
! 1755: v = sqlite3GetVdbe(pParse);
! 1756: sqlite3CodeVerifySchema(pParse, iDbSrc);
! 1757: iSrc = pParse->nTab++;
! 1758: iDest = pParse->nTab++;
! 1759: regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
! 1760: sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
! 1761: if( (pDest->iPKey<0 && pDest->pIndex!=0) /* (1) */
! 1762: || destHasUniqueIdx /* (2) */
! 1763: || (onError!=OE_Abort && onError!=OE_Rollback) /* (3) */
! 1764: ){
! 1765: /* In some circumstances, we are able to run the xfer optimization
! 1766: ** only if the destination table is initially empty. This code makes
! 1767: ** that determination. Conditions under which the destination must
! 1768: ** be empty:
! 1769: **
! 1770: ** (1) There is no INTEGER PRIMARY KEY but there are indices.
! 1771: ** (If the destination is not initially empty, the rowid fields
! 1772: ** of index entries might need to change.)
! 1773: **
! 1774: ** (2) The destination has a unique index. (The xfer optimization
! 1775: ** is unable to test uniqueness.)
! 1776: **
! 1777: ** (3) onError is something other than OE_Abort and OE_Rollback.
! 1778: */
! 1779: addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iDest, 0);
! 1780: emptyDestTest = sqlite3VdbeAddOp2(v, OP_Goto, 0, 0);
! 1781: sqlite3VdbeJumpHere(v, addr1);
! 1782: }else{
! 1783: emptyDestTest = 0;
! 1784: }
! 1785: sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
! 1786: emptySrcTest = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0);
! 1787: regData = sqlite3GetTempReg(pParse);
! 1788: regRowid = sqlite3GetTempReg(pParse);
! 1789: if( pDest->iPKey>=0 ){
! 1790: addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
! 1791: addr2 = sqlite3VdbeAddOp3(v, OP_NotExists, iDest, 0, regRowid);
! 1792: sqlite3HaltConstraint(
! 1793: pParse, onError, "PRIMARY KEY must be unique", P4_STATIC);
! 1794: sqlite3VdbeJumpHere(v, addr2);
! 1795: autoIncStep(pParse, regAutoinc, regRowid);
! 1796: }else if( pDest->pIndex==0 ){
! 1797: addr1 = sqlite3VdbeAddOp2(v, OP_NewRowid, iDest, regRowid);
! 1798: }else{
! 1799: addr1 = sqlite3VdbeAddOp2(v, OP_Rowid, iSrc, regRowid);
! 1800: assert( (pDest->tabFlags & TF_Autoincrement)==0 );
! 1801: }
! 1802: sqlite3VdbeAddOp2(v, OP_RowData, iSrc, regData);
! 1803: sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid);
! 1804: sqlite3VdbeChangeP5(v, OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND);
! 1805: sqlite3VdbeChangeP4(v, -1, pDest->zName, 0);
! 1806: sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1);
! 1807: for(pDestIdx=pDest->pIndex; pDestIdx; pDestIdx=pDestIdx->pNext){
! 1808: for(pSrcIdx=pSrc->pIndex; ALWAYS(pSrcIdx); pSrcIdx=pSrcIdx->pNext){
! 1809: if( xferCompatibleIndex(pDestIdx, pSrcIdx) ) break;
! 1810: }
! 1811: assert( pSrcIdx );
! 1812: sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
! 1813: sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
! 1814: pKey = sqlite3IndexKeyinfo(pParse, pSrcIdx);
! 1815: sqlite3VdbeAddOp4(v, OP_OpenRead, iSrc, pSrcIdx->tnum, iDbSrc,
! 1816: (char*)pKey, P4_KEYINFO_HANDOFF);
! 1817: VdbeComment((v, "%s", pSrcIdx->zName));
! 1818: pKey = sqlite3IndexKeyinfo(pParse, pDestIdx);
! 1819: sqlite3VdbeAddOp4(v, OP_OpenWrite, iDest, pDestIdx->tnum, iDbDest,
! 1820: (char*)pKey, P4_KEYINFO_HANDOFF);
! 1821: VdbeComment((v, "%s", pDestIdx->zName));
! 1822: addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iSrc, 0);
! 1823: sqlite3VdbeAddOp2(v, OP_RowKey, iSrc, regData);
! 1824: sqlite3VdbeAddOp3(v, OP_IdxInsert, iDest, regData, 1);
! 1825: sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1+1);
! 1826: sqlite3VdbeJumpHere(v, addr1);
! 1827: }
! 1828: sqlite3VdbeJumpHere(v, emptySrcTest);
! 1829: sqlite3ReleaseTempReg(pParse, regRowid);
! 1830: sqlite3ReleaseTempReg(pParse, regData);
! 1831: sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
! 1832: sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
! 1833: if( emptyDestTest ){
! 1834: sqlite3VdbeAddOp2(v, OP_Halt, SQLITE_OK, 0);
! 1835: sqlite3VdbeJumpHere(v, emptyDestTest);
! 1836: sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
! 1837: return 0;
! 1838: }else{
! 1839: return 1;
! 1840: }
! 1841: }
! 1842: #endif /* SQLITE_OMIT_XFER_OPT */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to insert.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src