Index: src/expr.c ================================================================== --- src/expr.c +++ src/expr.c @@ -4893,10 +4893,17 @@ #endif case TK_STRING: { assert( !ExprHasProperty(pExpr, EP_IntValue) ); sqlite3VdbeLoadString(v, target, pExpr->u.zToken); return target; + } + case TK_DEFAULT: { + /* If the DEFAULT keyword ever gets this far, that means it was used + ** in a context that is not supported. So raise an error. */ + sqlite3ErrorMsg(pParse, "near \"default\": syntax error"); + sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr); + return target; } default: { /* Make NULL the default case so that if a bug causes an illegal ** Expr node to be passed into this function, it will be handled ** sanely and not crash. But keep the assert() to bring the problem Index: src/insert.c ================================================================== --- src/insert.c +++ src/insert.c @@ -669,15 +669,22 @@ ** d) One or more of the values in the first row of the VALUES clause ** has an affinity (i.e. is a CAST expression). This causes problems ** because the complex rules SQLite uses (see function ** sqlite3SubqueryColumnTypes() in select.c) to determine the effective ** affinity of such a column for all rows require access to all values in -** the column simultaneously. +** the column simultaneously. +** +** e) The DEFAULT keyword cannot have been used in any of the terms +** of the VALUES clause. This optimization won't work in that case +** because we do not yet know the mapping from VALUES-clause terms +** into table columns, so we cannot figure out which column default +** value to use in place of the DEFAULT keyword. */ Select *sqlite3MultiValues(Parse *pParse, Select *pLeft, ExprList *pRow){ if( pParse->bHasWith /* condition (a) above */ + || pParse->bDfltInExpr /* condition (e) above */ || pParse->db->init.busy /* condition (b) above */ || exprListIsConstant(pParse,pRow)==0 /* condition (c) above */ || (pLeft->pSrc->nSrc==0 && exprListIsNoAffinity(pParse,pLeft->pEList)==0) /* condition (d) above */ || IN_SPECIAL_PARSE @@ -779,10 +786,120 @@ sqlite3ExprListDelete(pParse->db, pRow); } return pLeft; } + +/* +** The aTabColMap[] array maps table columns into terms of the IDLIST +** of an INSERT. For example, if we have: +** +** CREATE TABLE t1(a,b,c,d,e,f,g); +** \/ \___________/ +** pTab----' `-------- pTab->aCol[] +** +** And we do: +** +** INSERT INTO t1(e,b,g) .... +** \/ \___/ +** pTab---' `----- IDLIST +** +** Then aTabColMap[] contains: { 0, 2, 0, 0, 1, 0, 3 } +** Thus aTabColMap provides a one-based mapping of table column indexes into +** IDLIST entries. 0 means "none" because there are often table columns +** that are not in the IDLIST. The left-most table columns is 1, and +** the next table columns is 2 and so forth. +** +** This routine creates a new array (obtained from sqlite3DbMalloc() - +** the caller must free it) that inverts the mapping. The returned +** array aColTabMap[] would be {4, 1, 6}. This new mapping is zero-based. +** +** The aTabColMap input might both be NULL. This means that the IDLIST +** on the INSERT is omitted. This routine still constructs a column map, +** but in this case it maps "insertable" columns of the table into actual +** columns. Hidden and computed columns are not "insertable" and are +** thus skipped. +*/ +static int *computeColTabMap( + Parse *pParse, /* Parsing context */ + int *const aTabColMap, /* Mapping from table column to IDList column */ + Table *pTab, /* The table */ + int nId /* Number of columns in the IDLIST */ +){ + int *aColTabMap; + + if( pParse->nErr ) return 0; + assert( pTab->nCol>0 ); + aColTabMap = sqlite3DbMallocZero(pParse->db, sizeof(int)*nId); + if( aColTabMap==0 ) return 0; + if( aTabColMap ){ + /* Invert the aTabColMap[] */ + int i; + assert( sqlite3DbMallocSize(pParse->db, aTabColMap) >= + sizeof(int)*pTab->nCol ); + for(i=0; inCol; i++){ + if( aTabColMap[i]>0 ){ + aColTabMap[aTabColMap[i]-1] = i; + } + } + }else{ + /* Construct a new mapping that merely skips over non-insertable terms */ + int i, j; + for(i=j=0; inCol; i++){ + if( (pTab->aCol[i].colFlags & COLFLAG_NOINSERT)==0 ){ + aColTabMap[j++] = i; + } + } + } + return aColTabMap; +} + +/* +** Expression pExpr is a DEFAULT keyword. Transform that expression to +** an expansion of the actual default value for the iCol-th column of +** table pTab. +*/ +void sqlite3ExpandDefaultValue( + Parse *pParse, /* Parsing context */ + Expr *pExpr, /* Expression to be transformed */ + Table *pTab, /* Table that supplies the new value to pExpr */ + int iCol /* Column of pTab that contains the new value for pExpr */ +){ + assert( pExpr->op==TK_DEFAULT ); + assert( iCol>=0 && iColnCol ); + if( pTab->aCol[iCol].iDflt==0 ){ + pExpr->op = TK_NULL; + }else{ + Expr *pDfltVal = sqlite3ColumnExpr(pTab, &pTab->aCol[iCol]); + pExpr->op = TK_UPLUS; + assert( pExpr->pLeft==0 ); + pExpr->pLeft = sqlite3ExprDup(pParse->db, pDfltVal, 0); + } +} + +/* +** Scan all expressions in pList. If any is just a DEFAULT keyword, +** convert that expression into a new expression that evaluates to +** the default value of the corresponding table. +*/ +static void convertDefaultExpr( + Parse *pParse, /* Parsing context */ + int *aColTabMap, /* Mapping from pList entry to pTab column number */ + Table *pTab, /* Table being inserted into */ + ExprList *pList, /* The list to scan */ + int nId /* Number of columns in aColTabMap */ +){ + int i; + assert( aColTabMap!=0 ); + assert( sqlite3DbMallocSize(pParse->db, aColTabMap) >= sizeof(int)*nId ); + for(i=0; inExpr && ia[i].pExpr; + if( p->op==TK_DEFAULT ){ + sqlite3ExpandDefaultValue(pParse, p, pTab, aColTabMap[i]); + } + } +} /* Forward declaration */ static int xferOptimization( Parse *pParse, /* Parser context */ Table *pDest, /* The table we are inserting into */ @@ -843,11 +960,12 @@ ** close cursors ** end foreach ** ** The 3rd template is for when the second template does not apply ** and the SELECT clause does not read from at any time. -** The generated code follows this template: +** This template is also used when the INSERT has a VALUES clause with +** two or more rows. Pseudocode for this, the 3rd template is: ** ** X <- A ** goto B ** A: setup for the SELECT ** loop over the rows in the SELECT @@ -862,11 +980,11 @@ ** goto C ** D: cleanup ** ** The 4th template is used if the insert statement takes its ** values from a SELECT but the data is being inserted into a table -** that is also read as part of the SELECT. In the third form, +** that is also read as part of the SELECT. In the fourth form, ** we have to use an intermediate table to store the results of ** the select. The template is like this: ** ** X <- A ** goto B @@ -1101,10 +1219,36 @@ goto insert_cleanup; } } } } + + /* If there are DEFAULT keywords within VALUES clauses on the right-hand + ** side of this INSERT, convert them into the corresponding column default + ** values. + */ + if( pParse->bDfltInExpr && (pList || pSelect) ){ + int nId; + int *aColTabMap; + nId = pColumn ? pColumn->nId : 0; + if( pTab->nCol > nId ) nId = pTab->nCol; + aColTabMap = computeColTabMap(pParse, aTabColMap, pTab, nId); + if( aColTabMap==0 ){ + assert( pParse->nErr ); + }else if( pSelect==0 ){ + /* A single-row VALUES clause in pList */ + convertDefaultExpr(pParse, aColTabMap, pTab, pList, nId); + }else if( (pSelect->selFlags & SF_Values)!=0 ){ + /* A multi-row VALUES clause in pSelect */ + Select *pS = pSelect; + do{ + convertDefaultExpr(pParse, aColTabMap, pTab, pS->pEList, nId); + pS = pS->pPrior; + }while( pS ); + } + sqlite3DbFree(db, aColTabMap); + } /* Figure out how many columns of data are supplied. If the data ** is coming from a SELECT statement, then generate a co-routine that ** produces a single row of the SELECT on each invocation. The ** co-routine is the common header to the 3rd and 4th templates. Index: src/parse.y ================================================================== --- src/parse.y +++ src/parse.y @@ -1401,10 +1401,17 @@ expr(A) ::= expr(B) PTR(C) expr(D). { ExprList *pList = sqlite3ExprListAppend(pParse, 0, B); pList = sqlite3ExprListAppend(pParse, pList, D); A = sqlite3ExprFunction(pParse, pList, &C, 0); } + +expr(A) ::= DEFAULT(X). { + Expr *p = sqlite3Expr(pParse->db, TK_DEFAULT, 0); + sqlite3ExprSetErrorOffset(p, (int)(X.z - pParse->zTail)); + pParse->bDfltInExpr = 1; + A = p; +} %type between_op {int} between_op(A) ::= BETWEEN. {A = 0;} between_op(A) ::= NOT BETWEEN. {A = 1;} expr(A) ::= expr(A) between_op(N) expr(X) AND expr(Y). [BETWEEN] { Index: src/sqliteInt.h ================================================================== --- src/sqliteInt.h +++ src/sqliteInt.h @@ -3853,10 +3853,11 @@ #endif bft colNamesSet :1; /* TRUE after OP_ColumnName has been issued to pVdbe */ bft bHasWith :1; /* True if statement contains WITH */ bft okConstFactor :1; /* OK to factor out constants */ bft checkSchema :1; /* Causes schema cookie check after an error */ + bft bDfltInExpr :1; /* DEFAULT keyword occurs in an expression */ int nRangeReg; /* Size of the temporary register block */ int iRangeReg; /* First register in temporary register block */ int nErr; /* Number of errors seen */ int nTab; /* Number of previously allocated VDBE cursors */ int nMem; /* Number of memory cells used so far */ @@ -4973,10 +4974,11 @@ void sqlite3AutoincrementEnd(Parse *pParse); #else # define sqlite3AutoincrementBegin(X) # define sqlite3AutoincrementEnd(X) #endif +void sqlite3ExpandDefaultValue(Parse*, Expr*, Table*, int); void sqlite3Insert(Parse*, SrcList*, Select*, IdList*, int, Upsert*); #ifndef SQLITE_OMIT_GENERATED_COLUMNS void sqlite3ComputeGeneratedColumns(Parse*, int, Table*); #endif void *sqlite3ArrayAllocate(sqlite3*,void*,int,int*,int*); Index: src/update.c ================================================================== --- src/update.c +++ src/update.c @@ -488,10 +488,13 @@ pTab->aCol[j].zCnName); goto update_cleanup; } #endif aXRef[j] = i; + if( pChanges->a[i].pExpr->op==TK_DEFAULT ){ + sqlite3ExpandDefaultValue(pParse, pChanges->a[i].pExpr, pTab, j); + } }else{ if( pPk==0 && sqlite3IsRowid(pChanges->a[i].zEName) ){ j = -1; chngRowid = 1; pRowidExpr = pChanges->a[i].pExpr;