Lines Matching defs:pParse
10305 Parse *pParse; /* Parsing and code generating context */
10315 double savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */
10342 Parse *pParse; /* The parser */
10607 #define IN_DECLARE_VTAB (pParse->declareVtab)
10616 Parse *pParse; /* The Parse structure */
10726 Parse *pParse; /* The parsing context. Error messages written here */
10804 Parse *pParse; /* Parser context. */
11053 SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse);
11054 SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse);
11279 SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse);
11281 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
11282 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr);
11284 SQLITE_PRIVATE Expr *sqlite3ExprSetCollByToken(Parse *pParse, Expr*, Token*);
11498 SQLITE_PRIVATE void sqlite3ExprSetHeight(Parse *pParse, Expr *p);
20354 ** Add an error message to pParse->zErrMsg and increment pParse->nErr.
20370 SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
20373 sqlite3 *db = pParse->db;
20380 pParse->nErr++;
20381 sqlite3DbFree(db, pParse->zErrMsg);
20382 pParse->zErrMsg = zMsg;
20383 pParse->rc = SQLITE_ERROR;
55355 Parse *pParse;
55357 pParse = sqlite3StackAllocZero(pErrorDb, sizeof(*pParse));
55358 if( pParse==0 ){
55362 pParse->db = pDb;
55363 if( sqlite3OpenTempDatabase(pParse) ){
55364 sqlite3Error(pErrorDb, pParse->rc, "%s", pParse->zErrMsg);
55367 sqlite3DbFree(pErrorDb, pParse->zErrMsg);
55368 sqlite3StackFree(pErrorDb, pParse);
57467 ** Check if the program stored in the VM associated with pParse may
57484 ** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) );
68584 Parse *pParse = 0;
68594 pParse = sqlite3StackAllocRaw(db, sizeof(*pParse));
68595 if( !pParse ) goto blob_open_out;
68598 memset(pParse, 0, sizeof(Parse));
68599 pParse->db = db;
68604 pTab = sqlite3LocateTable(pParse, 0, zTable, zDb);
68607 sqlite3ErrorMsg(pParse, "cannot open virtual table: %s", zTable);
68612 sqlite3ErrorMsg(pParse, "cannot open view: %s", zTable);
68616 if( pParse
68618 zErr = pParse->zErrMsg;
68619 pParse->zErrMsg = 0;
68752 sqlite3StackFree(db, pParse);
69580 Parse *pParse, /* Parsing context */
69594 db = pParse->db;
69597 pDup = sqlite3PExpr(pParse, TK_AS, pDup, 0, 0);
69600 pEList->a[iCol].iAlias = (u16)(++pParse->nAlias);
69657 ** in pParse and return WRC_Abort. Return WRC_Prune on success.
69660 Parse *pParse, /* The parsing context */
69670 sqlite3 *db = pParse->db; /* The database connection */
69761 if( zDb==0 && zTab!=0 && cnt==0 && pParse->pTriggerTab!=0 ){
69762 int op = pParse->eTriggerOp;
69767 pTab = pParse->pTriggerTab;
69770 pTab = pParse->pTriggerTab;
69796 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
69800 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
69841 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
69844 resolveAlias(pParse, pEList, j, pExpr, "");
69885 sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
69887 sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
69889 sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
69891 pParse->checkSchema = 1;
69921 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
69972 Parse *pParse;
69976 pParse = pNC->pParse;
69977 assert( pParse==pWalker->pParse );
69986 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
70014 return lookupName(pParse, 0, 0, pExpr->u.zToken, pNC, pExpr);
70038 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
70054 u8 enc = ENC(pParse->db); /* The database encoding */
70060 pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0);
70062 pDef = sqlite3FindFunction(pParse->db, zId, nId, -1, enc, 0);
70073 auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0);
70076 sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
70086 sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId);
70090 sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
70093 sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
70119 sqlite3ErrorMsg(pParse,"subqueries prohibited in CHECK constraints");
70133 sqlite3ErrorMsg(pParse,"parameters prohibited in CHECK constraints");
70139 return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
70155 Parse *pParse, /* Parsing context for error messages */
70161 UNUSED_PARAMETER(pParse);
70194 Parse *pParse, /* Parsing context for error messages */
70211 nc.pParse = pParse;
70216 db = pParse->db;
70241 Parse *pParse, /* The error context into which to write the error */
70246 sqlite3ErrorMsg(pParse,
70267 Parse *pParse, /* Parsing context. Leave error messages here */
70278 db = pParse->db;
70281 sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
70305 resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr);
70309 iCol = resolveAsName(pParse, pEList, pE);
70314 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
70338 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
70353 ** If any errors are detected, add an error message to pParse and
70357 Parse *pParse, /* Parsing context. Leave error messages here */
70363 sqlite3 *db = pParse->db;
70367 if( pOrderBy==0 || pParse->db->mallocFailed ) return 0;
70370 sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
70379 resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
70382 resolveAlias(pParse, pEList, pItem->iCol-1, pItem->pExpr, zType);
70403 ** an appropriate error message might be left in pParse. (OOM errors
70415 Parse *pParse; /* Parsing context */
70420 pParse = pNC->pParse;
70423 iCol = resolveAsName(pParse, pSelect->pEList, pE);
70437 resolveOutOfRangeError(pParse, zType, i+1, nResult);
70450 return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType);
70461 Parse *pParse; /* Parsing context */
70474 pParse = pWalker->pParse;
70475 db = pParse->db;
70486 sqlite3SelectPrep(pParse, p, pOuterNC);
70487 return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune;
70502 sNC.pParse = pParse;
70530 const char *zSavedContext = pParse->zAuthContext;
70531 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
70532 sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
70533 pParse->zAuthContext = zSavedContext;
70534 if( pParse->nErr || db->mallocFailed ) return WRC_Abort;
70552 sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
70600 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
70616 if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){
70668 ** An error message is left in pParse if anything is amiss. The number
70681 Parse *pParse = pNC->pParse;
70682 if( sqlite3ExprCheckHeight(pParse, pExpr->nHeight+pNC->pParse->nHeight) ){
70685 pParse->nHeight += pExpr->nHeight;
70692 w.pParse = pNC->pParse;
70696 pNC->pParse->nHeight -= pExpr->nHeight;
70698 if( pNC->nErr>0 || w.pParse->nErr>0 ){
70723 Parse *pParse, /* The parser context */
70732 w.pParse = pParse;
70814 SQLITE_PRIVATE Expr *sqlite3ExprSetCollByToken(Parse *pParse, Expr *pExpr, Token *pCollName){
70817 sqlite3 *db = pParse->db;
70819 pColl = sqlite3LocateCollSeq(pParse, zColl);
70829 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
70845 sqlite3 *db = pParse->db;
70857 if( sqlite3CheckCollSeq(pParse, pColl) ){
70953 Parse *pParse,
70966 pColl = sqlite3ExprCollSeq(pParse, pLeft);
70968 pColl = sqlite3ExprCollSeq(pParse, pRight);
70978 Parse *pParse, /* The parsing (and code generating) context */
70990 p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
70992 addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
70994 sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
71002 ** pParse.
71004 SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){
71006 int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
71008 sqlite3ErrorMsg(pParse,
71075 ** leave an error in pParse.
71077 SQLITE_PRIVATE void sqlite3ExprSetHeight(Parse *pParse, Expr *p){
71079 sqlite3ExprCheckHeight(pParse, p->nHeight);
71213 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
71217 Parse *pParse, /* Parsing context */
71223 Expr *p = sqlite3ExprAlloc(pParse->db, op, pToken, 1);
71224 sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
71226 sqlite3ExprCheckHeight(pParse, p->nHeight);
71251 SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){
71253 sqlite3 *db = pParse->db;
71262 sqlite3ExprSetHeight(pParse, pNew);
71282 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
71283 sqlite3 *db = pParse->db;
71294 pExpr->iColumn = (ynVar)(++pParse->nVar);
71306 sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
71309 if( i>pParse->nVar ){
71310 pParse->nVar = (int)i;
71318 for(i=0; i<pParse->nVarExpr; i++){
71319 Expr *pE = pParse->apVarExpr[i];
71326 if( i>=pParse->nVarExpr ){
71327 pExpr->iColumn = (ynVar)(++pParse->nVar);
71328 if( pParse->nVarExpr>=pParse->nVarExprAlloc-1 ){
71329 pParse->nVarExprAlloc += pParse->nVarExprAlloc + 10;
71330 pParse->apVarExpr =
71333 pParse->apVarExpr,
71334 pParse->nVarExprAlloc*sizeof(pParse->apVarExpr[0])
71338 assert( pParse->apVarExpr!=0 );
71339 pParse->apVarExpr[pParse->nVarExpr++] = pExpr;
71343 if( !pParse->nErr && pParse->nVar>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
71344 sqlite3ErrorMsg(pParse, "too many SQL variables");
71717 Parse *pParse, /* Parsing context */
71721 sqlite3 *db = pParse->db;
71759 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
71763 Parse *pParse, /* Parsing context */
71768 assert( pList!=0 || pParse->db->mallocFailed!=0 );
71774 pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
71784 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
71788 Parse *pParse, /* Parsing context */
71792 sqlite3 *db = pParse->db;
71806 ** leave an error message in pParse.
71809 Parse *pParse,
71813 int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
71817 sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
72165 SQLITE_PRIVATE int sqlite3FindInIndex(Parse *pParse, Expr *pX, int *prNotFound){
72168 int iTab = pParse->nTab++; /* Cursor of the RHS table */
72178 if( ALWAYS(pParse->nErr==0) && isCandidateForInOpt(p) ){
72179 sqlite3 *db = pParse->db; /* Database connection */
72182 Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
72188 sqlite3CodeVerifySchema(pParse, iDb);
72189 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
72197 int iMem = ++pParse->nMem;
72203 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
72213 CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
72227 int iMem = ++pParse->nMem;
72231 pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
72242 *prNotFound = ++pParse->nMem;
72253 double savedNQueryLoop = pParse->nQueryLoop;
72257 *prNotFound = rMayHaveNull = ++pParse->nMem;
72259 testcase( pParse->nQueryLoop>(double)1 );
72260 pParse->nQueryLoop = (double)1;
72265 sqlite3CodeSubselect(pParse, pX, rMayHaveNull, eType==IN_INDEX_ROWID);
72266 pParse->nQueryLoop = savedNQueryLoop;
72309 Parse *pParse, /* Parsing context */
72316 Vdbe *v = sqlite3GetVdbe(pParse);
72318 sqlite3ExprCachePush(pParse);
72330 if( !ExprHasAnyProperty(pExpr, EP_VarSelect) && !pParse->pTriggerTab ){
72331 int mem = ++pParse->nMem;
72334 assert( testAddr>0 || pParse->db->mallocFailed );
72338 if( pParse->explain==2 ){
72340 pParse->db, "EXECUTE %s%s SUBQUERY %d", testAddr?"":"CORRELATED ",
72341 pExpr->op==TK_IN?"LIST":"SCALAR", pParse->iNextSelectId
72343 sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
72373 pExpr->iTable = pParse->nTab++;
72393 if( sqlite3Select(pParse, pExpr->x.pSelect, &dest) ){
72398 keyInfo.aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
72417 keyInfo.aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
72420 r1 = sqlite3GetTempReg(pParse);
72421 r2 = sqlite3GetTempReg(pParse);
72441 r3 = sqlite3ExprCodeTarget(pParse, pE2, r1);
72448 sqlite3ExprCacheAffinityChange(pParse, r3, 1);
72453 sqlite3ReleaseTempReg(pParse, r1);
72454 sqlite3ReleaseTempReg(pParse, r2);
72480 sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
72490 sqlite3ExprDelete(pParse->db, pSel->pLimit);
72491 pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0,
72494 if( sqlite3Select(pParse, pSel, &dest) ){
72506 sqlite3ExprCachePop(pParse, 1);
72531 Parse *pParse, /* Parsing and code generating context */
72545 v = pParse->pVdbe;
72548 eType = sqlite3FindInIndex(pParse, pExpr, &rRhsHasNull);
72558 sqlite3ExprCachePush(pParse);
72559 r1 = sqlite3GetTempReg(pParse);
72560 sqlite3ExprCode(pParse, pExpr->pLeft, r1);
72640 sqlite3ReleaseTempReg(pParse, r1);
72641 sqlite3ExprCachePop(pParse, 1);
72686 static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
72687 Vdbe *v = pParse->pVdbe;
72706 sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
72717 static void cacheEntryClear(Parse *pParse, struct yColCache *p){
72719 if( pParse->nTempReg<ArraySize(pParse->aTempReg) ){
72720 pParse->aTempReg[pParse->nTempReg++] = p->iReg;
72731 SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
72744 if( pParse->db->flags & SQLITE_ColumnCache ) return;
72752 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
72755 cacheEntryClear(pParse, p);
72756 p->iLevel = pParse->iCacheLevel;
72758 p->lru = pParse->iCacheCnt++;
72767 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
72769 p->iLevel = pParse->iCacheLevel;
72774 p->lru = pParse->iCacheCnt++;
72782 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
72789 p = &pParse->aColCache[idxLru];
72790 p->iLevel = pParse->iCacheLevel;
72795 p->lru = pParse->iCacheCnt++;
72804 SQLITE_PRIVATE void sqlite3ExprCacheRemove(Parse *pParse, int iReg, int nReg){
72808 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
72811 cacheEntryClear(pParse, p);
72822 SQLITE_PRIVATE void sqlite3ExprCachePush(Parse *pParse){
72823 pParse->iCacheLevel++;
72831 SQLITE_PRIVATE void sqlite3ExprCachePop(Parse *pParse, int N){
72835 assert( pParse->iCacheLevel>=N );
72836 pParse->iCacheLevel -= N;
72837 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
72838 if( p->iReg && p->iLevel>pParse->iCacheLevel ){
72839 cacheEntryClear(pParse, p);
72851 static void sqlite3ExprCachePinRegister(Parse *pParse, int iReg){
72854 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
72892 Parse *pParse, /* Parsing and code generating context */
72898 Vdbe *v = pParse->pVdbe;
72902 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
72904 p->lru = pParse->iCacheCnt++;
72905 sqlite3ExprCachePinRegister(pParse, p->iReg);
72911 sqlite3ExprCacheStore(pParse, iTable, iColumn, iReg);
72918 SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse *pParse){
72922 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
72924 cacheEntryClear(pParse, p);
72934 SQLITE_PRIVATE void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
72935 sqlite3ExprCacheRemove(pParse, iStart, iCount);
72942 SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
72946 sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
72947 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
72959 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, int iFrom, int iTo, int nReg){
72963 sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, iFrom+i, iTo+i);
72975 static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){
72978 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
72997 SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
72998 Vdbe *v = pParse->pVdbe; /* The VM under construction */
73004 sqlite3 *db = pParse->db; /* The database connection */
73006 assert( target>0 && target<=pParse->nMem );
73008 assert( pParse->db->mallocFailed );
73035 assert( pParse->ckBase>0 );
73036 pParse->ckBase;
73038 inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
73044 codeInteger(pParse, pExpr, 0, target);
73094 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
73101 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
73120 testcase( usedAsColumnCache(pParse, inReg, inReg) );
73121 sqlite3ExprCacheAffinityChange(pParse, inReg, 1);
73143 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
73144 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
73145 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
73155 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
73156 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
73158 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
73198 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
73199 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
73209 codeInteger(pParse, pLeft, 1, target);
73216 regFree1 = r1 = sqlite3GetTempReg(pParse);
73218 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
73231 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
73245 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
73256 sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
73288 sqlite3ErrorMsg(pParse, "unknown function: %.*s()", nId, zId);
73299 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
73302 sqlite3ExprCacheRemove(pParse, target, 1);
73303 sqlite3ExprCachePush(pParse);
73304 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
73305 sqlite3ExprCachePop(pParse, 1);
73313 r1 = sqlite3GetTempRange(pParse, nFarg);
73314 sqlite3ExprCachePush(pParse); /* Ticket 2ea2425d34be */
73315 sqlite3ExprCodeExprList(pParse, pFarg, r1, 1);
73316 sqlite3ExprCachePop(pParse, 1); /* Ticket 2ea2425d34be */
73344 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
73355 sqlite3ReleaseTempRange(pParse, r1, nFarg);
73364 inReg = sqlite3CodeSubselect(pParse, pExpr, 0, 0);
73371 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
73397 r1 = sqlite3ExprCodeTemp(pParse, pLeft, ®Free1);
73398 r2 = sqlite3ExprCodeTemp(pParse, pRight, ®Free2);
73401 r3 = sqlite3GetTempReg(pParse);
73402 r4 = sqlite3GetTempReg(pParse);
73403 codeCompare(pParse, pLeft, pRight, OP_Ge,
73407 sqlite3ReleaseTempReg(pParse, regFree2);
73408 r2 = sqlite3ExprCodeTemp(pParse, pRight, ®Free2);
73410 codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2);
73412 sqlite3ReleaseTempReg(pParse, r3);
73413 sqlite3ReleaseTempReg(pParse, r4);
73417 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
73507 VVA_ONLY( int iCacheLevel = pParse->iCacheLevel; )
73520 cacheX.iTable = sqlite3ExprCodeTemp(pParse, pX, ®Free1);
73533 sqlite3ExprCachePush(pParse);
73542 sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
73545 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
73547 sqlite3ExprCachePop(pParse, 1);
73551 sqlite3ExprCachePush(pParse);
73552 sqlite3ExprCode(pParse, pExpr->pRight, target);
73553 sqlite3ExprCachePop(pParse, 1);
73557 assert( db->mallocFailed || pParse->nErr>0
73558 || pParse->iCacheLevel==iCacheLevel );
73569 if( !pParse->pTriggerTab ){
73570 sqlite3ErrorMsg(pParse,
73575 sqlite3MayAbort(pParse);
73582 sqlite3HaltConstraint(pParse, pExpr->affinity, pExpr->u.zToken, 0);
73589 sqlite3ReleaseTempReg(pParse, regFree1);
73590 sqlite3ReleaseTempReg(pParse, regFree2);
73603 SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
73604 int r1 = sqlite3GetTempReg(pParse);
73605 int r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
73609 sqlite3ReleaseTempReg(pParse, r1);
73620 SQLITE_PRIVATE int sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
73623 assert( target>0 && target<=pParse->nMem );
73625 sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, pExpr->iTable, target);
73627 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
73628 assert( pParse->pVdbe || pParse->db->mallocFailed );
73629 if( inReg!=target && pParse->pVdbe ){
73630 sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
73648 SQLITE_PRIVATE int sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
73649 Vdbe *v = pParse->pVdbe;
73651 inReg = sqlite3ExprCode(pParse, pExpr, target);
73661 iMem = ++pParse->nMem;
73736 Parse *pParse = pWalker->pParse;
73762 int r1 = ++pParse->nMem;
73764 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
73765 if( NEVER(r1!=r2) ) sqlite3ReleaseTempReg(pParse, r1);
73790 SQLITE_PRIVATE void sqlite3ExprCodeConstants(Parse *pParse, Expr *pExpr){
73792 if( pParse->cookieGoto ) return;
73793 if( (pParse->db->flags & SQLITE_FactorOutConst)!=0 ) return;
73796 w.pParse = pParse;
73808 Parse *pParse, /* Parsing context */
73817 assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */
73821 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
73823 sqlite3VdbeAddOp2(pParse->pVdbe, doHardCopy ? OP_Copy : OP_SCopy,
73843 Parse *pParse, /* Parsing and code generating context */
73866 exprX.iTable = sqlite3ExprCodeTemp(pParse, &exprX, ®Free1);
73869 sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
73871 sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
73873 sqlite3ReleaseTempReg(pParse, regFree1);
73900 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
73901 Vdbe *v = pParse->pVdbe;
73915 sqlite3ExprCachePush(pParse);
73916 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
73917 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
73919 sqlite3ExprCachePop(pParse, 1);
73924 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
73925 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
73930 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
73952 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
73953 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
73954 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
73964 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
73965 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
73967 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
73979 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
73986 exprCodeBetween(pParse, pExpr, dest, 1, jumpIfNull);
73993 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
74000 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
74007 sqlite3ReleaseTempReg(pParse, regFree1);
74008 sqlite3ReleaseTempReg(pParse, regFree2);
74020 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
74021 Vdbe *v = pParse->pVdbe;
74065 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
74066 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
74072 sqlite3ExprCachePush(pParse);
74073 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
74074 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
74076 sqlite3ExprCachePop(pParse, 1);
74081 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
74097 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
74098 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
74099 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
74109 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
74110 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
74112 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
74122 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
74129 exprCodeBetween(pParse, pExpr, dest, 0, jumpIfNull);
74135 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
74138 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
74145 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
74152 sqlite3ReleaseTempReg(pParse, regFree1);
74153 sqlite3ReleaseTempReg(pParse, regFree2);
74272 Parse *pParse = pNC->pParse;
74304 && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
74310 pCol->iMem = ++pParse->nMem;
74362 u8 enc = ENC(pParse->db);
74363 i = addAggInfoFunc(pParse->db, pAggInfo);
74368 pItem->iMem = ++pParse->nMem;
74370 pItem->pFunc = sqlite3FindFunction(pParse->db,
74374 pItem->iDistinct = pParse->nTab++;
74406 ** for variables that need to be added to the pParse->aAgg[] array.
74407 ** Make additional entries to the pParse->aAgg[] array as necessary.
74440 SQLITE_PRIVATE int sqlite3GetTempReg(Parse *pParse){
74441 if( pParse->nTempReg==0 ){
74442 return ++pParse->nMem;
74444 return pParse->aTempReg[--pParse->nTempReg];
74455 SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
74456 if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
74459 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
74465 pParse->aTempReg[pParse->nTempReg++] = iReg;
74472 SQLITE_PRIVATE int sqlite3GetTempRange(Parse *pParse, int nReg){
74474 i = pParse->iRangeReg;
74475 n = pParse->nRangeReg;
74477 assert( !usedAsColumnCache(pParse, i, i+n-1) );
74478 pParse->iRangeReg += nReg;
74479 pParse->nRangeReg -= nReg;
74481 i = pParse->nMem+1;
74482 pParse->nMem += nReg;
74486 SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
74487 sqlite3ExprCacheRemove(pParse, iReg, nReg);
74488 if( nReg>pParse->nRangeReg ){
74489 pParse->nRangeReg = nReg;
74490 pParse->iRangeReg = iReg;
74776 static char *whereForeignKeys(Parse *pParse, Table *pTab){
74780 zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName);
74792 static char *whereTempTriggers(Parse *pParse, Table *pTab){
74795 const Schema *pTempSchema = pParse->db->aDb[1].pSchema; /* Temp db schema */
74803 sqlite3 *db = pParse->db;
74804 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
74811 char *zNew = sqlite3MPrintf(pParse->db, "type='trigger' AND (%s)", zWhere);
74812 sqlite3DbFree(pParse->db, zWhere);
74826 static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
74834 v = sqlite3GetVdbe(pParse);
74836 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
74837 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
74842 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
74843 int iTrigDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
74853 zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName);
74861 if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
74871 ** in pParse->zErr (system tables may not be altered) and returns non-zero.
74875 static int isSystemTable(Parse *pParse, const char *zName){
74877 sqlite3ErrorMsg(pParse, "table %s may not be altered", zName);
74888 Parse *pParse, /* Parser context. */
74896 sqlite3 *db = pParse->db; /* Database connection */
74909 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
74911 pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
74913 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
74925 sqlite3ErrorMsg(pParse,
74933 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
74936 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto
74942 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
74949 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
74955 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
74971 v = sqlite3GetVdbe(pParse);
74975 sqlite3BeginWriteOperation(pParse, pVTab!=0, iDb);
74976 sqlite3ChangeCookie(pParse, iDb);
74985 int i = ++pParse->nMem;
74988 sqlite3MayAbort(pParse);
75001 if( (zWhere=whereForeignKeys(pParse, pTab))!=0 ){
75002 sqlite3NestedParse(pParse,
75012 sqlite3NestedParse(pParse,
75041 sqlite3NestedParse(pParse,
75052 if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
75053 sqlite3NestedParse(pParse,
75068 reloadTableSchema(pParse, p->pFrom, pFrom->zName);
75075 reloadTableSchema(pParse, pTab, zName);
75088 SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){
75090 v = sqlite3GetVdbe(pParse);
75095 int r1 = sqlite3GetTempReg(pParse);
75096 int r2 = sqlite3GetTempReg(pParse);
75104 sqlite3ReleaseTempReg(pParse, r1);
75105 sqlite3ReleaseTempReg(pParse, r2);
75114 ** The Table structure pParse->pNewTable was extended to include
75117 SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
75118 Table *pNew; /* Copy of pParse->pNewTable */
75128 db = pParse->db;
75129 if( pParse->nErr || db->mallocFailed ) return;
75130 pNew = pParse->pNewTable;
75144 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
75162 sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column");
75166 sqlite3ErrorMsg(pParse, "Cannot add a UNIQUE column");
75170 sqlite3ErrorMsg(pParse,
75175 sqlite3ErrorMsg(pParse,
75190 sqlite3ErrorMsg(pParse, "Cannot add a column with non-constant default");
75205 sqlite3NestedParse(pParse,
75220 sqlite3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2);
75223 reloadTableSchema(pParse, pTab, pTab->zName);
75241 SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
75248 sqlite3 *db = pParse->db;
75251 assert( pParse->pNewTable==0 );
75254 pTab = sqlite3LocateTable(pParse, 0, pSrc->a[0].zName, pSrc->a[0].zDatabase);
75259 sqlite3ErrorMsg(pParse, "virtual tables may not be altered");
75266 sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
75269 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
75285 pParse->pNewTable = pNew;
75311 sqlite3BeginWriteOperation(pParse, 0, iDb);
75312 v = sqlite3GetVdbe(pParse);
75314 sqlite3ChangeCookie(pParse, iDb);
75356 Parse *pParse, /* Parsing context */
75376 sqlite3 *db = pParse->db;
75378 Vdbe *v = sqlite3GetVdbe(pParse);
75390 ** of the new table in register pParse->regRoot. This is important
75392 sqlite3NestedParse(pParse,
75395 aRoot[i] = pParse->regRoot;
75402 sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab);
75404 sqlite3NestedParse(pParse,
75427 Parse *pParse, /* Parser context */
75433 sqlite3 *db = pParse->db; /* Database handle */
75459 v = sqlite3GetVdbe(pParse);
75476 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
75483 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
75485 iIdxCur = pParse->nTab++;
75493 pKey = sqlite3IndexKeyinfo(pParse, pIdx);
75494 if( iMem+1+(nCol*2)>pParse->nMem ){
75495 pParse->nMem = iMem+1+(nCol*2);
75603 pColl = sqlite3LocateCollSeq(pParse, pIdx->azColl[i]);
75686 if( pParse->nMem<regRec ) pParse->nMem = regRec;
75694 static void loadAnalysis(Parse *pParse, int iDb){
75695 Vdbe *v = sqlite3GetVdbe(pParse);
75704 static void analyzeDatabase(Parse *pParse, int iDb){
75705 sqlite3 *db = pParse->db;
75711 sqlite3BeginWriteOperation(pParse, 0, iDb);
75712 iStatCur = pParse->nTab;
75713 pParse->nTab += 2;
75714 openStatTable(pParse, iDb, iStatCur, 0, 0);
75715 iMem = pParse->nMem+1;
75719 analyzeOneTable(pParse, pTab, 0, iStatCur, iMem);
75721 loadAnalysis(pParse, iDb);
75729 static void analyzeTable(Parse *pParse, Table *pTab, Index *pOnlyIdx){
75734 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
75735 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
75736 sqlite3BeginWriteOperation(pParse, 0, iDb);
75737 iStatCur = pParse->nTab;
75738 pParse->nTab += 2;
75740 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
75742 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
75744 analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur, pParse->nMem+1);
75745 loadAnalysis(pParse, iDb);
75760 SQLITE_PRIVATE void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){
75761 sqlite3 *db = pParse->db;
75770 ** and code in pParse and return NULL. */
75771 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
75772 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
75781 analyzeDatabase(pParse, i);
75787 analyzeDatabase(pParse, iDb);
75792 analyzeTable(pParse, pIdx->pTable, pIdx);
75793 }else if( (pTab = sqlite3LocateTable(pParse, 0, z, 0))!=0 ){
75794 analyzeTable(pParse, pTab, 0);
75801 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
75807 analyzeTable(pParse, pIdx->pTable, pIdx);
75808 }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
75809 analyzeTable(pParse, pTab, 0);
76085 sqlite3ErrorMsg(pName->pParse, "invalid name: \"%s\"", pExpr->u.zToken);
76332 Parse *pParse, /* The parser context */
76343 sqlite3* db = pParse->db;
76347 sName.pParse = pParse;
76354 pParse->nErr++;
76366 rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
76374 v = sqlite3GetVdbe(pParse);
76375 regArgs = sqlite3GetTempRange(pParse, 4);
76376 sqlite3ExprCode(pParse, pFilename, regArgs);
76377 sqlite3ExprCode(pParse, pDbname, regArgs+1);
76378 sqlite3ExprCode(pParse, pKey, regArgs+2);
76405 SQLITE_PRIVATE void sqlite3Detach(Parse *pParse, Expr *pDbname){
76419 codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname);
76427 SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
76441 codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
76454 Parse *pParse, /* Error messages will be written here */
76462 db = pParse->db;
76464 pFix->pParse = pParse;
76482 ** pParse->zErrMsg and these routines return non-zero. If everything
76497 pItem->zDatabase = sqlite3DbStrDup(pFix->pParse->db, zDb);
76499 sqlite3ErrorMsg(pFix->pParse,
76672 ** Write an error message into pParse->zErrMsg that explains that the
76675 static void sqliteAuthBadReturnCode(Parse *pParse){
76676 sqlite3ErrorMsg(pParse, "authorizer malfunction");
76677 pParse->rc = SQLITE_ERROR;
76687 ** is treated as SQLITE_DENY. In this case an error is left in pParse.
76690 Parse *pParse, /* The parser context */
76695 sqlite3 *db = pParse->db; /* Database handle */
76699 rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext);
76702 sqlite3ErrorMsg(pParse, "access to %s.%s.%s is prohibited",zDb,zTab,zCol);
76704 sqlite3ErrorMsg(pParse, "access to %s.%s is prohibited", zTab, zCol);
76706 pParse->rc = SQLITE_AUTH;
76708 sqliteAuthBadReturnCode(pParse);
76723 Parse *pParse, /* The parser context */
76728 sqlite3 *db = pParse->db;
76736 iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
76745 pTab = pParse->pTriggerTab;
76768 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
76776 ** is returned, then the error count and error message in pParse are
76780 Parse *pParse,
76786 sqlite3 *db = pParse->db;
76799 rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext);
76801 sqlite3ErrorMsg(pParse, "not authorized");
76802 pParse->rc = SQLITE_AUTH;
76805 sqliteAuthBadReturnCode(pParse);
76813 ** popped. Or if pParse==0, this routine is a no-op.
76816 Parse *pParse,
76820 assert( pParse );
76821 pContext->pParse = pParse;
76822 pContext->zAuthContext = pParse->zAuthContext;
76823 pParse->zAuthContext = zContext;
76831 if( pContext->pParse ){
76832 pContext->pParse->zAuthContext = pContext->zAuthContext;
76833 pContext->pParse = 0;
76868 ** be parsed. Initialize the pParse structure as needed.
76870 SQLITE_PRIVATE void sqlite3BeginParse(Parse *pParse, int explainFlag){
76871 pParse->explain = (u8)explainFlag;
76872 pParse->nVar = 0;
76898 Parse *pParse, /* Parsing context */
76904 Parse *pToplevel = sqlite3ParseToplevel(pParse);
76937 static void codeTableLocks(Parse *pParse){
76941 pVdbe = sqlite3GetVdbe(pParse);
76944 for(i=0; i<pParse->nTableLock; i++){
76945 TableLock *p = &pParse->aTableLock[i];
76959 ** VDBE program and resets the pParse structure for the next
76965 SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){
76969 db = pParse->db;
76971 if( pParse->nested ) return;
76972 if( pParse->nErr ) return;
76977 v = sqlite3GetVdbe(pParse);
76978 assert( !pParse->isMultiWrite
76979 || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
76989 if( pParse->cookieGoto>0 ){
76992 sqlite3VdbeJumpHere(v, pParse->cookieGoto-1);
76994 if( (mask & pParse->cookieMask)==0 ) continue;
76996 sqlite3VdbeAddOp2(v,OP_Transaction, iDb, (mask & pParse->writeMask)!=0);
77000 iDb, pParse->cookieValue[iDb],
77007 for(i=0; i<pParse->nVtabLock; i++){
77008 char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
77011 pParse->nVtabLock = 0;
77019 codeTableLocks(pParse);
77023 sqlite3AutoincrementBegin(pParse);
77026 sqlite3VdbeAddOp2(v, OP_Goto, 0, pParse->cookieGoto);
77033 if( v && ALWAYS(pParse->nErr==0) && !db->mallocFailed ){
77038 assert( pParse->iCacheLevel==0 ); /* Disables and re-enables match */
77041 if( pParse->pAinc!=0 && pParse->nTab==0 ) pParse->nTab = 1;
77042 sqlite3VdbeMakeReady(v, pParse->nVar, pParse->nMem,
77043 pParse->nTab, pParse->nMaxArg, pParse->explain,
77044 pParse->isMultiWrite && pParse->mayAbort);
77045 pParse->rc = SQLITE_DONE;
77046 pParse->colNamesSet = 0;
77048 pParse->rc = SQLITE_ERROR;
77050 pParse->nTab = 0;
77051 pParse->nMem = 0;
77052 pParse->nSet = 0;
77053 pParse->nVar = 0;
77054 pParse->cookieMask = 0;
77055 pParse->cookieGoto = 0;
77060 ** code for the SQL statement given onto the end of the pParse context
77070 SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
77074 sqlite3 *db = pParse->db;
77078 if( pParse->nErr ) return;
77079 assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
77086 pParse->nested++;
77087 memcpy(saveBuf, &pParse->nVar, SAVE_SZ);
77088 memset(&pParse->nVar, 0, SAVE_SZ);
77089 sqlite3RunParser(pParse, zSql, &zErrMsg);
77092 memcpy(&pParse->nVar, saveBuf, SAVE_SZ);
77093 pParse->nested--;
77130 ** error message in pParse->zErrMsg.
77133 ** routine leaves an error message in pParse->zErrMsg where
77137 Parse *pParse, /* context in which to report errors */
77145 ** and code in pParse and return NULL. */
77146 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
77150 p = sqlite3FindTable(pParse->db, zName, zDbase);
77154 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
77156 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
77158 pParse->checkSchema = 1;
77500 Parse *pParse, /* Parsing and code generating context */
77506 sqlite3 *db = pParse->db;
77510 sqlite3ErrorMsg(pParse, "corrupt database");
77511 pParse->nErr++;
77517 sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
77518 pParse->nErr++;
77536 SQLITE_PRIVATE int sqlite3CheckObjectName(Parse *pParse, const char *zName){
77537 if( !pParse->db->init.busy && pParse->nested==0
77538 && (pParse->db->flags & SQLITE_WriteSchema)==0
77540 sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
77556 ** The new table record is initialized and put in pParse->pNewTable.
77563 Parse *pParse, /* Parser context */
77573 sqlite3 *db = pParse->db;
77595 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
77600 sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
77605 pParse->sNameToken = *pName;
77608 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
77617 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
77633 if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){
77648 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
77654 sqlite3ErrorMsg(pParse, "table %T already exists", pName);
77657 sqlite3CodeVerifySchema(pParse, iDb);
77662 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
77670 pParse->rc = SQLITE_NOMEM;
77671 pParse->nErr++;
77679 assert( pParse->pNewTable==0 );
77680 pParse->pNewTable = pTable;
77687 if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
77701 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
77705 sqlite3BeginWriteOperation(pParse, 0, iDb);
77716 reg1 = pParse->regRowid = ++pParse->nMem;
77717 reg2 = pParse->regRoot = ++pParse->nMem;
77718 reg3 = ++pParse->nMem;
77734 ** The rowid for the new entry is left in register pParse->regRowid.
77735 ** The root page number of the new table is left in reg pParse->regRoot.
77747 sqlite3OpenMasterTable(pParse, iDb);
77785 SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token *pName){
77790 sqlite3 *db = pParse->db;
77791 if( (p = pParse->pNewTable)==0 ) return;
77794 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
77802 sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
77834 SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){
77836 p = pParse->pNewTable;
77911 SQLITE_PRIVATE void sqlite3AddColumnType(Parse *pParse, Token *pType){
77915 p = pParse->pNewTable;
77919 pCol->zType = sqlite3NameFromToken(pParse->db, pType);
77933 SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse *pParse, ExprSpan *pSpan){
77936 sqlite3 *db = pParse->db;
77937 p = pParse->pNewTable;
77941 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
77977 Parse *pParse, /* Parsing context */
77983 Table *pTab = pParse->pNewTable;
77988 sqlite3ErrorMsg(pParse,
78020 sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
78025 p = sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0, 0, sortOrder, 0);
78033 sqlite3ExprListDelete(pParse->db, pList);
78041 Parse *pParse, /* Parsing context */
78044 sqlite3 *db = pParse->db;
78046 Table *pTab = pParse->pNewTable;
78060 SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){
78066 if( (p = pParse->pNewTable)==0 ) return;
78068 db = pParse->db;
78072 if( sqlite3LocateCollSeq(pParse, zColl) ){
78103 ** pParse.
78111 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
78112 sqlite3 *db = pParse->db;
78121 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
78145 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
78146 int r1 = sqlite3GetTempReg(pParse);
78147 sqlite3 *db = pParse->db;
78148 Vdbe *v = pParse->pVdbe;
78152 sqlite3ReleaseTempReg(pParse, r1);
78297 Parse *pParse, /* Parse context */
78303 sqlite3 *db = pParse->db;
78309 p = pParse->pNewTable;
78320 SrcList sSrc; /* Fake SrcList for pParse->pNewTable */
78321 NameContext sNC; /* Name context for pParse->pNewTable */
78329 sNC.pParse = pParse;
78361 v = sqlite3GetVdbe(pParse);
78383 ** new table is in register pParse->regRoot.
78398 assert(pParse->nTab==1);
78399 sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
78401 pParse->nTab = 2;
78403 sqlite3Select(pParse, pSelect, &dest);
78405 if( pParse->nErr==0 ){
78406 pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect);
78421 n = (int)(pEnd->z - pParse->sNameToken.z) + 1;
78423 "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
78431 sqlite3NestedParse(pParse,
78439 pParse->regRoot,
78441 pParse->regRowid
78444 sqlite3ChangeCookie(pParse, iDb);
78454 sqlite3NestedParse(pParse,
78481 pParse->pNewTable = 0;
78487 const char *zName = (const char *)pParse->sNameToken.z;
78505 Parse *pParse, /* The parsing context */
78520 sqlite3 *db = pParse->db;
78522 if( pParse->nVar>0 ){
78523 sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
78527 sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
78528 p = pParse->pNewTable;
78529 if( p==0 || pParse->nErr ){
78533 sqlite3TwoPartName(pParse, pName1, pName2, &pName);
78535 if( sqlite3FixInit(&sFix, pParse, iDb, "view", pName)
78553 sqlite3ViewGetColumnNames(pParse, p);
78559 sEnd = pParse->sLastToken;
78571 sqlite3EndTable(pParse, 0, &sEnd, 0);
78580 ** of errors. If an error is seen leave an error message in pParse->zErrMsg.
78582 SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
78587 sqlite3 *db = pParse->db; /* Database connection for malloc errors */
78593 if( sqlite3VtabCallConnect(pParse, pTable) ){
78621 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
78637 n = pParse->nTab;
78638 sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
78644 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
78647 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
78650 pParse->nTab = n;
78743 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
78744 Vdbe *v = sqlite3GetVdbe(pParse);
78745 int r1 = sqlite3GetTempReg(pParse);
78747 sqlite3MayAbort(pParse);
78758 sqlite3NestedParse(pParse,
78760 pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1);
78762 sqlite3ReleaseTempReg(pParse, r1);
78771 static void destroyTable(Parse *pParse, Table *pTab){
78774 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
78775 destroyRootPage(pParse, pTab->tnum, iDb);
78777 destroyRootPage(pParse, pIdx->tnum, iDb);
78816 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
78817 destroyRootPage(pParse, iLargest, iDb);
78828 SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
78831 sqlite3 *db = pParse->db;
78837 assert( pParse->nErr==0 );
78840 pTab = sqlite3LocateTable(pParse, isView,
78845 if( noErr ) sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
78854 if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
78863 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
78884 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
78887 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
78893 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
78902 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
78906 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
78914 v = sqlite3GetVdbe(pParse);
78918 sqlite3BeginWriteOperation(pParse, 1, iDb);
78925 sqlite3FkDropTable(pParse, pName, pTab);
78931 pTrigger = sqlite3TriggerList(pParse, pTab);
78935 sqlite3DropTriggerPtr(pParse, pTrigger);
78946 sqlite3NestedParse(pParse,
78960 sqlite3NestedParse(pParse,
78966 sqlite3NestedParse(pParse,
78972 destroyTable(pParse, pTab);
78982 sqlite3ChangeCookie(pParse, iDb);
79001 ** under construction in the pParse->pNewTable field.
79007 Parse *pParse, /* Parsing context */
79013 sqlite3 *db = pParse->db;
79017 Table *p = pParse->pNewTable;
79029 sqlite3ErrorMsg(pParse, "foreign key on %s"
79036 sqlite3ErrorMsg(pParse,
79074 sqlite3ErrorMsg(pParse,
79127 SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
79131 if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
79148 static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
79150 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
79151 int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
79158 sqlite3 *db = pParse->db; /* The database connection */
79162 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
79169 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
79171 v = sqlite3GetVdbe(pParse);
79179 pKey = sqlite3IndexKeyinfo(pParse, pIndex);
79185 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
79187 regRecord = sqlite3GetTempReg(pParse);
79188 regIdxKey = sqlite3GenerateIndexKey(pParse, pIndex, iTab, regRecord, 1);
79205 pParse, OE_Abort, "indexed columns are not unique", P4_STATIC);
79209 sqlite3ReleaseTempReg(pParse, regRecord);
79220 ** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
79221 ** as the table to be indexed. pParse->pNewTable is a table that is
79233 Parse *pParse, /* All information about this parse */
79236 SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
79253 sqlite3 *db = pParse->db;
79263 assert( pParse->nErr==0 ); /* Never called with prior errors */
79267 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
79281 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
79290 pTab = sqlite3SrcListLookup(pParse, pTblName);
79297 if( sqlite3FixInit(&sFix, pParse, iDb, "index", pName) &&
79304 pTab = sqlite3LocateTable(pParse, 0, pTblName->a[0].zName,
79310 pTab = pParse->pNewTable;
79317 assert( pParse->nErr==0 );
79320 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
79325 sqlite3ErrorMsg(pParse, "views may not be indexed");
79331 sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
79352 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
79357 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
79363 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
79366 pParse, iDb);
79385 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
79390 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
79403 pList = sqlite3ExprListAppend(pParse, 0, 0);
79405 sqlite3ExprListSetName(pParse, pList, &nullId, 0);
79483 sqlite3ErrorMsg(pParse, "table %s has no column named %s",
79485 pParse->checkSchema = 1;
79509 if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
79518 if( pTab==pParse->pNewTable ){
79566 sqlite3ErrorMsg(pParse,
79616 int iMem = ++pParse->nMem;
79618 v = sqlite3GetVdbe(pParse);
79624 sqlite3BeginWriteOperation(pParse, 1, iDb);
79645 sqlite3NestedParse(pParse,
79659 sqlite3RefillIndex(pParse, pIndex, iMem);
79660 sqlite3ChangeCookie(pParse, iDb);
79742 SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
79745 sqlite3 *db = pParse->db;
79748 assert( pParse->nErr==0 ); /* Never called with prior errors */
79753 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
79759 sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0);
79761 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
79763 pParse->checkSchema = 1;
79767 sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
79778 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
79782 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
79789 v = sqlite3GetVdbe(pParse);
79791 sqlite3BeginWriteOperation(pParse, 1, iDb);
79792 sqlite3NestedParse(pParse,
79798 sqlite3NestedParse(pParse,
79803 sqlite3ChangeCookie(pParse, iDb);
79804 destroyRootPage(pParse, pIndex->tnum, iDb);
80048 SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
80051 assert(pList || pParse->db->mallocFailed );
80055 pItem->iCursor = pParse->nTab++;
80057 sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
80100 Parse *pParse, /* Parsing context */
80110 sqlite3 *db = pParse->db;
80112 sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
80143 SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
80153 pItem->zIndex = sqlite3NameFromToken(pParse->db, pIndexedBy);
80186 SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){
80191 assert( pParse!=0 );
80192 db = pParse->db;
80195 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
80198 v = sqlite3GetVdbe(pParse);
80212 SQLITE_PRIVATE void sqlite3CommitTransaction(Parse *pParse){
80216 assert( pParse!=0 );
80217 db = pParse->db;
80220 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ){
80223 v = sqlite3GetVdbe(pParse);
80232 SQLITE_PRIVATE void sqlite3RollbackTransaction(Parse *pParse){
80236 assert( pParse!=0 );
80237 db = pParse->db;
80240 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ){
80243 v = sqlite3GetVdbe(pParse);
80253 SQLITE_PRIVATE void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
80254 char *zName = sqlite3NameFromToken(pParse->db, pName);
80256 Vdbe *v = sqlite3GetVdbe(pParse);
80261 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
80262 sqlite3DbFree(pParse->db, zName);
80271 ** the number of errors. Leave any error messages in the pParse structure.
80273 SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *pParse){
80274 sqlite3 *db = pParse->db;
80275 if( db->aDb[1].pBt==0 && !pParse->explain ){
80287 sqlite3ErrorMsg(pParse, "unable to open a temporary database "
80289 pParse->rc = rc;
80314 ** pParse->cookieMask field. Later, after all other code has been
80324 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
80325 Parse *pToplevel = sqlite3ParseToplevel(pParse);
80355 SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
80356 sqlite3 *db = pParse->db;
80361 sqlite3CodeVerifySchema(pParse, i);
80379 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
80380 Parse *pToplevel = sqlite3ParseToplevel(pParse);
80381 sqlite3CodeVerifySchema(pParse, iDb);
80393 SQLITE_PRIVATE void sqlite3MultiWrite(Parse *pParse){
80394 Parse *pToplevel = sqlite3ParseToplevel(pParse);
80414 SQLITE_PRIVATE void sqlite3MayAbort(Parse *pParse){
80415 Parse *pToplevel = sqlite3ParseToplevel(pParse);
80424 SQLITE_PRIVATE void sqlite3HaltConstraint(Parse *pParse, int onError, char *p4, int p4type){
80425 Vdbe *v = sqlite3GetVdbe(pParse);
80427 sqlite3MayAbort(pParse);
80456 static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
80461 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
80462 sqlite3BeginWriteOperation(pParse, 0, iDb);
80463 sqlite3RefillIndex(pParse, pIndex, -1);
80475 static void reindexDatabases(Parse *pParse, char const *zColl){
80478 sqlite3 *db = pParse->db; /* The database connection */
80487 reindexTable(pParse, pTab, zColl);
80507 SQLITE_PRIVATE void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
80514 sqlite3 *db = pParse->db; /* The database connection */
80518 ** and code in pParse and return NULL. */
80519 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
80524 reindexDatabases(pParse, 0);
80529 zColl = sqlite3NameFromToken(pParse->db, pName1);
80533 reindexDatabases(pParse, zColl);
80539 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
80546 reindexTable(pParse, pTab, 0);
80553 sqlite3BeginWriteOperation(pParse, 0, iDb);
80554 sqlite3RefillIndex(pParse, pIndex, -1);
80557 sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
80568 ** sequence), NULL is returned and the state of pParse updated to reflect
80571 SQLITE_PRIVATE KeyInfo *sqlite3IndexKeyinfo(Parse *pParse, Index *pIdx){
80575 sqlite3 *db = pParse->db;
80579 pKey->db = pParse->db;
80585 pKey->aColl[i] = sqlite3LocateCollSeq(pParse, zColl);
80591 if( pParse->nErr ){
80717 SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){
80720 sqlite3 *db = pParse->db;
80723 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
80724 pParse->nErr++;
81088 SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
81092 pTab = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
81093 sqlite3DeleteTable(pParse->db, pItem->pTab);
81098 if( sqlite3IndexedByLookup(pParse, pItem) ){
81109 SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
81118 ** In either case leave an error message in pParse and return non-zero.
81121 && sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 )
81123 && (pParse->db->flags & SQLITE_WriteSchema)==0
81124 && pParse->nested==0 )
81126 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
81132 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
81147 Parse *pParse, /* Parsing context */
81154 sqlite3 *db = pParse->db;
81171 pDup = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0);
81174 sqlite3Select(pParse, pDup, &dest);
81189 Parse *pParse, /* The parser context */
81207 sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType);
81208 pParse->parseError = 1;
81230 pSelectRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0);
81232 pEList = sqlite3ExprListAppend(pParse, 0, pSelectRowid);
81237 pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0);
81239 sqlite3ExprListDelete(pParse->db, pEList);
81244 pSelect = sqlite3SelectNew(pParse,pEList,pSelectSrc,pWhere,0,0,
81249 pWhereRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0);
81251 pInClause = sqlite3PExpr(pParse, TK_IN, pWhereRowid, 0, 0);
81256 sqlite3ExprSetHeight(pParse, pInClause);
81261 sqlite3SelectDelete(pParse->db, pSelect);
81265 sqlite3ExprDelete(pParse->db, pWhere);
81266 sqlite3ExprListDelete(pParse->db, pOrderBy);
81267 sqlite3ExprDelete(pParse->db, pLimit);
81268 sqlite3ExprDelete(pParse->db, pOffset);
81281 Parse *pParse, /* The parser context */
81306 db = pParse->db;
81307 if( pParse->nErr || db->mallocFailed ){
81317 pTab = sqlite3SrcListLookup(pParse, pTabList);
81324 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
81337 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
81341 if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){
81347 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb);
81357 iCur = pTabList->a[0].iCursor = pParse->nTab++;
81359 pParse->nTab++;
81365 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
81370 v = sqlite3GetVdbe(pParse);
81374 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
81375 sqlite3BeginWriteOperation(pParse, 1, iDb);
81382 sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
81389 sNC.pParse = pParse;
81399 memCnt = ++pParse->nMem;
81409 && 0==sqlite3FkRequired(pParse, pTab, 0, 0)
81424 int iRowSet = ++pParse->nMem; /* Register for rowset of rows to delete */
81425 int iRowid = ++pParse->nMem; /* Used for storing rowid values. */
81431 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere,0,WHERE_DUPLICATES_OK);
81433 regRowid = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iCur, iRowid);
81450 sqlite3OpenTableAndIndices(pParse, pTab, iCur, OP_OpenWrite);
81459 sqlite3VtabMakeWritable(pParse, pTab);
81461 sqlite3MayAbort(pParse);
81465 int count = (pParse->nested==0); /* True to count changes */
81466 sqlite3GenerateRowDelete(pParse, pTab, iCur, iRowid, count, pTrigger, OE_Default);
81486 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
81487 sqlite3AutoincrementEnd(pParse);
81494 if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
81536 Parse *pParse, /* Parsing context */
81544 Vdbe *v = pParse->pVdbe; /* Vdbe */
81559 if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
81566 pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf
81568 mask |= sqlite3FkOldmask(pParse, pTab);
81569 iOld = pParse->nMem+1;
81570 pParse->nMem += (1 + pTab->nCol);
81582 sqlite3CodeRowTrigger(pParse, pTrigger,
81595 sqlite3FkCheck(pParse, pTab, iOld, 0);
81602 sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, 0);
81612 sqlite3FkActions(pParse, pTab, 0, iOld);
81615 sqlite3CodeRowTrigger(pParse, pTrigger,
81642 Parse *pParse, /* Parsing and code generating context */
81653 r1 = sqlite3GenerateIndexKey(pParse, pIdx, iCur, 0, 0);
81654 sqlite3VdbeAddOp3(pParse->pVdbe, OP_IdxDelete, iCur+i, r1,pIdx->nColumn+1);
81670 Parse *pParse, /* Parsing context */
81676 Vdbe *v = pParse->pVdbe;
81683 regBase = sqlite3GetTempRange(pParse, nCol+1);
81698 sqlite3ReleaseTempRange(pParse, regBase, nCol+1);
83470 ** into pParse. If an OOM error occurs, non-zero is returned and the
83471 ** pParse->db->mallocFailed flag is set.
83474 Parse *pParse, /* Parse context to store any error in */
83488 assert( pParse );
83512 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
83569 if( !pParse->disableTriggers ){
83570 sqlite3ErrorMsg(pParse, "foreign key mismatch");
83572 sqlite3DbFree(pParse->db, aiCol);
83607 Parse *pParse, /* Parse context */
83618 Vdbe *v = sqlite3GetVdbe(pParse); /* Vdbe to add code to */
83619 int iCur = pParse->nTab - 1; /* Cursor number to use */
83642 int regTemp = sqlite3GetTempReg(pParse);
83660 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
83665 sqlite3ReleaseTempReg(pParse, regTemp);
83668 int regTemp = sqlite3GetTempRange(pParse, nCol);
83669 int regRec = sqlite3GetTempReg(pParse);
83670 KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
83696 sqlite3ReleaseTempReg(pParse, regRec);
83697 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
83701 if( !pFKey->isDeferred && !pParse->pToplevel && !pParse->isMultiWrite ){
83708 pParse, OE_Abort, "foreign key constraint failed", P4_STATIC
83712 sqlite3ParseToplevel(pParse)->mayAbort = 1;
83750 Parse *pParse, /* Parse context */
83759 sqlite3 *db = pParse->db; /* Database handle */
83765 Vdbe *v = sqlite3GetVdbe(pParse);
83799 pLeft->pColl = sqlite3LocateCollSeq(pParse, pCol->zColl);
83809 pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight, 0);
83829 pEq = sqlite3PExpr(pParse, TK_NE, pLeft, pRight, 0);
83836 sNameContext.pParse = pParse;
83843 pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0, 0);
83845 sqlite3ParseToplevel(pParse)->mayAbort = 1;
83914 SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){
83915 sqlite3 *db = pParse->db;
83918 Vdbe *v = sqlite3GetVdbe(pParse);
83936 pParse->disableTriggers = 1;
83937 sqlite3DeleteFrom(pParse, sqlite3SrcListDup(db, pName, 0), 0);
83938 pParse->disableTriggers = 0;
83946 pParse, OE_Abort, "foreign key constraint failed", P4_STATIC
83976 Parse *pParse, /* Parse context */
83981 sqlite3 *db = pParse->db; /* Database handle */
83985 int isIgnoreErrors = pParse->disableTriggers;
84009 ** schema items cannot be located, set an error in pParse and return
84011 if( pParse->disableTriggers ){
84014 pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb);
84016 if( !pTo || locateFkeyIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){
84039 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
84048 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
84049 pParse->nTab++;
84055 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1,isIgnore);
84060 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1,isIgnore);
84072 if( !pFKey->isDeferred && !pParse->pToplevel && !pParse->isMultiWrite ){
84079 if( locateFkeyIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){
84094 pItem->iCursor = pParse->nTab++;
84097 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1);
84106 pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1);
84122 Parse *pParse, /* Parse context */
84126 if( pParse->db->flags&SQLITE_ForeignKeys ){
84134 locateFkeyIndex(pParse, pTab, p, &pIdx, 0);
84158 Parse *pParse, /* Parse context */
84163 if( pParse->db->flags&SQLITE_ForeignKeys ){
84233 Parse *pParse, /* Parse context */
84238 sqlite3 *db = pParse->db; /* Database handle */
84259 if( locateFkeyIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0;
84282 pEq = sqlite3PExpr(pParse, TK_EQ,
84283 sqlite3PExpr(pParse, TK_DOT,
84284 sqlite3PExpr(pParse, TK_ID, 0, 0, &tOld),
84285 sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol)
84287 sqlite3PExpr(pParse, TK_ID, 0, 0, &tFromCol)
84297 pEq = sqlite3PExpr(pParse, TK_IS,
84298 sqlite3PExpr(pParse, TK_DOT,
84299 sqlite3PExpr(pParse, TK_ID, 0, 0, &tOld),
84300 sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol),
84302 sqlite3PExpr(pParse, TK_DOT,
84303 sqlite3PExpr(pParse, TK_ID, 0, 0, &tNew),
84304 sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol),
84313 pNew = sqlite3PExpr(pParse, TK_DOT,
84314 sqlite3PExpr(pParse, TK_ID, 0, 0, &tNew),
84315 sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol)
84322 pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
84325 pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
84327 pList = sqlite3ExprListAppend(pParse, pList, pNew);
84328 sqlite3ExprListSetName(pParse, pList, &tFromCol, 0);
84346 pSelect = sqlite3SelectNew(pParse,
84347 sqlite3ExprListAppend(pParse, 0, pRaise),
84374 pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0, 0);
84418 Parse *pParse, /* Parse context */
84427 if( pParse->db->flags&SQLITE_ForeignKeys ){
84430 Trigger *pAction = fkActionTrigger(pParse, pTab, pFKey, pChanges);
84432 sqlite3CodeRowTriggerDirect(pParse, pAction, pTab, regOld, OE_Abort, 0);
84675 Parse *pParse, /* Parsing context */
84681 Parse *pToplevel = sqlite3ParseToplevel(pParse);
84687 pInfo = sqlite3DbMallocRaw(pParse->db, sizeof(*pInfo));
84706 SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){
84708 sqlite3 *db = pParse->db; /* The database connection */
84712 Vdbe *v = pParse->pVdbe; /* VDBE under construction */
84716 assert( pParse->pTriggerTab==0 );
84717 assert( pParse==sqlite3ParseToplevel(pParse) );
84720 for(p = pParse->pAinc; p; p = p->pNext){
84724 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
84748 static void autoIncStep(Parse *pParse, int memId, int regRowid){
84750 sqlite3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid);
84761 SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){
84763 Vdbe *v = pParse->pVdbe;
84764 sqlite3 *db = pParse->db;
84767 for(p = pParse->pAinc; p; p = p->pNext){
84773 iRec = sqlite3GetTempReg(pParse);
84775 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
84792 sqlite3ReleaseTempReg(pParse, iRec);
84807 Parse *pParse, /* Parser context */
84917 Parse *pParse, /* Parser context */
84962 db = pParse->db;
84964 if( pParse->nErr || db->mallocFailed ){
84973 pTab = sqlite3SrcListLookup(pParse, pTabList);
84981 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
84989 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
85006 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
85014 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
85020 v = sqlite3GetVdbe(pParse);
85022 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
85023 sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
85035 if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){
85045 regAutoinc = autoIncBegin(pParse, iDb, pTab);
85077 regEof = ++pParse->nMem;
85080 sqlite3SelectDestInit(&dest, SRT_Coroutine, ++pParse->nMem);
85087 rc = sqlite3Select(pParse, pSelect, &dest);
85088 assert( pParse->nErr==0 || rc );
85089 if( rc || NEVER(pParse->nErr) || db->mallocFailed ){
85112 if( pTrigger || readsTable(pParse, addrSelect, iDb, pTab) ){
85133 srcTab = pParse->nTab++;
85134 regRec = sqlite3GetTempReg(pParse);
85135 regTempRowid = sqlite3GetTempReg(pParse);
85144 sqlite3ReleaseTempReg(pParse, regRec);
85145 sqlite3ReleaseTempReg(pParse, regTempRowid);
85153 sNC.pParse = pParse;
85173 sqlite3ErrorMsg(pParse,
85179 sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
85212 sqlite3ErrorMsg(pParse, "table %S has no column named %s",
85214 pParse->checkSchema = 1;
85232 regRowCount = ++pParse->nMem;
85240 baseCur = pParse->nTab;
85241 nIdx = sqlite3OpenTableAndIndices(pParse, pTab, baseCur, OP_OpenWrite);
85247 aRegIdx[i] = ++pParse->nMem;
85281 regRowid = regIns = pParse->nMem+1;
85282 pParse->nMem += pTab->nCol + 1;
85285 pParse->nMem++;
85293 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
85309 sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regCols);
85333 sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regCols+i+1);
85338 sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr, regCols+i+1);
85353 sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_BEFORE,
85356 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
85376 sqlite3ExprCode(pParse, pList->a[keyColumn].pExpr, regRowid);
85407 autoIncStep(pParse, regAutoinc, regRowid);
85437 sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, iRegStore);
85443 sqlite3ExprCode(pParse, pList->a[j].pExpr, iRegStore);
85453 sqlite3VtabMakeWritable(pParse, pTab);
85455 sqlite3MayAbort(pParse);
85460 sqlite3GenerateConstraintChecks(pParse, pTab, baseCur, regIns, aRegIdx,
85463 sqlite3FkCheck(pParse, pTab, 0, regIns);
85465 pParse, pTab, baseCur, regIns, aRegIdx, 0, appendFlag, isReplace==0
85478 sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_AFTER,
85508 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
85509 sqlite3AutoincrementEnd(pParse);
85517 if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
85610 ** Or if overrideError==OE_Default, then the pParse->onError parameter
85611 ** is used. Or if pParse->onError==OE_Default then the onError value
85621 Parse *pParse, /* The parser context */
85644 v = sqlite3GetVdbe(pParse);
85670 sqlite3MayAbort(pParse);
85676 zMsg = sqlite3MPrintf(pParse->db, "%s.%s may not be NULL",
85688 sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regData+i);
85698 if( pTab->pCheck && (pParse->db->flags & SQLITE_IgnoreChecks)==0 ){
85700 pParse->ckBase = regData;
85701 sqlite3ExprIfTrue(pParse, pTab->pCheck, allOk, SQLITE_JUMPIFNULL);
85707 sqlite3HaltConstraint(pParse, onError, 0, 0);
85738 pParse, onError, "PRIMARY KEY must be unique", P4_STATIC);
85765 if( pParse->db->flags&SQLITE_RecTriggers ){
85766 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
85768 if( pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0) ){
85769 sqlite3MultiWrite(pParse);
85771 pParse, pTab, baseCur, regRowid, 0, pTrigger, OE_Replace
85774 sqlite3MultiWrite(pParse);
85775 sqlite3GenerateRowIndexDelete(pParse, pTab, baseCur, 0);
85803 regIdx = sqlite3GetTempRange(pParse, pIdx->nColumn+1);
85815 sqlite3ExprCacheAffinityChange(pParse, regIdx, pIdx->nColumn+1);
85820 sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn+1);
85834 regR = sqlite3GetTempReg(pParse);
85839 sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn+1);
85854 errMsg.db = pParse->db;
85865 sqlite3HaltConstraint(pParse, onError, zErr, 0);
85877 sqlite3MultiWrite(pParse);
85878 if( pParse->db->flags&SQLITE_RecTriggers ){
85879 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
85882 pParse, pTab, baseCur, regR, 0, pTrigger, OE_Replace
85889 sqlite3ReleaseTempReg(pParse, regR);
85907 Parse *pParse, /* The parser context */
85924 v = sqlite3GetVdbe(pParse);
85936 regRec = sqlite3GetTempReg(pParse);
85939 sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
85940 if( pParse->nested ){
85953 if( !pParse->nested ){
85967 Parse *pParse, /* Parsing context */
85978 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
85979 v = sqlite3GetVdbe(pParse);
85981 sqlite3OpenTable(pParse, baseCur, iDb, pTab, op);
85983 KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
85989 if( pParse->nTab<baseCur+i ){
85990 pParse->nTab = baseCur+i;
86090 Parse *pParse, /* Parser context */
86115 if( sqlite3TriggerList(pParse, pDest) ){
86172 pSrc = sqlite3LocateTable(pParse, 0, pItem->zName, pItem->zDatabase);
86232 iDbSrc = sqlite3SchemaToIndex(pParse->db, pSrc->pSchema);
86233 v = sqlite3GetVdbe(pParse);
86234 sqlite3CodeVerifySchema(pParse, iDbSrc);
86235 iSrc = pParse->nTab++;
86236 iDest = pParse->nTab++;
86237 regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
86238 sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
86256 sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
86258 regData = sqlite3GetTempReg(pParse);
86259 regRowid = sqlite3GetTempReg(pParse);
86264 pParse, onError, "PRIMARY KEY must be unique", P4_STATIC);
86266 autoIncStep(pParse, regAutoinc, regRowid);
86285 pKey = sqlite3IndexKeyinfo(pParse, pSrcIdx);
86289 pKey = sqlite3IndexKeyinfo(pParse, pDestIdx);
86300 sqlite3ReleaseTempReg(pParse, regRowid);
86301 sqlite3ReleaseTempReg(pParse, regData);
87644 static int invalidateTempStorage(Parse *pParse){
87645 sqlite3 *db = pParse->db;
87648 sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "
87666 static int changeTempStorage(Parse *pParse, const char *zStorageType){
87668 sqlite3 *db = pParse->db;
87670 if( invalidateTempStorage( pParse ) != SQLITE_OK ){
87681 static void returnSingleInt(Parse *pParse, const char *zLabel, i64 value){
87682 Vdbe *v = sqlite3GetVdbe(pParse);
87683 int mem = ++pParse->nMem;
87684 i64 *pI64 = sqlite3DbMallocRaw(pParse->db, sizeof(value));
87700 static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){
87743 sqlite3 *db = pParse->db;
87745 v = sqlite3GetVdbe(pParse);
87749 returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );
87838 Parse *pParse,
87849 sqlite3 *db = pParse->db;
87851 Vdbe *v = pParse->pVdbe = sqlite3VdbeCreate(db);
87854 pParse->nMem = 2;
87858 iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
87865 if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
87879 if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
87912 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
87917 pParse->nMem += 2;
87924 sqlite3BeginWriteOperation(pParse, 0, iDb);
87947 returnSingleInt(pParse, "page_size", size);
87981 returnSingleInt(pParse, "secure_delete", b);
88001 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
88002 sqlite3CodeVerifySchema(pParse, iDb);
88003 iReg = ++pParse->nMem;
88072 if( sqlite3ReadSchema(pParse) ){
88123 returnSingleInt(pParse, "journal_size_limit", iLimit);
88139 if( sqlite3ReadSchema(pParse) ){
88149 returnSingleInt(pParse, "auto_vacuum", auto_vacuum);
88197 if( sqlite3ReadSchema(pParse) ){
88203 sqlite3BeginWriteOperation(pParse, 0, iDb);
88229 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
88232 returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);
88253 returnSingleInt(pParse, "temp_store", db->temp_store);
88255 changeTempStorage(pParse, zRight);
88285 sqlite3ErrorMsg(pParse, "not a writable directory");
88293 invalidateTempStorage(pParse);
88348 sqlite3ErrorMsg(pParse, "failed to set lock proxy file");
88365 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
88367 returnSingleInt(pParse, "synchronous", pDb->safety_level-1);
88370 sqlite3ErrorMsg(pParse,
88380 if( flagPragma(pParse, zLeft, zRight) ){
88401 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
88408 pParse->nMem = 6;
88415 sqlite3ViewGetColumnNames(pParse, pTab);
88440 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
88446 pParse->nMem = 3;
88464 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
88467 v = sqlite3GetVdbe(pParse);
88472 pParse->nMem = 3;
88490 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
88492 pParse->nMem = 3;
88511 pParse->nMem = 2;
88527 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
88530 v = sqlite3GetVdbe(pParse);
88535 pParse->nMem = 8;
88618 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
88619 pParse->nMem = 6;
88641 sqlite3CodeVerifySchema(pParse, i);
88665 if( pParse->nMem < cnt+4 ){
88666 pParse->nMem = cnt+4;
88692 sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead);
88712 r1 = sqlite3GenerateIndexKey(pParse, pIdx, 1, 3, 0);
88798 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
88805 sqlite3VdbeChangeP4(v, -1, encnames[ENC(pParse->db)].zName, P4_STATIC);
88819 ENC(pParse->db) = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE;
88824 sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
88915 pParse->nMem = 1;
88940 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
88942 pParse->nMem = 3;
88963 returnSingleInt(pParse, "wal_autocheckpoint",
88979 pParse->nMem = 2;
89486 SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse){
89488 sqlite3 *db = pParse->db;
89491 rc = sqlite3Init(db, &pParse->zErrMsg);
89494 pParse->rc = rc;
89495 pParse->nErr++;
89503 ** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies
89504 ** make no changes to pParse->rc.
89506 static void schemaIsValid(Parse *pParse){
89507 sqlite3 *db = pParse->db;
89512 assert( pParse->checkSchema );
89538 pParse->rc = SQLITE_SCHEMA;
89592 Parse *pParse; /* Parsing context */
89598 pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
89599 if( pParse==0 ){
89603 pParse->pReprepare = pReprepare;
89647 pParse->db = db;
89648 pParse->nQueryLoop = (double)1;
89661 sqlite3RunParser(pParse, zSqlCopy, &zErrMsg);
89663 pParse->zTail = &zSql[pParse->zTail-zSqlCopy];
89665 pParse->zTail = &zSql[nBytes];
89668 sqlite3RunParser(pParse, zSql, &zErrMsg);
89670 assert( 1==(int)pParse->nQueryLoop );
89673 pParse->rc = SQLITE_NOMEM;
89675 if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK;
89676 if( pParse->checkSchema ){
89677 schemaIsValid(pParse);
89680 pParse->rc = SQLITE_NOMEM;
89683 *pzTail = pParse->zTail;
89685 rc = pParse->rc;
89688 if( rc==SQLITE_OK && pParse->pVdbe && pParse->explain ){
89694 if( pParse->explain==2 ){
89695 sqlite3VdbeSetNumCols(pParse->pVdbe, 4);
89699 sqlite3VdbeSetNumCols(pParse->pVdbe, 8);
89704 sqlite3VdbeSetColName(pParse->pVdbe, i-iFirst, COLNAME_NAME,
89712 Vdbe *pVdbe = pParse->pVdbe;
89713 sqlite3VdbeSetSql(pVdbe, zSql, (int)(pParse->zTail-zSql), saveSqlFlag);
89715 if( pParse->pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){
89716 sqlite3VdbeFinalize(pParse->pVdbe);
89719 *ppStmt = (sqlite3_stmt*)pParse->pVdbe;
89730 while( pParse->pTriggerPrg ){
89731 TriggerPrg *pT = pParse->pTriggerPrg;
89732 pParse->pTriggerPrg = pT->pNext;
89738 sqlite3StackFree(db, pParse);
89973 Parse *pParse, /* Parsing context */
89986 sqlite3 *db = pParse->db;
89994 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ALL,0));
90043 ** a join type, but put an error in the pParse structure.
90045 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
90090 sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "
90095 sqlite3ErrorMsg(pParse,
90159 Parse *pParse, /* Parsing context */
90168 sqlite3 *db = pParse->db;
90181 pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2, 0);
90242 static int sqliteProcessJoin(Parse *pParse, Select *p){
90264 sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
90275 addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j,
90284 sqlite3ErrorMsg(pParse, "cannot have both ON and USING "
90294 p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn);
90318 sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
90322 addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, iRightCol,
90335 Parse *pParse, /* Parser context */
90340 Vdbe *v = pParse->pVdbe;
90342 int regBase = sqlite3GetTempRange(pParse, nExpr+2);
90343 int regRecord = sqlite3GetTempReg(pParse);
90344 sqlite3ExprCacheClear(pParse);
90345 sqlite3ExprCodeExprList(pParse, pOrderBy, regBase, 0);
90347 sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+1, 1);
90350 sqlite3ReleaseTempReg(pParse, regRecord);
90351 sqlite3ReleaseTempRange(pParse, regBase, nExpr+2);
90398 Parse *pParse, /* Parsing and code generating context */
90407 v = pParse->pVdbe;
90408 r1 = sqlite3GetTempReg(pParse);
90412 sqlite3ReleaseTempReg(pParse, r1);
90424 Parse *pParse, /* Parse context. */
90430 sqlite3ErrorMsg(pParse, "only a single result allowed for "
90449 Parse *pParse, /* The parser context */
90460 Vdbe *v = pParse->pVdbe;
90484 pDest->iMem = pParse->nMem+1;
90486 pParse->nMem += nResultCol;
90499 sqlite3ExprCacheClear(pParse);
90500 sqlite3ExprCodeExprList(pParse, pEList, regResult, eDest==SRT_Output);
90511 codeDistinct(pParse, distinct, iContinue, nColumn, regResult);
90524 r1 = sqlite3GetTempReg(pParse);
90527 sqlite3ReleaseTempReg(pParse, r1);
90545 int r1 = sqlite3GetTempReg(pParse);
90550 pushOntoSorter(pParse, pOrderBy, p, r1);
90552 int r2 = sqlite3GetTempReg(pParse);
90556 sqlite3ReleaseTempReg(pParse, r2);
90558 sqlite3ReleaseTempReg(pParse, r1);
90575 pushOntoSorter(pParse, pOrderBy, p, regResult);
90577 int r1 = sqlite3GetTempReg(pParse);
90579 sqlite3ExprCacheAffinityChange(pParse, regResult, 1);
90581 sqlite3ReleaseTempReg(pParse, r1);
90601 pushOntoSorter(pParse, pOrderBy, p, regResult);
90603 sqlite3ExprCodeMove(pParse, regResult, iParm, 1);
90619 int r1 = sqlite3GetTempReg(pParse);
90621 pushOntoSorter(pParse, pOrderBy, p, r1);
90622 sqlite3ReleaseTempReg(pParse, r1);
90627 sqlite3ExprCacheAffinityChange(pParse, regResult, nColumn);
90669 static KeyInfo *keyInfoFromExprList(Parse *pParse, ExprList *pList){
90670 sqlite3 *db = pParse->db;
90685 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
90723 static void explainTempTable(Parse *pParse, const char *zUsage){
90724 if( pParse->explain==2 ){
90725 Vdbe *v = pParse->pVdbe;
90726 char *zMsg = sqlite3MPrintf(pParse->db, "USE TEMP B-TREE FOR %s", zUsage);
90727 sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
90762 Parse *pParse, /* Parse context */
90769 if( pParse->explain==2 ){
90770 Vdbe *v = pParse->pVdbe;
90772 pParse->db, "COMPOUND SUBQUERIES %d AND %d %s(%s)", iSub1, iSub2,
90775 sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
90790 Parse *pParse, /* Parsing context */
90810 regRow = sqlite3GetTempReg(pParse);
90812 pseudoTab = pParse->nTab++;
90816 regRowid = sqlite3GetTempReg(pParse);
90835 sqlite3ExprCacheAffinityChange(pParse, regRow, 1);
90841 sqlite3ExprCodeMove(pParse, regRow, iParm, 1);
90860 sqlite3ExprCacheAffinityChange(pParse, pDest->iMem, nColumn);
90867 sqlite3ReleaseTempReg(pParse, regRow);
90868 sqlite3ReleaseTempReg(pParse, regRowid);
90971 sNC.pParse = pNC->pParse;
90987 if( pNC->pParse ){
90988 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
90989 zOriginDb = pNC->pParse->db->aDb[iDb].zName;
91006 sNC.pParse = pNC->pParse;
91027 Parse *pParse, /* Parser context */
91032 Vdbe *v = pParse->pVdbe;
91036 sNC.pParse = pParse;
91067 Parse *pParse, /* Parser context */
91071 Vdbe *v = pParse->pVdbe;
91073 sqlite3 *db = pParse->db;
91078 if( pParse->explain ){
91083 if( pParse->colNamesSet || NEVER(v==0) || db->mallocFailed ) return;
91084 pParse->colNamesSet = 1;
91126 generateColumnTypes(pParse, pTabList, pEList);
91143 Parse *pParse, /* Parsing context */
91148 sqlite3 *db = pParse->db; /* Database connection */
91234 Parse *pParse, /* Parsing contexts */
91239 sqlite3 *db = pParse->db;
91259 pColl = sqlite3ExprCollSeq(pParse, p);
91270 SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect){
91272 sqlite3 *db = pParse->db;
91278 sqlite3SelectPrep(pParse, pSelect, 0);
91279 if( pParse->nErr ) return 0;
91292 selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
91293 selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSelect);
91304 ** If an error occurs, return NULL and leave a message in pParse.
91306 SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse *pParse){
91307 Vdbe *v = pParse->pVdbe;
91309 v = pParse->pVdbe = sqlite3VdbeCreate(pParse->db);
91338 static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
91351 sqlite3ExprCacheClear(pParse);
91354 p->iLimit = iLimit = ++pParse->nMem;
91355 v = sqlite3GetVdbe(pParse);
91366 sqlite3ExprCode(pParse, p->pLimit, iLimit);
91372 p->iOffset = iOffset = ++pParse->nMem;
91373 pParse->nMem++; /* Allocate an extra register for limit+offset */
91374 sqlite3ExprCode(pParse, p->pOffset, iOffset);
91398 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
91401 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
91407 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
91415 Parse *pParse, /* Parsing context */
91454 Parse *pParse, /* Parsing context */
91473 db = pParse->db;
91479 sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
91485 sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
91491 v = sqlite3GetVdbe(pParse);
91508 sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
91517 return multiSelectOrderBy(pParse, p, pDest);
91529 explainSetInteger(iSub1, pParse->iNextSelectId);
91530 rc = sqlite3Select(pParse, pPrior, &dest);
91543 explainSetInteger(iSub2, pParse->iNextSelectId);
91544 rc = sqlite3Select(pParse, p, &dest);
91585 unionTab = pParse->nTab++;
91598 explainSetInteger(iSub1, pParse->iNextSelectId);
91599 rc = sqlite3Select(pParse, pPrior, &uniondest);
91618 explainSetInteger(iSub2, pParse->iNextSelectId);
91619 rc = sqlite3Select(pParse, p, &uniondest);
91644 generateColumnNames(pParse, 0, pFirst->pEList);
91648 computeLimitRegisters(pParse, p, iBreak);
91651 selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr,
91672 tab1 = pParse->nTab++;
91673 tab2 = pParse->nTab++;
91685 explainSetInteger(iSub1, pParse->iNextSelectId);
91686 rc = sqlite3Select(pParse, pPrior, &intersectdest);
91702 explainSetInteger(iSub2, pParse->iNextSelectId);
91703 rc = sqlite3Select(pParse, p, &intersectdest);
91719 generateColumnNames(pParse, 0, pFirst->pEList);
91723 computeLimitRegisters(pParse, p, iBreak);
91725 r1 = sqlite3GetTempReg(pParse);
91728 sqlite3ReleaseTempReg(pParse, r1);
91729 selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr,
91740 explainComposite(pParse, p->op, iSub1, iSub2, p->op!=TK_ALL);
91771 *apColl = multiSelectCollSeq(pParse, p, i);
91823 Parse *pParse, /* Parsing context */
91833 Vdbe *v = pParse->pVdbe;
91849 sqlite3ExprCodeCopy(pParse, pIn->iMem, regPrev+1, pIn->nMem);
91852 if( pParse->db->mallocFailed ) return 0;
91863 int r1 = sqlite3GetTempReg(pParse);
91864 int r2 = sqlite3GetTempReg(pParse);
91871 sqlite3ReleaseTempReg(pParse, r2);
91872 sqlite3ReleaseTempReg(pParse, r1);
91886 r1 = sqlite3GetTempReg(pParse);
91888 sqlite3ExprCacheAffinityChange(pParse, pIn->iMem, 1);
91890 sqlite3ReleaseTempReg(pParse, r1);
91910 sqlite3ExprCodeMove(pParse, pIn->iMem, pDest->iParm, 1);
91921 pDest->iMem = sqlite3GetTempRange(pParse, pIn->nMem);
91924 sqlite3ExprCodeMove(pParse, pIn->iMem, pDest->iMem, pDest->nMem);
91940 sqlite3ExprCacheAffinityChange(pParse, pIn->iMem, pIn->nMem);
92046 Parse *pParse, /* Parsing context */
92092 db = pParse->db;
92093 v = pParse->pVdbe;
92124 pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
92156 pColl = multiSelectCollSeq(pParse, p, aPermute[i]);
92171 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
92182 regPrev = sqlite3GetTempRange(pParse, nExpr+1);
92191 pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
92200 sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
92202 sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
92206 computeLimitRegisters(pParse, p, labelEnd);
92208 regLimitA = ++pParse->nMem;
92209 regLimitB = ++pParse->nMem;
92221 regAddrA = ++pParse->nMem;
92222 regEofA = ++pParse->nMem;
92223 regAddrB = ++pParse->nMem;
92224 regEofB = ++pParse->nMem;
92225 regOutA = ++pParse->nMem;
92226 regOutB = ++pParse->nMem;
92242 explainSetInteger(iSub1, pParse->iNextSelectId);
92243 sqlite3Select(pParse, pPrior, &destA);
92257 explainSetInteger(iSub2, pParse->iNextSelectId);
92258 sqlite3Select(pParse, p, &destB);
92269 addrOutA = generateOutputSubroutine(pParse,
92278 addrOutB = generateOutputSubroutine(pParse,
92366 sqlite3ReleaseTempRange(pParse, regPrev, nOrderBy+1);
92378 generateColumnNames(pParse, 0, pFirst->pEList);
92390 explainComposite(pParse, p->op, iSub1, iSub2, 0);
92595 Parse *pParse, /* Parsing context */
92601 const char *zSavedAuthContext = pParse->zAuthContext;
92612 sqlite3 *db = pParse->db;
92727 pParse->zAuthContext = pSubitem->zName;
92728 sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0);
92729 pParse->zAuthContext = zSavedAuthContext;
92815 Parse *pToplevel = sqlite3ParseToplevel(pParse);
93035 ** SQLITE_ERROR and leave an error in pParse. Otherwise, populate
93038 SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){
93048 sqlite3ErrorMsg(pParse, "no such index: %s", zIndex, 0);
93049 pParse->checkSchema = 1;
93082 Parse *pParse = pWalker->pParse;
93087 sqlite3 *db = pParse->db;
93102 sqlite3SrcListAssignCursors(pParse, pTabList);
93128 selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
93137 sqlite3LocateTable(pParse,0,pFrom->zName,pFrom->zDatabase);
93143 if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
93152 if( sqlite3IndexedByLookup(pParse, pFrom) ){
93159 if( db->mallocFailed || sqliteProcessJoin(pParse, p) ){
93188 int flags = pParse->db->flags;
93198 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
93265 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
93273 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
93276 sqlite3ExprListSetName(pParse, pNew, &sColname, 0);
93282 sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
93284 sqlite3ErrorMsg(pParse, "no tables specified");
93294 sqlite3ErrorMsg(pParse, "too many columns in result set");
93323 ** If anything goes wrong, an error message is written into pParse.
93324 ** The calling function can detect the problem by looking at pParse->nErr
93325 ** and/or pParse->db->mallocFailed.
93327 static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){
93331 w.pParse = pParse;
93351 Parse *pParse;
93359 pParse = pWalker->pParse;
93368 selectAddColumnTypeAndCollation(pParse, pTab->nCol, pTab->aCol, pSel);
93384 static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){
93389 w.pParse = pParse;
93408 Parse *pParse, /* The parser context */
93414 db = pParse->db;
93416 sqlite3SelectExpand(pParse, p);
93417 if( pParse->nErr || db->mallocFailed ) return;
93418 sqlite3ResolveSelectNames(pParse, p, pOuterNC);
93419 if( pParse->nErr || db->mallocFailed ) return;
93420 sqlite3SelectAddTypeInfo(pParse, p);
93430 static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
93431 Vdbe *v = pParse->pVdbe;
93446 sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
93450 KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->x.pList);
93462 static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
93463 Vdbe *v = pParse->pVdbe;
93478 static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){
93479 Vdbe *v = pParse->pVdbe;
93485 sqlite3ExprCacheClear(pParse);
93494 regAgg = sqlite3GetTempRange(pParse, nArg);
93495 sqlite3ExprCodeExprList(pParse, pList, regAgg, 1);
93503 codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg);
93511 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
93514 pColl = pParse->db->pDfltColl;
93521 sqlite3ExprCacheAffinityChange(pParse, regAgg, nArg);
93522 sqlite3ReleaseTempRange(pParse, regAgg, nArg);
93525 sqlite3ExprCacheClear(pParse);
93539 sqlite3ExprCacheClear(pParse);
93541 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
93544 sqlite3ExprCacheClear(pParse);
93553 Parse *pParse, /* Parse context */
93557 if( pParse->explain==2 ){
93558 char *zEqp = sqlite3MPrintf(pParse->db, "SCAN TABLE %s %s%s(~%d rows)",
93565 pParse->pVdbe, OP_Explain, pParse->iSelectId, 0, 0, zEqp, P4_DYNAMIC
93622 ** pParse->zErrMsg.
93628 Parse *pParse, /* The parser context */
93651 int iRestoreSelectId = pParse->iSelectId;
93652 pParse->iSelectId = pParse->iNextSelectId++;
93655 db = pParse->db;
93656 if( p==0 || db->mallocFailed || pParse->nErr ){
93659 if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
93671 sqlite3SelectPrep(pParse, p, 0);
93675 if( pParse->nErr || db->mallocFailed ){
93683 v = sqlite3GetVdbe(pParse);
93690 if( checkForMultiColumnSelectError(pParse, pDest, pEList->nExpr) ){
93713 pParse->nHeight += sqlite3SelectExprHeight(p);
93717 if( flattenSubquery(pParse, p, i, isAgg, isAggSub) ){
93726 explainSetInteger(pItem->iSelectId, (u8)pParse->iNextSelectId);
93727 sqlite3Select(pParse, pSub, &dest);
93731 if( /*pParse->nErr ||*/ db->mallocFailed ){
93734 pParse->nHeight -= sqlite3SelectExprHeight(p);
93762 sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
93766 rc = multiSelect(pParse, p, pDest);
93767 explainSetInteger(pParse->iSelectId, iRestoreSelectId);
93803 pKeyInfo = keyInfoFromExprList(pParse, pOrderBy);
93804 pOrderBy->iECursor = pParse->nTab++;
93823 computeLimitRegisters(pParse, p, iEnd);
93830 distinct = pParse->nTab++;
93831 pKeyInfo = keyInfoFromExprList(pParse, p->pEList);
93844 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pOrderBy, 0);
93860 selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, -1, pDest,
93905 sNC.pParse = pParse;
93941 sAggInfo.sortingIdx = pParse->nTab++;
93942 pKeyInfo = keyInfoFromExprList(pParse, pGroupBy);
93949 iUseFlag = ++pParse->nMem;
93950 iAbortFlag = ++pParse->nMem;
93951 regOutputRow = ++pParse->nMem;
93953 regReset = ++pParse->nMem;
93955 iAMem = pParse->nMem + 1;
93956 pParse->nMem += pGroupBy->nExpr;
93957 iBMem = pParse->nMem + 1;
93958 pParse->nMem += pGroupBy->nExpr;
93970 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pGroupBy, 0);
93990 explainTempTable(pParse,
94003 regBase = sqlite3GetTempRange(pParse, nCol);
94004 sqlite3ExprCacheClear(pParse);
94005 sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0);
94014 r2 = sqlite3ExprCodeGetColumn(pParse,
94022 regRecord = sqlite3GetTempReg(pParse);
94025 sqlite3ReleaseTempReg(pParse, regRecord);
94026 sqlite3ReleaseTempRange(pParse, regBase, nCol);
94031 sqlite3ExprCacheClear(pParse);
94040 sqlite3ExprCacheClear(pParse);
94046 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
94063 sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
94075 updateAccumulator(pParse, &sAggInfo);
94113 finalizeAggFunctions(pParse, &sAggInfo);
94114 sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL);
94115 selectInnerLoop(pParse
94124 resetAccumulator(pParse, &sAggInfo);
94146 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
94147 const int iCsr = pParse->nTab++; /* Cursor to scan b-tree */
94153 sqlite3CodeVerifySchema(pParse, iDb);
94154 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
94174 pKeyInfo = sqlite3IndexKeyinfo(pParse, pBest);
94184 explainSimpleCount(pParse, pTab, pBest);
94229 resetAccumulator(pParse, &sAggInfo);
94230 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pMinMax, flag);
94235 updateAccumulator(pParse, &sAggInfo);
94242 finalizeAggFunctions(pParse, &sAggInfo);
94246 sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
94247 selectInnerLoop(pParse, p, p->pEList, 0, 0, 0, -1,
94256 explainTempTable(pParse, "DISTINCT");
94263 explainTempTable(pParse, "ORDER BY");
94264 generateSortTail(pParse, p, v, pEList->nExpr, pDest);
94280 explainSetInteger(pParse->iSelectId, iRestoreSelectId);
94285 generateColumnNames(pParse, pTabList, pEList);
94633 SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
94634 Schema * const pTmpSchema = pParse->db->aDb[1].pSchema;
94637 if( pParse->disableTriggers ){
94643 assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) );
94662 ** in pParse->pNewTrigger. After the trigger actions have been parsed, the
94667 Parse *pParse, /* The parse context of the CREATE TRIGGER statement */
94681 sqlite3 *db = pParse->db; /* The database connection */
94694 sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name");
94701 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
94715 pTab = sqlite3SrcListLookup(pParse, pTableName);
94724 if( sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName) &&
94728 pTab = sqlite3SrcListLookup(pParse, pTableName);
94745 sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables");
94752 if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
94759 sqlite3ErrorMsg(pParse, "trigger %T already exists", pName);
94762 sqlite3CodeVerifySchema(pParse, iDb);
94769 sqlite3ErrorMsg(pParse, "cannot create trigger on system table");
94770 pParse->nErr++;
94778 sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S",
94783 sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF"
94795 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
94798 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){
94825 assert( pParse->pNewTrigger==0 );
94826 pParse->pNewTrigger = pTrigger;
94833 if( !pParse->pNewTrigger ){
94836 assert( pParse->pNewTrigger==pTrigger );
94845 Parse *pParse, /* Parser context */
94849 Trigger *pTrig = pParse->pNewTrigger; /* Trigger being finished */
94851 sqlite3 *db = pParse->db; /* The database */
94856 pParse->pNewTrigger = 0;
94857 if( NEVER(pParse->nErr) || !pTrig ) goto triggerfinish_cleanup;
94859 iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
94867 if( sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken)
94880 v = sqlite3GetVdbe(pParse);
94882 sqlite3BeginWriteOperation(pParse, 0, iDb);
94884 sqlite3NestedParse(pParse,
94889 sqlite3ChangeCookie(pParse, iDb);
94914 assert( !pParse->pNewTrigger );
95063 SQLITE_PRIVATE void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){
95069 sqlite3 *db = pParse->db;
95072 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
95090 sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0);
95092 sqlite3CodeVerifyNamedSchema(pParse, zDb);
95094 pParse->checkSchema = 1;
95097 sqlite3DropTriggerPtr(pParse, pTrigger);
95116 SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){
95119 sqlite3 *db = pParse->db;
95122 iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
95133 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
95134 sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
95143 if( (v = sqlite3GetVdbe(pParse))!=0 ){
95157 sqlite3BeginWriteOperation(pParse, 0, iDb);
95158 sqlite3OpenMasterTable(pParse, iDb);
95162 sqlite3ChangeCookie(pParse, iDb);
95165 if( pParse->nMem<3 ){
95166 pParse->nMem = 3;
95218 Parse *pParse, /* Parse context */
95228 if( (pParse->db->flags & SQLITE_EnableTrigger)!=0 ){
95229 pList = sqlite3TriggerList(pParse, pTab);
95254 Parse *pParse, /* The parsing context */
95260 pSrc = sqlite3SrcListAppend(pParse->db, 0, &pStep->target, 0);
95264 iDb = sqlite3SchemaToIndex(pParse->db, pStep->pTrig->pSchema);
95266 sqlite3 *db = pParse->db;
95267 assert( iDb<pParse->db->nDb );
95279 Parse *pParse, /* The parser context */
95284 Vdbe *v = pParse->pVdbe;
95285 sqlite3 *db = pParse->db;
95287 assert( pParse->pTriggerTab && pParse->pToplevel );
95304 pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf;
95308 sqlite3Update(pParse,
95309 targetSrcList(pParse, pStep),
95312 pParse->eOrconf
95317 sqlite3Insert(pParse,
95318 targetSrcList(pParse, pStep),
95322 pParse->eOrconf
95327 sqlite3DeleteFrom(pParse,
95328 targetSrcList(pParse, pStep),
95337 sqlite3Select(pParse, pSelect, &sDest);
95389 Parse *pParse, /* Current parse context */
95394 Parse *pTop = sqlite3ParseToplevel(pParse);
95395 sqlite3 *db = pParse->db; /* Database handle */
95427 sNC.pParse = pSubParse;
95433 pSubParse->nQueryLoop = pParse->nQueryLoop;
95475 transferParseError(pParse, pSubParse);
95501 Parse *pParse, /* Current parse context */
95506 Parse *pRoot = sqlite3ParseToplevel(pParse);
95522 pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf);
95535 Parse *pParse, /* Parse context */
95542 Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */
95544 pPrg = getRowTrigger(pParse, p, pTab, orconf);
95545 assert( pPrg || pParse->nErr || pParse->db->mallocFailed );
95550 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
95552 sqlite3VdbeAddOp3(v, OP_Program, reg, ignoreJump, ++pParse->nMem);
95607 Parse *pParse, /* Parse context */
95631 || p->pSchema==pParse->db->aDb[1].pSchema );
95638 sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
95669 Parse *pParse, /* Parse context */
95687 pPrg = getRowTrigger(pParse, p, pTab, orconf);
95719 Parse *pParse, /* The parsing context */
95788 Parse *pParse, /* The parser context */
95832 db = pParse->db;
95833 if( pParse->nErr || db->mallocFailed ){
95840 pTab = sqlite3SrcListLookup(pParse, pTabList);
95842 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
95848 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
95861 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
95864 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
95876 pTabList->a[0].iCursor = iCur = pParse->nTab++;
95878 pParse->nTab++;
95883 sNC.pParse = pParse;
95912 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
95913 pParse->checkSchema = 1;
95920 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
95931 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngRowid);
95946 reg = ++pParse->nMem;
95951 reg = ++pParse->nMem;
95960 v = sqlite3GetVdbe(pParse);
95962 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
95963 sqlite3BeginWriteOperation(pParse, 1, iDb);
95968 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
95977 regOldRowid = regNewRowid = ++pParse->nMem;
95979 regOld = pParse->nMem + 1;
95980 pParse->nMem += pTab->nCol;
95983 regNewRowid = ++pParse->nMem;
95985 regNew = pParse->nMem + 1;
95986 pParse->nMem += pTab->nCol;
95990 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
95998 sqlite3MaterializeView(pParse, pTab, pWhere, iCur);
96012 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere,0, WHERE_ONEPASS_DESIRED);
96020 regRowSet = ++pParse->nMem;
96030 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){
96031 regRowCount = ++pParse->nMem;
96042 if( !okOnePass ) sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
96056 KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
96059 assert( pParse->nTab>iCur+i+1 );
96084 sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
96091 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
96092 oldmask |= sqlite3TriggerColmask(pParse,
96121 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
96129 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i);
96150 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
96178 sqlite3GenerateConstraintChecks(pParse, pTab, iCur, regNewRowid,
96183 sqlite3FkCheck(pParse, pTab, regOldRowid, 0);
96188 sqlite3GenerateRowIndexDelete(pParse, pTab, iCur, aRegIdx);
96197 sqlite3FkCheck(pParse, pTab, 0, regNewRowid);
96201 sqlite3CompleteInsertion(pParse, pTab, iCur, regNewRowid, aRegIdx, 1, 0, 0);
96207 sqlite3FkActions(pParse, pTab, pChanges, regOldRowid);
96213 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){
96217 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
96238 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
96239 sqlite3AutoincrementEnd(pParse);
96247 if( (db->flags&SQLITE_CountRows) && !pParse->pTriggerTab && !pParse->nested ){
96293 Parse *pParse, /* The parsing context */
96301 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
96309 sqlite3 *db = pParse->db; /* Database connection */
96316 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, "_rowid_"));
96318 pEList = sqlite3ExprListAppend(pParse, pEList,
96328 pEList = sqlite3ExprListAppend(pParse, pEList, pExpr);
96330 pSelect = sqlite3SelectNew(pParse, pEList, pSrc, pWhere, 0, 0, 0, 0, 0, 0);
96336 ephemTab = pParse->nTab++;
96343 sqlite3Select(pParse, pSelect, &dest);
96346 iReg = ++pParse->nMem;
96347 pParse->nMem += pTab->nCol+1;
96354 sqlite3VtabMakeWritable(pParse, pTab);
96356 sqlite3MayAbort(pParse);
96449 SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse){
96450 Vdbe *v = sqlite3GetVdbe(pParse);
96978 Parse *pParse, /* Parsing context */
96987 sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, 0);
96988 pTable = pParse->pNewTable;
96992 db = pParse->db;
97001 pParse->sNameToken.n = (int)(&pModuleName->z[pModuleName->n] - pName1->z);
97010 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
97011 pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
97018 ** in pParse->zArg[] and appends it to the list of arguments on the
97019 ** virtual table currently under construction in pParse->pTable.
97021 static void addArgumentToVtab(Parse *pParse){
97022 if( pParse->sArg.z && ALWAYS(pParse->pNewTable) ){
97023 const char *z = (const char*)pParse->sArg.z;
97024 int n = pParse->sArg.n;
97025 sqlite3 *db = pParse->db;
97026 addModuleArgument(db, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));
97034 SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
97035 Table *pTab = pParse->pNewTable; /* The table being constructed */
97036 sqlite3 *db = pParse->db; /* The database connection */
97039 addArgumentToVtab(pParse);
97040 pParse->sArg.z = 0;
97057 pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n;
97059 zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
97065 ** The VM register number pParse->regRowid holds the rowid of an
97070 sqlite3NestedParse(pParse,
97078 pParse->regRowid
97081 v = sqlite3GetVdbe(pParse);
97082 sqlite3ChangeCookie(pParse, iDb);
97108 pParse->pNewTable = 0;
97116 SQLITE_PRIVATE void sqlite3VtabArgInit(Parse *pParse){
97117 addArgumentToVtab(pParse);
97118 pParse->sArg.z = 0;
97119 pParse->sArg.n = 0;
97126 SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse *pParse, Token *p){
97127 Token *pArg = &pParse->sArg;
97244 ** and an error left in pParse.
97248 SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
97249 sqlite3 *db = pParse->db;
97265 sqlite3ErrorMsg(pParse, "no such module: %s", zModule);
97271 sqlite3ErrorMsg(pParse, "%s", zErr);
97350 Parse *pParse;
97365 pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
97366 if( pParse
97369 pParse->declareVtab = 1;
97370 pParse->db = db;
97371 pParse->nQueryLoop = 1;
97373 if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr)
97374 && pParse->pNewTable
97376 && !pParse->pNewTable->pSelect
97377 && (pParse->pNewTable->tabFlags & TF_Virtual)==0
97380 pTab->aCol = pParse->pNewTable->aCol;
97381 pTab->nCol = pParse->pNewTable->nCol;
97382 pParse->pNewTable->nCol = 0;
97383 pParse->pNewTable->aCol = 0;
97391 pParse->declareVtab = 0;
97393 if( pParse->pVdbe ){
97394 sqlite3VdbeFinalize(pParse->pVdbe);
97396 sqlite3DeleteTable(db, pParse->pNewTable);
97397 sqlite3StackFree(db, pParse);
97628 ** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]
97633 SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
97634 Parse *pToplevel = sqlite3ParseToplevel(pParse);
97786 Parse *pParse; /* The parser context */
97916 Parse *pParse, /* The parsing context */
97919 pWC->pParse = pParse;
97953 sqlite3 *db = pWC->pParse->db;
97994 sqlite3 *db = pWC->pParse->db;
98170 static void exprCommute(Parse *pParse, Expr *pExpr){
98174 pExpr->pRight->pColl = sqlite3ExprCollSeq(pParse, pExpr->pRight);
98175 pExpr->pLeft->pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
98243 Parse *pParse = pWC->pParse;
98253 pColl = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight);
98254 assert(pColl || pParse->nErr);
98295 Parse *pParse, /* Parsing and code generating context */
98307 sqlite3 *db = pParse->db; /* Database connection */
98332 Vdbe *pReprepare = pParse->pReprepare;
98338 sqlite3VdbeSetVarmask(pParse->pVdbe, iCol); /* IMP: R-23257-02778 */
98355 Vdbe *v = pParse->pVdbe;
98364 int r1 = sqlite3GetTempReg(pParse);
98365 sqlite3ExprCodeTarget(pParse, pRight, r1);
98367 sqlite3ReleaseTempReg(pParse, r1);
98502 Parse *pParse = pWC->pParse; /* Parser context */
98503 sqlite3 *db = pParse->db; /* Database connection */
98525 whereClauseInit(pOrWc, pWC->pParse, pMaskSet);
98552 whereClauseInit(pAndWC, pWC->pParse, pMaskSet);
98704 pList = sqlite3ExprListAppend(pWC->pParse, pList, pDup);
98709 pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0, 0);
98764 Parse *pParse = pWC->pParse; /* Parsing context */
98765 sqlite3 *db = pParse->db; /* Database connection */
98827 exprCommute(pParse, pDup);
98863 pNewExpr = sqlite3PExpr(pParse, ops[i],
98899 && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
98930 pNewExpr1 = sqlite3PExpr(pParse, TK_GE,
98936 pNewExpr2 = sqlite3PExpr(pParse, TK_LT,
98970 pNewExpr = sqlite3PExpr(pParse, TK_MATCH,
99008 pNewExpr = sqlite3PExpr(pParse, TK_GT,
99010 sqlite3PExpr(pParse, TK_NULL, 0, 0, 0), 0);
99075 Parse *pParse, /* Parsing context */
99088 sqlite3 *db = pParse->db;
99121 pColl = sqlite3ExprCollSeq(pParse, pExpr);
99276 Parse *pParse, /* The parsing context */
99317 bestIndex(pParse, pAndWC, pSrc, notReady, notValid, 0, &sTermCost);
99320 tempWC.pParse = pWC->pParse;
99325 bestIndex(pParse, &tempWC, pSrc, notReady, notValid, 0, &sTermCost);
99390 Parse *pParse, /* The parsing context */
99403 if( (pParse->db->flags & SQLITE_AutoIndex)==0 ){
99416 assert( pParse->nQueryLoop >= (double)1 );
99420 costTempIdx = 2*logN*(nTableRow/pParse->nQueryLoop + 1);
99453 Parse *pParse, /* The parsing context */
99480 v = pParse->pVdbe;
99482 regIsInit = ++pParse->nMem;
99532 pIdx = sqlite3DbMallocZero(pParse->db, nByte);
99551 pColl = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight);
99578 pKeyinfo = sqlite3IndexKeyinfo(pParse, pIdx);
99586 regRecord = sqlite3GetTempReg(pParse);
99587 sqlite3GenerateIndexKey(pParse, pIdx, pLevel->iTabCur, regRecord, 1);
99593 sqlite3ReleaseTempReg(pParse, regRecord);
99607 Parse *pParse,
99651 pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo)
99655 sqlite3ErrorMsg(pParse, "out of memory");
99711 ** If an error occurs, pParse is populated with an error message and a
99719 static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
99720 sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
99731 pParse->db->mallocFailed = 1;
99733 sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc));
99735 sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg);
99743 sqlite3ErrorMsg(pParse,
99748 return pParse->nErr;
99769 Parse *pParse, /* The parsing context */
99799 *ppIdxInfo = pIdxInfo = allocateIndexInfo(pParse, pWC, pSrc, pOrderBy);
99817 assert( sqlite3GetVTable(pParse->db, pTab) );
99861 if( vtabBestIndex(pParse, pTab, pIdxInfo) ){
99903 bestOrClauseIndex(pParse, pWC, pSrc, notReady, notValid, pOrderBy, pCost);
99931 Parse *pParse, /* Database connection */
99960 sqlite3 *db = pParse->db;
99975 sqlite3ErrorMsg(pParse, "no such collation sequence: %s",
100038 Parse *pParse,
100047 sqlite3VdbeSetVarmask(pParse->pVdbe, iVar); /* IMP: R-23257-02778 */
100048 *pp = sqlite3VdbeGetValue(pParse->pReprepare, iVar, aff);
100051 return sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, aff, pp);
100097 Parse *pParse, /* Parsing & code generating context */
100120 rc = valueFromExpr(pParse, pExpr, aff, &pLowerVal);
100126 rc = valueFromExpr(pParse, pExpr, aff, &pUpperVal);
100136 rc = whereRangeRegion(pParse, p, pUpperVal, roundUpUpper, &iUpper);
100139 rc = whereRangeRegion(pParse, p, pLowerVal, roundUpLower, &iLower);
100142 rc = whereRangeRegion(pParse, p, pUpperVal, roundUpUpper, &iUpper);
100144 rc = whereRangeRegion(pParse, p, pLowerVal, roundUpLower, &iLower);
100163 UNUSED_PARAMETER(pParse);
100190 ** in the pParse structure.
100193 Parse *pParse, /* Parsing & code generating context */
100207 rc = valueFromExpr(pParse, pExpr, aff, &pRhs);
100210 pRhs = sqlite3ValueNew(pParse->db);
100213 rc = whereRangeRegion(pParse, p, pRhs, 0, &iLower);
100215 rc = whereRangeRegion(pParse, p, pRhs, 1, &iUpper);
100247 ** in the pParse structure.
100250 Parse *pParse, /* Parsing & code generating context */
100273 rc = valueFromExpr(pParse, pList->a[i].pExpr, aff, &pVal);
100279 rc = whereRangeRegion(pParse, p, pVal, 0, &iLower);
100281 rc = whereRangeRegion(pParse, p, pVal, 1, &iUpper);
100340 Parse *pParse, /* The parsing context */
100525 whereRangeScanEst(pParse, pProbe, nEq, pBtm, pTop, &estBound);
100553 && isSortingIndex(pParse, pWC->pMaskSet, pProbe, iCur, pOrderBy,
100604 whereEqualScanEst(pParse, pProbe, pFirstTerm->pExpr->pRight, &nRow);
100606 whereInScanEst(pParse, pProbe, pFirstTerm->pExpr->x.pList, &nRow);
100775 if( !pOrderBy && pParse->db->flags & SQLITE_ReverseOrder ){
100791 bestOrClauseIndex(pParse, pWC, pSrc, notReady, notValid, pOrderBy, pCost);
100792 bestAutomaticIndex(pParse, pWC, pSrc, notReady, pCost);
100803 Parse *pParse, /* The parsing context */
100814 bestVirtualIndex(pParse, pWC, pSrc, notReady, notValid, pOrderBy, pCost,&p);
100818 sqlite3DbFree(pParse->db, p);
100822 bestBtreeIndex(pParse, pWC, pSrc, notReady, notValid, pOrderBy, pCost);
100878 static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){
100879 Vdbe *v = pParse->pVdbe;
100881 assert( pParse->db->mallocFailed );
100902 sqlite3ExprCacheAffinityChange(pParse, base, n);
100919 Parse *pParse, /* The parsing context */
100925 Vdbe *v = pParse->pVdbe;
100930 iReg = sqlite3ExprCodeTarget(pParse, pX->pRight, iTarget);
100942 eType = sqlite3FindInIndex(pParse, pX, 0);
100951 sqlite3DbReallocOrFree(pParse->db, pLevel->u.in.aInLoop,
101012 Parse *pParse, /* Parsing context */
101020 Vdbe *v = pParse->pVdbe; /* The vm under construction */
101035 regBase = pParse->nMem + 1;
101037 pParse->nMem += nReg;
101039 zAff = sqlite3DbStrDup(pParse->db, sqlite3IndexAffinityStr(v, pIdx));
101041 pParse->db->mallocFailed = 1;
101056 r1 = codeEqualityTerm(pParse, pTerm, pLevel, regBase+j);
101059 sqlite3ReleaseTempReg(pParse, regBase);
101161 Parse *pParse, /* Parse context */
101168 if( pParse->explain==2 ){
101171 Vdbe *v = pParse->pVdbe; /* VM being constructed */
101172 sqlite3 *db = pParse->db; /* Database handle */
101175 int iId = pParse->iSelectId; /* Select id (left-most output column) */
101257 Parse *pParse; /* Parsing context */
101265 pParse = pWInfo->pParse;
101266 v = pParse->pVdbe;
101293 pLevel->iLeftJoin = ++pParse->nMem;
101311 sqlite3ExprCachePush(pParse);
101312 iReg = sqlite3GetTempRange(pParse, nConstraint+2);
101317 sqlite3ExprCode(pParse, pWC->a[iTerm].pExpr->pRight, iReg+j+1);
101337 sqlite3ReleaseTempRange(pParse, iReg, nConstraint+2);
101338 sqlite3ExprCachePop(pParse, 1);
101348 iReleaseReg = sqlite3GetTempReg(pParse);
101355 iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, iReleaseReg);
101359 sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
101399 r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &rTemp);
101402 sqlite3ExprCacheAffinityChange(pParse, r1, 1);
101403 sqlite3ReleaseTempReg(pParse, rTemp);
101414 memEndValue = ++pParse->nMem;
101415 sqlite3ExprCode(pParse, pX->pRight, memEndValue);
101433 iRowidReg = iReleaseReg = sqlite3GetTempReg(pParse);
101435 sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
101542 pParse, pLevel, pWC, notReady, nExtraReg, &zStartAff
101544 zEndAff = sqlite3DbStrDup(pParse->db, zStartAff);
101567 sqlite3ExprCode(pParse, pRight, regBase+nEq);
101590 codeApplyAffinity(pParse, regBase, nConstraint, zStartAff);
101607 sqlite3ExprCacheRemove(pParse, regBase+nEq, 1);
101608 sqlite3ExprCode(pParse, pRight, regBase+nEq);
101623 codeApplyAffinity(pParse, regBase, nEq+1, zEndAff);
101627 sqlite3DbFree(pParse->db, zStartAff);
101628 sqlite3DbFree(pParse->db, zEndAff);
101647 r1 = sqlite3GetTempReg(pParse);
101654 sqlite3ReleaseTempReg(pParse, r1);
101660 iRowidReg = iReleaseReg = sqlite3GetTempReg(pParse);
101662 sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
101723 int regReturn = ++pParse->nMem; /* Register used with OP_Gosub */
101747 pOrTab = sqlite3StackAllocRaw(pParse->db,
101773 regRowset = ++pParse->nMem;
101774 regRowid = ++pParse->nMem;
101784 pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrTerm->pExpr, 0,
101789 pParse, pOrTab, &pSubWInfo->a[0], iLevel, pLevel->iFrom, 0
101794 r = sqlite3ExprCodeGetColumn(pParse, pTabItem->pTab, -1, iCur,
101817 if( pWInfo->nLevel>1 ) sqlite3StackFree(pParse->db, pOrTab);
101860 sqlite3ExprIfFalse(pParse, pE, addrCont, SQLITE_JUMPIFNULL);
101871 sqlite3ExprCacheClear(pParse);
101881 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
101885 sqlite3ReleaseTempReg(pParse, iReleaseReg);
102021 Parse *pParse, /* The parser context */
102031 Vdbe *v = pParse->pVdbe; /* The virtual database engine */
102046 sqlite3ErrorMsg(pParse, "at most %d tables in a join", BMS);
102064 db = pParse->db;
102077 pWInfo->pParse = pParse;
102082 pWInfo->savedNQueryLoop = pParse->nQueryLoop;
102089 whereClauseInit(pWC, pParse, pMaskSet);
102090 sqlite3ExprCodeConstants(pParse, pWhere);
102097 sqlite3ExprIfFalse(pParse, pWhere, pWInfo->iBreak, SQLITE_JUMPIFNULL);
102253 bestVirtualIndex(pParse, pWC, pTabItem, mask, notReady, pOrderBy,
102258 bestBtreeIndex(pParse, pWC, pTabItem, mask, notReady, pOrderBy,
102325 pLevel->iIdxCur = pParse->nTab++;
102332 pParse->nQueryLoop *= bestPlan.plan.nRow;
102343 sqlite3ErrorMsg(pParse, "cannot use index: %s", pIdx->zName);
102354 if( pParse->nErr || db->mallocFailed ){
102379 sqlite3CodeVerifySchema(pParse, -1); /* Insert the cookie verifier Goto */
102404 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
102416 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
102420 constructAutomaticIndex(pParse, pWC, pTabItem, notReady, pLevel);
102425 KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIx);
102433 sqlite3CodeVerifySchema(pParse, iDb);
102446 explainOneScan(pParse, pTabList, pLevel, i, pLevel->iFrom, wctrlFlags);
102508 pParse->nQueryLoop = pWInfo->savedNQueryLoop;
102519 Parse *pParse = pWInfo->pParse;
102520 Vdbe *v = pParse->pVdbe;
102524 sqlite3 *db = pParse->db;
102528 sqlite3ExprCacheClear(pParse);
102636 pParse->nQueryLoop = pWInfo->savedNQueryLoop;
102715 static void spanExpr(ExprSpan *pOut, Parse *pParse, int op, Token *pValue){
102716 pOut->pExpr = sqlite3PExpr(pParse, op, 0, 0, pValue);
102726 Parse *pParse, /* The parsing context. Errors accumulate here */
102731 pOut->pExpr = sqlite3PExpr(pParse, op, pLeft->pExpr, pRight->pExpr, 0);
102740 Parse *pParse, /* Parsing context to record errors */
102745 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
102752 static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
102753 sqlite3 *db = pParse->db;
102765 Parse *pParse, /* Parsing context to record errors */
102770 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
102848 #define sqlite3ParserARG_SDECL Parse *pParse;
102849 #define sqlite3ParserARG_PDECL ,Parse *pParse
102850 #define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse
102851 #define sqlite3ParserARG_STORE yypParser->pParse = pParse
104028 sqlite3SelectDelete(pParse->db, (yypminor->yy387));
104034 sqlite3ExprDelete(pParse->db, (yypminor->yy118).pExpr);
104050 sqlite3ExprListDelete(pParse->db, (yypminor->yy322));
104058 sqlite3SrcListDelete(pParse->db, (yypminor->yy259));
104070 sqlite3ExprDelete(pParse->db, (yypminor->yy314));
104077 sqlite3IdListDelete(pParse->db, (yypminor->yy384));
104083 sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy203));
104088 sqlite3IdListDelete(pParse->db, (yypminor->yy90).b);
104276 sqlite3ErrorMsg(pParse, "parser stack overflow");
104277 pParse->parseError = 1;
104718 { sqlite3BeginParse(pParse, 0); }
104721 { sqlite3BeginParse(pParse, 1); }
104724 { sqlite3BeginParse(pParse, 2); }
104727 { sqlite3FinishCoding(pParse); }
104730 {sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy4);}
104744 {sqlite3CommitTransaction(pParse);}
104747 {sqlite3RollbackTransaction(pParse);}
104751 sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &yymsp[0].minor.yy0);
104756 sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &yymsp[0].minor.yy0);
104761 sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
104766 sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy4,0,0,yymsp[-2].minor.yy4);
104771 pParse->db->lookaside.bEnabled = 0;
104801 sqlite3EndTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0);
104806 sqlite3EndTable(pParse,0,0,yymsp[0].minor.yy387);
104807 sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy387);
104813 yygotominor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-2].minor.yy0.z) + pParse->sLastToken.n;
104818 sqlite3AddColumn(pParse,&yymsp[0].minor.yy0);
104847 {sqlite3AddColumnType(pParse,&yymsp[0].minor.yy0);}
104866 {sqlite3AddDefaultValue(pParse,&yymsp[0].minor.yy118);}
104869 {sqlite3AddDefaultValue(pParse,&yymsp[-1].minor.yy118);}
104874 v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy118.pExpr, 0, 0);
104877 sqlite3AddDefaultValue(pParse,&v);
104883 spanExpr(&v, pParse, TK_STRING, &yymsp[0].minor.yy0);
104884 sqlite3AddDefaultValue(pParse,&v);
104888 {sqlite3AddNotNull(pParse, yymsp[0].minor.yy4);}
104891 {sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy4,yymsp[0].minor.yy4,yymsp[-2].minor.yy4);}
104894 {sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy4,0,0,0,0);}
104897 {sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy118.pExpr);}
104900 {sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy322,yymsp[0].minor.yy4);}
104903 {sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy4);}
104906 {sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
104952 {sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy322,yymsp[0].minor.yy4,yymsp[-2].minor.yy4,0);}
104955 {sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy322,yymsp[0].minor.yy4,0,0,0,0);}
104958 {sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy118.pExpr);}
104962 sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy322, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy322, yymsp[-1].minor.yy4);
104963 sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy4);
104983 sqlite3DropTable(pParse, yymsp[0].minor.yy259, 0, yymsp[-1].minor.yy4);
104988 sqlite3CreateView(pParse, &yymsp[-7].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, yymsp[0].minor.yy387, yymsp[-6].minor.yy4, yymsp[-4].minor.yy4);
104993 sqlite3DropTable(pParse, yymsp[0].minor.yy259, 1, yymsp[-1].minor.yy4);
104999 sqlite3Select(pParse, yymsp[0].minor.yy387, &dest);
105000 sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy387);
105012 sqlite3SelectDelete(pParse->db, yymsp[-2].minor.yy387);
105022 yygotominor.yy387 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy322,yymsp[-5].minor.yy259,yymsp[-4].minor.yy314,yymsp[-3].minor.yy322,yymsp[-2].minor.yy314,yymsp[-1].minor.yy322,yymsp[-7].minor.yy4,yymsp[0].minor.yy292.pLimit,yymsp[0].minor.yy292.pOffset);
105038 yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy322, yymsp[-1].minor.yy118.pExpr);
105039 if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[0].minor.yy0, 1);
105040 sqlite3ExprListSetSpan(pParse,yygotominor.yy322,&yymsp[-1].minor.yy118);
105045 Expr *p = sqlite3Expr(pParse->db, TK_ALL, 0);
105046 yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-1].minor.yy322, p);
105051 Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, &yymsp[0].minor.yy0);
105052 Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
105053 Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
105054 yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy322, pDot);
105061 {yygotominor.yy259 = sqlite3DbMallocZero(pParse->db, sizeof(*yygotominor.yy259));}
105080 yygotominor.yy259 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
105081 sqlite3SrcListIndexedBy(pParse, yygotominor.yy259, &yymsp[-2].minor.yy0);
105086 yygotominor.yy259 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy387,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
105096 pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy259,0,0,0,0,0,0,0);
105097 yygotominor.yy259 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy259,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy314,yymsp[0].minor.yy384);
105106 {yygotominor.yy259 = sqlite3SrcListAppend(pParse->db,0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
105112 { yygotominor.yy4 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); }
105115 { yygotominor.yy4 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); }
105118 { yygotominor.yy4 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); }
105153 yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy322,yymsp[-1].minor.yy314);
105159 yygotominor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[-1].minor.yy314);
105184 sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy259, &yymsp[-1].minor.yy0);
105185 sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy259,yymsp[0].minor.yy314);
105190 sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy259, &yymsp[-3].minor.yy0);
105191 sqlite3ExprListCheckLength(pParse,yymsp[-1].minor.yy322,"set list");
105192 sqlite3Update(pParse,yymsp[-4].minor.yy259,yymsp[-1].minor.yy322,yymsp[0].minor.yy314,yymsp[-5].minor.yy210);
105197 yygotominor.yy322 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy322, yymsp[0].minor.yy118.pExpr);
105198 sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
105203 yygotominor.yy322 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy118.pExpr);
105204 sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
105208 {sqlite3Insert(pParse, yymsp[-5].minor.yy259, yymsp[-1].minor.yy322, 0, yymsp[-4].minor.yy384, yymsp[-7].minor.yy210);}
105211 {sqlite3Insert(pParse, yymsp[-2].minor.yy259, 0, yymsp[0].minor.yy387, yymsp[-1].minor.yy384, yymsp[-4].minor.yy210);}
105214 {sqlite3Insert(pParse, yymsp[-3].minor.yy259, 0, 0, yymsp[-2].minor.yy384, yymsp[-5].minor.yy210);}
105224 {yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy322,yymsp[0].minor.yy118.pExpr);}
105228 {yygotominor.yy322 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy118.pExpr);}
105231 {yygotominor.yy384 = sqlite3IdListAppend(pParse->db,yymsp[-2].minor.yy384,&yymsp[0].minor.yy0);}
105234 {yygotominor.yy384 = sqlite3IdListAppend(pParse->db,0,&yymsp[0].minor.yy0);}
105245 {spanExpr(&yygotominor.yy118, pParse, yymsp[0].major, &yymsp[0].minor.yy0);}
105249 {spanExpr(&yygotominor.yy118, pParse, TK_ID, &yymsp[0].minor.yy0);}
105253 Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
105254 Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
105255 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
105261 Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-4].minor.yy0);
105262 Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
105263 Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
105264 Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0);
105265 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
105274 if( pParse->nested==0 ){
105275 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &yymsp[0].minor.yy0);
105278 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &yymsp[0].minor.yy0);
105286 spanExpr(&yygotominor.yy118, pParse, TK_VARIABLE, &yymsp[0].minor.yy0);
105287 sqlite3ExprAssignVarNumber(pParse, yygotominor.yy118.pExpr);
105293 yygotominor.yy118.pExpr = sqlite3ExprSetCollByToken(pParse, yymsp[-2].minor.yy118.pExpr, &yymsp[0].minor.yy0);
105300 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy118.pExpr, 0, &yymsp[-1].minor.yy0);
105306 if( yymsp[-1].minor.yy322 && yymsp[-1].minor.yy322->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
105307 sqlite3ErrorMsg(pParse, "too many arguments on function %T", &yymsp[-4].minor.yy0);
105309 yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy322, &yymsp[-4].minor.yy0);
105318 yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0);
105326 yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, 0,&yymsp[0].minor.yy0);
105341 {spanBinaryExpr(&yygotominor.yy118,pParse,yymsp[-1].major,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy118);}
105354 pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy118.pExpr);
105355 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy118.pExpr);
105356 yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy342.eOperator);
105357 if( yymsp[-1].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
105366 pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
105367 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy118.pExpr);
105368 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy118.pExpr);
105369 yygotominor.yy118.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy342.eOperator);
105370 if( yymsp[-3].minor.yy342.not ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
105377 {spanUnaryPostfix(&yygotominor.yy118,pParse,yymsp[0].major,&yymsp[-1].minor.yy118,&yymsp[0].minor.yy0);}
105380 {spanUnaryPostfix(&yygotominor.yy118,pParse,TK_NOTNULL,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy0);}
105384 spanBinaryExpr(&yygotominor.yy118,pParse,TK_IS,&yymsp[-2].minor.yy118,&yymsp[0].minor.yy118);
105385 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy118.pExpr, yygotominor.yy118.pExpr, TK_ISNULL);
105390 spanBinaryExpr(&yygotominor.yy118,pParse,TK_ISNOT,&yymsp[-3].minor.yy118,&yymsp[0].minor.yy118);
105391 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy118.pExpr, yygotominor.yy118.pExpr, TK_NOTNULL);
105396 {spanUnaryPrefix(&yygotominor.yy118,pParse,yymsp[-1].major,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
105399 {spanUnaryPrefix(&yygotominor.yy118,pParse,TK_UMINUS,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
105402 {spanUnaryPrefix(&yygotominor.yy118,pParse,TK_UPLUS,&yymsp[0].minor.yy118,&yymsp[-1].minor.yy0);}
105406 ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
105407 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy118.pExpr);
105408 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy118.pExpr, 0, 0);
105412 sqlite3ExprListDelete(pParse->db, pList);
105414 if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
105430 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &sqlite3IntTokens[yymsp[-3].minor.yy4]);
105431 sqlite3ExprDelete(pParse->db, yymsp[-4].minor.yy118.pExpr);
105433 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy118.pExpr, 0, 0);
105436 sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
105438 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy322);
105440 if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
105448 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
105452 sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
105454 sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
105462 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy118.pExpr, 0, 0);
105466 sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
105468 sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
105470 if( yymsp[-3].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
105477 SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);
105478 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy118.pExpr, 0, 0);
105480 yygotominor.yy118.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
105482 sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
105484 sqlite3SrcListDelete(pParse->db, pSrc);
105486 if( yymsp[-2].minor.yy4 ) yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy118.pExpr, 0, 0);
105493 Expr *p = yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
105497 sqlite3ExprSetHeight(pParse, p);
105499 sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy387);
105507 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy314, yymsp[-1].minor.yy314, 0);
105510 sqlite3ExprSetHeight(pParse, yygotominor.yy118.pExpr);
105512 sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy322);
105520 yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, yymsp[-2].minor.yy118.pExpr);
105521 yygotominor.yy322 = sqlite3ExprListAppend(pParse,yygotominor.yy322, yymsp[0].minor.yy118.pExpr);
105526 yygotominor.yy322 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy118.pExpr);
105527 yygotominor.yy322 = sqlite3ExprListAppend(pParse,yygotominor.yy322, yymsp[0].minor.yy118.pExpr);
105532 sqlite3CreateIndex(pParse, &yymsp[-6].minor.yy0, &yymsp[-5].minor.yy0,
105533 sqlite3SrcListAppend(pParse->db,0,&yymsp[-3].minor.yy0,0), yymsp[-1].minor.yy322, yymsp[-9].minor.yy4,
105548 p = sqlite3Expr(pParse->db, TK_COLUMN, 0);
105549 sqlite3ExprSetCollByToken(pParse, p, &yymsp[-1].minor.yy0);
105551 yygotominor.yy322 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy322, p);
105552 sqlite3ExprListSetName(pParse,yygotominor.yy322,&yymsp[-2].minor.yy0,1);
105553 sqlite3ExprListCheckLength(pParse, yygotominor.yy322, "index");
105561 p = sqlite3PExpr(pParse, TK_COLUMN, 0, 0, 0);
105562 sqlite3ExprSetCollByToken(pParse, p, &yymsp[-1].minor.yy0);
105564 yygotominor.yy322 = sqlite3ExprListAppend(pParse,0, p);
105565 sqlite3ExprListSetName(pParse, yygotominor.yy322, &yymsp[-2].minor.yy0, 1);
105566 sqlite3ExprListCheckLength(pParse, yygotominor.yy322, "index");
105574 {sqlite3DropIndex(pParse, yymsp[0].minor.yy259, yymsp[-1].minor.yy4);}
105578 {sqlite3Vacuum(pParse);}
105581 {sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
105584 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
105587 {sqlite3Pragma(pParse
105590 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
105593 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
105600 sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy203, &all);
105605 sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy4, yymsp[-4].minor.yy90.a, yymsp[-4].minor.yy90.b, yymsp[-2].minor.yy259, yymsp[0].minor.yy314, yymsp[-10].minor.yy4, yymsp[-8].minor.yy4);
105652 sqlite3ErrorMsg(pParse,
105659 sqlite3ErrorMsg(pParse,
105666 sqlite3ErrorMsg(pParse,
105672 { yygotominor.yy203 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy322, yymsp[0].minor.yy314, yymsp[-5].minor.yy210); }
105675 {yygotominor.yy203 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy384, yymsp[-1].minor.yy322, 0, yymsp[-7].minor.yy210);}
105678 {yygotominor.yy203 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy384, 0, yymsp[0].minor.yy387, yymsp[-4].minor.yy210);}
105681 {yygotominor.yy203 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy314);}
105684 {yygotominor.yy203 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy387); }
105688 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
105698 yygotominor.yy118.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0);
105714 sqlite3DropTrigger(pParse,yymsp[0].minor.yy259,yymsp[-1].minor.yy4);
105719 sqlite3Attach(pParse, yymsp[-3].minor.yy118.pExpr, yymsp[-1].minor.yy118.pExpr, yymsp[0].minor.yy314);
105724 sqlite3Detach(pParse, yymsp[0].minor.yy118.pExpr);
105728 {sqlite3Reindex(pParse, 0, 0);}
105731 {sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
105734 {sqlite3Analyze(pParse, 0, 0);}
105737 {sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
105741 sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy259,&yymsp[0].minor.yy0);
105746 sqlite3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy0);
105751 pParse->db->lookaside.bEnabled = 0;
105752 sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy259);
105756 {sqlite3VtabFinishParse(pParse,0);}
105759 {sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
105763 sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
105767 {sqlite3VtabArgInit(pParse);}
105772 {sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
105877 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);
105878 pParse->parseError = 1;
106731 SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
106738 sqlite3 *db = pParse->db; /* The database connection */
106746 pParse->rc = SQLITE_OK;
106747 pParse->zTail = zSql;
106755 assert( pParse->pNewTable==0 );
106756 assert( pParse->pNewTrigger==0 );
106757 assert( pParse->nVar==0 );
106758 assert( pParse->nVarExpr==0 );
106759 assert( pParse->nVarExprAlloc==0 );
106760 assert( pParse->apVarExpr==0 );
106765 pParse->sLastToken.z = &zSql[i];
106766 pParse->sLastToken.n = sqlite3GetToken((unsigned char*)&zSql[i],&tokenType);
106767 i += pParse->sLastToken.n;
106769 pParse->rc = SQLITE_TOOBIG;
106775 sqlite3ErrorMsg(pParse, "interrupt");
106776 pParse->rc = SQLITE_INTERRUPT;
106784 &pParse->sLastToken);
106789 pParse->zTail = &zSql[i];
106793 sqlite3Parser(pEngine, tokenType, pParse->sLastToken, pParse);
106795 if( pParse->rc!=SQLITE_OK ){
106803 if( zSql[i]==0 && nErr==0 && pParse->rc==SQLITE_OK ){
106805 sqlite3Parser(pEngine, TK_SEMI, pParse->sLastToken, pParse);
106806 pParse->zTail = &zSql[i];
106808 sqlite3Parser(pEngine, 0, pParse->sLastToken, pParse);
106818 pParse->rc = SQLITE_NOMEM;
106820 if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){
106821 sqlite3SetString(&pParse->zErrMsg, db, "%s", sqlite3ErrStr(pParse->rc));
106824 if( pParse->zErrMsg ){
106825 *pzErrMsg = pParse->zErrMsg;
106826 sqlite3_log(pParse->rc, "%s", *pzErrMsg);
106827 pParse->zErrMsg = 0;
106830 if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){
106831 sqlite3VdbeDelete(pParse->pVdbe);
106832 pParse->pVdbe = 0;
106835 if( pParse->nested==0 ){
106836 sqlite3DbFree(db, pParse->aTableLock);
106837 pParse->aTableLock = 0;
106838 pParse->nTableLock = 0;
106842 sqlite3_free(pParse->apVtabLock);
106846 /* If the pParse->declareVtab flag is set, do not delete any table
106847 ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
106850 sqlite3DeleteTable(db, pParse->pNewTable);
106853 sqlite3DeleteTrigger(db, pParse->pNewTrigger);
106854 sqlite3DbFree(db, pParse->apVarExpr);
106855 sqlite3DbFree(db, pParse->aAlias);
106856 while( pParse->pAinc ){
106857 AutoincInfo *p = pParse->pAinc;
106858 pParse->pAinc = p->pNext;
106861 while( pParse->pZombieTab ){
106862 Table *p = pParse->pZombieTab;
106863 pParse->pZombieTab = p->pNextZombie;
106866 if( nErr>0 && pParse->rc==SQLITE_OK ){
106867 pParse->rc = SQLITE_ERROR;
117359 ** and other information (column names etc.) in pParse. Create an Fts3Expr
117370 ParseContext *pParse, /* fts3 query parse context */
117376 sqlite3_tokenizer *pTokenizer = pParse->pTokenizer;
117451 ParseContext *pParse, /* fts3 query parse context */
117455 sqlite3_tokenizer *pTokenizer = pParse->pTokenizer;
117523 p->pPhrase->iColumn = pParse->iDefaultCol;
117555 ParseContext *pParse, /* fts3 query parse context */
117644 pParse->nNest++;
117645 rc = fts3ExprParse(pParse, &zInput[1], nInput-1, ppExpr, &nConsumed);
117655 pParse->nNest--;
117672 return getNextString(pParse, &zInput[1], ii-1, ppExpr);
117687 iCol = pParse->iDefaultCol;
117689 for(ii=0; ii<pParse->nCol; ii++){
117690 const char *zStr = pParse->azCol[ii];
117700 rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
117777 ParseContext *pParse, /* fts3 query parse context */
117793 rc = getNextNode(pParse, zIn, nIn, &p, &nByte);
