Lines Matching defs:pParse
11650 Parse *pParse; /* The parser */
12015 #define IN_DECLARE_VTAB (pParse->declareVtab)
12024 Parse *pParse; /* The Parse structure */
12139 Parse *pParse; /* The parsing context. Error messages written here */
12259 Parse *pParse; /* Parser context. */
12568 SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse);
12569 SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse);
12825 SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse);
12827 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
12828 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr);
12829 SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(Parse *pParse, Expr*, const Token*);
13099 SQLITE_PRIVATE void sqlite3ExprSetHeight(Parse *pParse, Expr *p);
14177 Parse *pParse; /* Parsing context used to create this Vdbe */
22388 ** Add an error message to pParse->zErrMsg and increment pParse->nErr.
22404 SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
22407 sqlite3 *db = pParse->db;
22414 pParse->nErr++;
22415 sqlite3DbFree(db, pParse->zErrMsg);
22416 pParse->zErrMsg = zMsg;
22417 pParse->rc = SQLITE_ERROR;
60156 Parse *pParse;
60158 pParse = sqlite3StackAllocZero(pErrorDb, sizeof(*pParse));
60159 if( pParse==0 ){
60163 pParse->db = pDb;
60164 if( sqlite3OpenTempDatabase(pParse) ){
60165 sqlite3Error(pErrorDb, pParse->rc, "%s", pParse->zErrMsg);
60168 sqlite3DbFree(pErrorDb, pParse->zErrMsg);
60169 sqlite3ParserReset(pParse);
60170 sqlite3StackFree(pErrorDb, pParse);
61728 Parse *pParse;
61759 pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx);
61993 Parse *pParse, /* Parse context */
62001 sqlite3 *db = pParse->db;
62016 sqlite3VdbeSetVarmask(pParse->pVdbe, iBindVar);
62017 if( (v = pParse->pReprepare)!=0 ){
62024 pVal->db = pParse->db;
62067 Parse *pParse, /* Parse context */
62079 alloc.pParse = pParse;
62084 rc = stat4ValueFromExpr(pParse, pExpr, affinity, &alloc, &pVal);
62085 assert( pVal==0 || pVal->db==pParse->db );
62101 Parse *pParse, /* Parse context */
62106 return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal);
62237 SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse *pParse){
62238 sqlite3 *db = pParse->db;
62250 p->pParse = pParse;
62251 assert( pParse->aLabel==0 );
62252 assert( pParse->nLabel==0 );
62253 assert( pParse->nOpAlloc==0 );
62312 Parse *p = v->pParse;
62372 if( p->pParse->nOpAlloc<=i ){
62392 Parse *pParse = p->pParse;
62394 struct yColCache *x = pParse->aColCache + jj;
62395 if( x->iLevel>pParse->iCacheLevel || x->iReg==0 ) continue;
62487 Parse *p = v->pParse;
62506 Parse *p = v->pParse;
62594 ** Check if the program stored in the VM associated with pParse may
62611 ** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) );
62661 Parse *pParse = p->pParse;
62662 int *aLabel = pParse->aLabel;
62725 assert( -1-pOp->p2<pParse->nLabel );
62729 sqlite3DbFree(p->db, pParse->aLabel);
62730 pParse->aLabel = 0;
62731 pParse->nLabel = 0;
62775 if( p->nOp + nOp > p->pParse->nOpAlloc && growOpArray(p, nOp) ){
62868 p->pParse->iFixedOp = p->nOp - 1;
62974 if( (p->nOp-1)>(p->pParse->iFixedOp) && p->aOp[p->nOp-1].opcode==op ){
63052 SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse *pParse, Index *pIdx){
63053 Vdbe *v = pParse->pVdbe;
63056 sqlite3VdbeChangeP4(v, -1, (char*)sqlite3KeyInfoOfIndex(pParse, pIdx),
63840 Parse *pParse /* Parsing context */
63855 assert( pParse!=0 );
63857 assert( pParse==p->pParse );
63860 nVar = pParse->nVar;
63861 nMem = pParse->nMem;
63862 nCursor = pParse->nTab;
63863 nArg = pParse->nMaxArg;
63864 nOnce = pParse->nOnce;
63882 zEnd = (u8*)&p->aOp[pParse->nOpAlloc]; /* First byte past end of zCsr[] */
63885 p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort);
63886 if( pParse->explain && nMem<10 ){
63930 p->nzVar = pParse->nzVar;
63931 memcpy(p->azVar, pParse->azVar, p->nzVar*sizeof(p->azVar[0]));
63932 memset(pParse->azVar, 0, pParse->nzVar*sizeof(pParse->azVar[0]));
63942 p->explain = pParse->explain;
74685 Parse *pParse = 0;
74695 pParse = sqlite3StackAllocRaw(db, sizeof(*pParse));
74696 if( !pParse ) goto blob_open_out;
74699 memset(pParse, 0, sizeof(Parse));
74700 pParse->db = db;
74705 pTab = sqlite3LocateTable(pParse, 0, zTable, zDb);
74708 sqlite3ErrorMsg(pParse, "cannot open virtual table: %s", zTable);
74712 sqlite3ErrorMsg(pParse, "cannot open table without rowid: %s", zTable);
74717 sqlite3ErrorMsg(pParse, "cannot open view: %s", zTable);
74721 if( pParse->zErrMsg ){
74723 zErr = pParse->zErrMsg;
74724 pParse->zErrMsg = 0;
74786 pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(pParse);
74828 pParse->nVar = 1;
74829 pParse->nMem = 1;
74830 pParse->nTab = 1;
74831 sqlite3VdbeMakeReady(v, pParse);
74855 sqlite3ParserReset(pParse);
74856 sqlite3StackFree(db, pParse);
76855 Parse *pParse, /* Parsing context */
76870 db = pParse->db;
76875 pDup = sqlite3PExpr(pParse, TK_AS, pDup, 0, 0);
76879 pEList->a[iCol].u.x.iAlias = (u16)(++pParse->nAlias);
76884 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
76977 ** in pParse and return WRC_Abort. Return WRC_Prune on success.
76980 Parse *pParse, /* The parsing context */
76991 sqlite3 *db = pParse->db; /* The database connection */
77098 if( zDb==0 && zTab!=0 && cntTab==0 && pParse->pTriggerTab!=0 ){
77099 int op = pParse->eTriggerOp;
77103 pTab = pParse->pTriggerTab;
77106 pTab = pParse->pTriggerTab;
77135 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
77139 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
77190 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
77193 resolveAlias(pParse, pEList, j, pExpr, "", nSubquery);
77235 sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
77237 sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
77239 sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
77241 pParse->checkSchema = 1;
77272 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
77316 Parse *pParse, /* Leave error message here */
77321 sqlite3ErrorMsg(pParse, "%s prohibited in partial index WHERE clauses",
77331 Parse *pParse, /* Leave error message here */
77336 sqlite3ErrorMsg(pParse,"%s prohibited in CHECK constraints", zMsg);
77370 Parse *pParse;
77374 pParse = pNC->pParse;
77375 assert( pParse==pWalker->pParse );
77384 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
77412 return lookupName(pParse, 0, 0, pExpr->u.zToken, pNC, pExpr);
77436 return lookupName(pParse, zDb, zTable, zColumn, pNC, pExpr);
77451 u8 enc = ENC(pParse->db); /* The database encoding */
77454 notValidPartIdxWhere(pParse, pNC, "functions");
77457 pDef = sqlite3FindFunction(pParse->db, zId, nId, n, enc, 0);
77459 pDef = sqlite3FindFunction(pParse->db, zId, nId, -2, enc, 0);
77472 sqlite3ErrorMsg(pParse, "second argument to likelihood() must be a "
77492 auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0, pDef->zName, 0);
77495 sqlite3ErrorMsg(pParse, "not authorized to use function: %s",
77506 sqlite3ErrorMsg(pParse, "misuse of aggregate function %.*s()", nId,zId);
77509 }else if( no_such_func && pParse->db->init.busy==0 ){
77510 sqlite3ErrorMsg(pParse, "no such function: %.*s", nId, zId);
77513 sqlite3ErrorMsg(pParse,"wrong number of arguments to function %.*s()",
77543 notValidCheckConstraint(pParse, pNC, "subqueries");
77544 notValidPartIdxWhere(pParse, pNC, "subqueries");
77554 notValidCheckConstraint(pParse, pNC, "parameters");
77555 notValidPartIdxWhere(pParse, pNC, "parameters");
77559 return (pParse->nErr || pParse->db->mallocFailed) ? WRC_Abort : WRC_Continue;
77575 Parse *pParse, /* Parsing context for error messages */
77581 UNUSED_PARAMETER(pParse);
77614 Parse *pParse, /* Parsing context for error messages */
77631 nc.pParse = pParse;
77636 db = pParse->db;
77661 Parse *pParse, /* The error context into which to write the error */
77666 sqlite3ErrorMsg(pParse,
77687 Parse *pParse, /* Parsing context. Leave error messages here */
77698 db = pParse->db;
77701 sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
77725 resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr);
77729 iCol = resolveAsName(pParse, pEList, pE);
77734 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
77764 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
77779 ** If any errors are detected, add an error message to pParse and
77783 Parse *pParse, /* Parsing context. Leave error messages here */
77789 sqlite3 *db = pParse->db;
77793 if( pOrderBy==0 || pParse->db->mallocFailed ) return 0;
77796 sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
77805 resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr);
77808 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr, zType,0);
77829 ** an appropriate error message might be left in pParse. (OOM errors
77841 Parse *pParse; /* Parsing context */
77846 pParse = pNC->pParse;
77851 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
77866 resolveOutOfRangeError(pParse, zType, i+1, nResult);
77884 return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType);
77895 Parse *pParse; /* Parsing context */
77908 pParse = pWalker->pParse;
77909 db = pParse->db;
77920 sqlite3SelectPrep(pParse, p, pOuterNC);
77921 return (pParse->nErr || db->mallocFailed) ? WRC_Abort : WRC_Prune;
77936 sNC.pParse = pParse;
77949 const char *zSavedContext = pParse->zAuthContext;
77958 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
77959 sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
77960 pParse->zAuthContext = zSavedContext;
77961 if( pParse->nErr || db->mallocFailed ) return WRC_Abort;
78000 sqlite3ErrorMsg(pParse, "a GROUP BY clause is required before HAVING");
78045 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
78061 if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){
78113 ** An error message is left in pParse if anything is amiss. The number
78126 Parse *pParse = pNC->pParse;
78127 if( sqlite3ExprCheckHeight(pParse, pExpr->nHeight+pNC->pParse->nHeight) ){
78130 pParse->nHeight += pExpr->nHeight;
78138 w.pParse = pNC->pParse;
78142 pNC->pParse->nHeight -= pExpr->nHeight;
78144 if( pNC->nErr>0 || w.pParse->nErr>0 ){
78169 Parse *pParse, /* The parser context */
78179 w.pParse = pParse;
78193 ** Any errors cause an error message to be set in pParse.
78196 Parse *pParse, /* Parsing context */
78202 SrcList sSrc; /* Fake SrcList for pParse->pNewTable */
78203 NameContext sNC; /* Name context for pParse->pNewTable */
78213 sNC.pParse = pParse;
78292 ** If a memory allocation error occurs, that fact is recorded in pParse->db
78296 Parse *pParse, /* Parsing context */
78301 Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, 1);
78310 SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse *pParse, Expr *pExpr, const char *zC){
78315 return sqlite3ExprAddCollateToken(pParse, pExpr, &s);
78346 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr){
78347 sqlite3 *db = pParse->db;
78358 pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken);
78384 if( sqlite3CheckCollSeq(pParse, pColl) ){
78480 Parse *pParse,
78487 pColl = sqlite3ExprCollSeq(pParse, pLeft);
78489 pColl = sqlite3ExprCollSeq(pParse, pRight);
78491 pColl = sqlite3ExprCollSeq(pParse, pLeft);
78493 pColl = sqlite3ExprCollSeq(pParse, pRight);
78503 Parse *pParse, /* The parsing (and code generating) context */
78515 p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
78517 addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
78519 sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
78527 ** pParse.
78529 SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){
78531 int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
78533 sqlite3ErrorMsg(pParse,
78600 ** leave an error in pParse.
78602 SQLITE_PRIVATE void sqlite3ExprSetHeight(Parse *pParse, Expr *p){
78604 sqlite3ExprCheckHeight(pParse, p->nHeight);
78733 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
78737 Parse *pParse, /* Parsing context */
78746 p = sqlite3ExprAnd(pParse->db, pLeft, pRight);
78748 p = sqlite3ExprAlloc(pParse->db, op, pToken, 1);
78749 sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
78752 sqlite3ExprCheckHeight(pParse, p->nHeight);
78812 SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse *pParse, ExprList *pList, Token *pToken){
78814 sqlite3 *db = pParse->db;
78823 sqlite3ExprSetHeight(pParse, pNew);
78843 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
78844 sqlite3 *db = pParse->db;
78855 pExpr->iColumn = (ynVar)(++pParse->nVar);
78870 sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
78874 if( i>pParse->nVar ){
78875 pParse->nVar = (int)i;
78883 for(i=0; i<pParse->nzVar; i++){
78884 if( pParse->azVar[i] && strcmp(pParse->azVar[i],z)==0 ){
78889 if( x==0 ) x = pExpr->iColumn = (ynVar)(++pParse->nVar);
78892 if( x>pParse->nzVar ){
78894 a = sqlite3DbRealloc(db, pParse->azVar, x*sizeof(a[0]));
78896 pParse->azVar = a;
78897 memset(&a[pParse->nzVar], 0, (x-pParse->nzVar)*sizeof(a[0]));
78898 pParse->nzVar = x;
78900 if( z[0]!='?' || pParse->azVar[x-1]==0 ){
78901 sqlite3DbFree(db, pParse->azVar[x-1]);
78902 pParse->azVar[x-1] = sqlite3DbStrNDup(db, z, n);
78906 if( !pParse->nErr && pParse->nVar>db->aLimit[SQLITE_LIMIT_VARIABLE_NUMBER] ){
78907 sqlite3ErrorMsg(pParse, "too many SQL variables");
79317 Parse *pParse, /* Parsing context */
79321 sqlite3 *db = pParse->db;
79358 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
79362 Parse *pParse, /* Parsing context */
79367 assert( pList!=0 || pParse->db->mallocFailed!=0 );
79373 pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
79383 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
79387 Parse *pParse, /* Parsing context */
79391 sqlite3 *db = pParse->db;
79405 ** leave an error message in pParse.
79408 Parse *pParse,
79412 int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
79416 sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
79702 SQLITE_PRIVATE int sqlite3CodeOnce(Parse *pParse){
79703 Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
79704 return sqlite3VdbeAddOp1(v, OP_Once, pParse->nOnce++);
79812 SQLITE_PRIVATE int sqlite3FindInIndex(Parse *pParse, Expr *pX, u32 inFlags, int *prRhsHasNull){
79815 int iTab = pParse->nTab++; /* Cursor of the RHS table */
79817 Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
79827 if( ALWAYS(pParse->nErr==0) && isCandidateForInOpt(p) ){
79828 sqlite3 *db = pParse->db; /* Database connection */
79844 sqlite3CodeVerifySchema(pParse, iDb);
79845 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
79853 int iAddr = sqlite3CodeOnce(pParse);
79856 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
79866 CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pExpr);
79879 int iAddr = sqlite3CodeOnce(pParse); VdbeCoverage(v);
79881 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
79887 pParse->nMem;
79916 u32 savedNQueryLoop = pParse->nQueryLoop;
79920 pParse->nQueryLoop = 0;
79925 *prRhsHasNull = rMayHaveNull = ++pParse->nMem;
79927 sqlite3CodeSubselect(pParse, pX, rMayHaveNull, eType==IN_INDEX_ROWID);
79928 pParse->nQueryLoop = savedNQueryLoop;
79965 Parse *pParse, /* Parsing context */
79972 Vdbe *v = sqlite3GetVdbe(pParse);
79974 sqlite3ExprCachePush(pParse);
79987 jmpIfDynamic = sqlite3CodeOnce(pParse); VdbeCoverage(v);
79991 if( pParse->explain==2 ){
79993 pParse->db, "EXECUTE %s%s SUBQUERY %d", jmpIfDynamic>=0?"":"CORRELATED ",
79994 pExpr->op==TK_IN?"LIST":"SCALAR", pParse->iNextSelectId
79996 sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
80022 pExpr->iTable = pParse->nTab++;
80024 pKeyInfo = isRowid ? 0 : sqlite3KeyInfoAlloc(pParse->db, 1, 1);
80044 if( sqlite3Select(pParse, pSelect, &dest) ){
80053 pKeyInfo->aColl[0] = sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft,
80073 pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
80077 r1 = sqlite3GetTempReg(pParse);
80078 r2 = sqlite3GetTempReg(pParse);
80098 r3 = sqlite3ExprCodeTarget(pParse, pE2, r1);
80106 sqlite3ExprCacheAffinityChange(pParse, r3, 1);
80111 sqlite3ReleaseTempReg(pParse, r1);
80112 sqlite3ReleaseTempReg(pParse, r2);
80138 sqlite3SelectDestInit(&dest, 0, ++pParse->nMem);
80148 sqlite3ExprDelete(pParse->db, pSel->pLimit);
80149 pSel->pLimit = sqlite3PExpr(pParse, TK_INTEGER, 0, 0,
80152 if( sqlite3Select(pParse, pSel, &dest) ){
80168 sqlite3ExprCachePop(pParse);
80193 Parse *pParse, /* Parsing and code generating context */
80207 v = pParse->pVdbe;
80210 eType = sqlite3FindInIndex(pParse, pExpr,
80222 sqlite3ExprCachePush(pParse);
80223 r1 = sqlite3GetTempReg(pParse);
80224 sqlite3ExprCode(pParse, pExpr->pLeft, r1);
80232 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
80239 regCkNull = sqlite3GetTempReg(pParse);
80243 r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree);
80259 sqlite3ReleaseTempReg(pParse, regToFree);
80266 sqlite3ReleaseTempReg(pParse, regCkNull);
80336 sqlite3ReleaseTempReg(pParse, r1);
80337 sqlite3ExprCachePop(pParse);
80382 static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
80383 Vdbe *v = pParse->pVdbe;
80402 sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
80406 sqlite3ErrorMsg(pParse, "hex literal too big: %s", z);
80420 static void cacheEntryClear(Parse *pParse, struct yColCache *p){
80422 if( pParse->nTempReg<ArraySize(pParse->aTempReg) ){
80423 pParse->aTempReg[pParse->nTempReg++] = p->iReg;
80434 SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
80447 if( OptimizationDisabled(pParse->db, SQLITE_ColumnCache) ) return;
80455 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
80461 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
80463 p->iLevel = pParse->iCacheLevel;
80468 p->lru = pParse->iCacheCnt++;
80476 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
80483 p = &pParse->aColCache[idxLru];
80484 p->iLevel = pParse->iCacheLevel;
80489 p->lru = pParse->iCacheCnt++;
80498 SQLITE_PRIVATE void sqlite3ExprCacheRemove(Parse *pParse, int iReg, int nReg){
80502 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
80505 cacheEntryClear(pParse, p);
80516 SQLITE_PRIVATE void sqlite3ExprCachePush(Parse *pParse){
80517 pParse->iCacheLevel++;
80519 if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
80520 printf("PUSH to %d\n", pParse->iCacheLevel);
80530 SQLITE_PRIVATE void sqlite3ExprCachePop(Parse *pParse){
80533 assert( pParse->iCacheLevel>=1 );
80534 pParse->iCacheLevel--;
80536 if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
80537 printf("POP to %d\n", pParse->iCacheLevel);
80540 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
80541 if( p->iReg && p->iLevel>pParse->iCacheLevel ){
80542 cacheEntryClear(pParse, p);
80554 static void sqlite3ExprCachePinRegister(Parse *pParse, int iReg){
80557 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
80599 Parse *pParse, /* Parsing and code generating context */
80606 Vdbe *v = pParse->pVdbe;
80610 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
80612 p->lru = pParse->iCacheCnt++;
80613 sqlite3ExprCachePinRegister(pParse, p->iReg);
80622 sqlite3ExprCacheStore(pParse, iTable, iColumn, iReg);
80630 SQLITE_PRIVATE void sqlite3ExprCacheClear(Parse *pParse){
80635 if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
80639 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
80641 cacheEntryClear(pParse, p);
80651 SQLITE_PRIVATE void sqlite3ExprCacheAffinityChange(Parse *pParse, int iStart, int iCount){
80652 sqlite3ExprCacheRemove(pParse, iStart, iCount);
80659 SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
80663 sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
80664 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
80680 static int usedAsColumnCache(Parse *pParse, int iFrom, int iTo){
80683 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
80712 SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
80713 Vdbe *v = pParse->pVdbe; /* The VM under construction */
80719 sqlite3 *db = pParse->db; /* The database connection */
80722 assert( target>0 && target<=pParse->nMem );
80724 assert( pParse->db->mallocFailed );
80751 if( pParse->ckBase>0 ){
80753 inReg = pExpr->iColumn + pParse->ckBase;
80757 iTab = pParse->iPartIdxTab;
80760 inReg = sqlite3ExprCodeGetColumn(pParse, pExpr->pTab,
80766 codeInteger(pParse, pExpr, 0, target);
80808 || strcmp(pExpr->u.zToken, pParse->azVar[pExpr->iColumn-1])==0 );
80809 sqlite3VdbeChangeP4(v, -1, pParse->azVar[pExpr->iColumn-1], P4_STATIC);
80818 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
80825 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
80844 testcase( usedAsColumnCache(pParse, inReg, inReg) );
80845 sqlite3ExprCacheAffinityChange(pParse, inReg, 1);
80855 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
80856 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
80857 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
80873 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
80874 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
80876 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
80907 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
80908 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
80918 codeInteger(pParse, pLeft, 1, target);
80928 r1 = sqlite3ExprCodeTemp(pParse, &tempX, ®Free1);
80929 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
80940 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
80952 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
80965 sqlite3ErrorMsg(pParse, "misuse of aggregate: %s()", pExpr->u.zToken);
80994 sqlite3ErrorMsg(pParse, "unknown function: %.*s()", nId, zId);
81005 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
81009 sqlite3ExprCacheRemove(pParse, target, 1);
81010 sqlite3ExprCachePush(pParse);
81011 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
81012 sqlite3ExprCachePop(pParse);
81023 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
81033 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
81038 r1 = pParse->nMem+1;
81039 pParse->nMem += nFarg;
81041 r1 = sqlite3GetTempRange(pParse, nFarg);
81063 sqlite3ExprCachePush(pParse); /* Ticket 2ea2425d34be */
81064 sqlite3ExprCodeExprList(pParse, pFarg, r1,
81066 sqlite3ExprCachePop(pParse); /* Ticket 2ea2425d34be */
81097 sqlite3ReleaseTempRange(pParse, r1, nFarg);
81106 inReg = sqlite3CodeSubselect(pParse, pExpr, 0, 0);
81113 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
81139 r1 = sqlite3ExprCodeTemp(pParse, pLeft, ®Free1);
81140 r2 = sqlite3ExprCodeTemp(pParse, pRight, ®Free2);
81143 r3 = sqlite3GetTempReg(pParse);
81144 r4 = sqlite3GetTempReg(pParse);
81145 codeCompare(pParse, pLeft, pRight, OP_Ge,
81149 sqlite3ReleaseTempReg(pParse, regFree2);
81150 r2 = sqlite3ExprCodeTemp(pParse, pRight, ®Free2);
81152 codeCompare(pParse, pLeft, pRight, OP_Le, r1, r2, r4, SQLITE_STOREP2);
81155 sqlite3ReleaseTempReg(pParse, r3);
81156 sqlite3ReleaseTempReg(pParse, r4);
81161 inReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft, target);
81250 VVA_ONLY( int iCacheLevel = pParse->iCacheLevel; )
81261 exprToRegister(&tempX, sqlite3ExprCodeTemp(pParse, pX, ®Free1));
81273 sqlite3ExprCachePush(pParse);
81282 sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
81284 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
81286 sqlite3ExprCachePop(pParse);
81290 sqlite3ExprCachePush(pParse);
81291 sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target);
81292 sqlite3ExprCachePop(pParse);
81296 assert( db->mallocFailed || pParse->nErr>0
81297 || pParse->iCacheLevel==iCacheLevel );
81308 if( !pParse->pTriggerTab ){
81309 sqlite3ErrorMsg(pParse,
81314 sqlite3MayAbort(pParse);
81322 sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_TRIGGER,
81330 sqlite3ReleaseTempReg(pParse, regFree1);
81331 sqlite3ReleaseTempReg(pParse, regFree2);
81339 Parse *pParse, /* Parsing context */
81345 assert( ConstFactorOk(pParse) );
81346 p = pParse->pConstExpr;
81347 pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
81348 p = sqlite3ExprListAppend(pParse, p, pExpr);
81354 pParse->pConstExpr = p;
81370 SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
81373 if( ConstFactorOk(pParse)
81377 ExprList *p = pParse->pConstExpr;
81388 r2 = ++pParse->nMem;
81389 sqlite3ExprCodeAtInit(pParse, pExpr, r2, 1);
81391 int r1 = sqlite3GetTempReg(pParse);
81392 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
81396 sqlite3ReleaseTempReg(pParse, r1);
81408 SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
81411 assert( target>0 && target<=pParse->nMem );
81413 sqlite3VdbeAddOp2(pParse->pVdbe, OP_Copy, pExpr->iTable, target);
81415 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
81416 assert( pParse->pVdbe || pParse->db->mallocFailed );
81417 if( inReg!=target && pParse->pVdbe ){
81418 sqlite3VdbeAddOp2(pParse->pVdbe, OP_SCopy, inReg, target);
81429 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
81430 if( pParse->okConstFactor && sqlite3ExprIsConstant(pExpr) ){
81431 sqlite3ExprCodeAtInit(pParse, pExpr, target, 0);
81433 sqlite3ExprCode(pParse, pExpr, target);
81449 SQLITE_PRIVATE void sqlite3ExprCodeAndCache(Parse *pParse, Expr *pExpr, int target){
81450 Vdbe *v = pParse->pVdbe;
81455 sqlite3ExprCode(pParse, pExpr, target);
81456 iMem = ++pParse->nMem;
81746 Parse *pParse, /* Parsing context */
81756 assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */
81758 if( !ConstFactorOk(pParse) ) flags &= ~SQLITE_ECEL_FACTOR;
81762 sqlite3ExprCodeAtInit(pParse, pExpr, target+i, 0);
81764 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
81767 Vdbe *v = pParse->pVdbe;
81796 Parse *pParse, /* Parsing and code generating context */
81819 exprToRegister(&exprX, sqlite3ExprCodeTemp(pParse, &exprX, ®Free1));
81821 sqlite3ExprIfTrue(pParse, &exprAnd, dest, jumpIfNull);
81823 sqlite3ExprIfFalse(pParse, &exprAnd, dest, jumpIfNull);
81825 sqlite3ReleaseTempReg(pParse, regFree1);
81852 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
81853 Vdbe *v = pParse->pVdbe;
81867 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,jumpIfNull^SQLITE_JUMPIFNULL);
81868 sqlite3ExprCachePush(pParse);
81869 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
81871 sqlite3ExprCachePop(pParse);
81876 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
81877 sqlite3ExprCachePush(pParse);
81878 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
81879 sqlite3ExprCachePop(pParse);
81884 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
81894 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
81895 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
81896 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
81912 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
81913 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
81915 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
81927 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
81936 exprCodeBetween(pParse, pExpr, dest, 1, jumpIfNull);
81943 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
81955 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
81964 sqlite3ReleaseTempReg(pParse, regFree1);
81965 sqlite3ReleaseTempReg(pParse, regFree2);
81977 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
81978 Vdbe *v = pParse->pVdbe;
82022 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
82023 sqlite3ExprCachePush(pParse);
82024 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
82025 sqlite3ExprCachePop(pParse);
82031 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2, jumpIfNull^SQLITE_JUMPIFNULL);
82032 sqlite3ExprCachePush(pParse);
82033 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
82035 sqlite3ExprCachePop(pParse);
82040 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
82050 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
82051 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
82052 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
82068 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
82069 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
82071 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
82081 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
82090 exprCodeBetween(pParse, pExpr, dest, 0, jumpIfNull);
82096 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
82099 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
82111 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
82120 sqlite3ReleaseTempReg(pParse, regFree1);
82121 sqlite3ReleaseTempReg(pParse, regFree2);
82352 Parse *pParse = pNC->pParse;
82384 && (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
82390 pCol->iMem = ++pParse->nMem;
82442 u8 enc = ENC(pParse->db);
82443 i = addAggInfoFunc(pParse->db, pAggInfo);
82448 pItem->iMem = ++pParse->nMem;
82450 pItem->pFunc = sqlite3FindFunction(pParse->db,
82454 pItem->iDistinct = pParse->nTab++;
82518 SQLITE_PRIVATE int sqlite3GetTempReg(Parse *pParse){
82519 if( pParse->nTempReg==0 ){
82520 return ++pParse->nMem;
82522 return pParse->aTempReg[--pParse->nTempReg];
82533 SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
82534 if( iReg && pParse->nTempReg<ArraySize(pParse->aTempReg) ){
82537 for(i=0, p=pParse->aColCache; i<SQLITE_N_COLCACHE; i++, p++){
82543 pParse->aTempReg[pParse->nTempReg++] = iReg;
82550 SQLITE_PRIVATE int sqlite3GetTempRange(Parse *pParse, int nReg){
82552 i = pParse->iRangeReg;
82553 n = pParse->nRangeReg;
82555 assert( !usedAsColumnCache(pParse, i, i+n-1) );
82556 pParse->iRangeReg += nReg;
82557 pParse->nRangeReg -= nReg;
82559 i = pParse->nMem+1;
82560 pParse->nMem += nReg;
82564 SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
82565 sqlite3ExprCacheRemove(pParse, iReg, nReg);
82566 if( nReg>pParse->nRangeReg ){
82567 pParse->nRangeReg = nReg;
82568 pParse->iRangeReg = iReg;
82575 SQLITE_PRIVATE void sqlite3ClearTempRegCache(Parse *pParse){
82576 pParse->nTempReg = 0;
82577 pParse->nRangeReg = 0;
82863 static char *whereForeignKeys(Parse *pParse, Table *pTab){
82867 zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName);
82879 static char *whereTempTriggers(Parse *pParse, Table *pTab){
82882 const Schema *pTempSchema = pParse->db->aDb[1].pSchema; /* Temp db schema */
82890 sqlite3 *db = pParse->db;
82891 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
82898 char *zNew = sqlite3MPrintf(pParse->db, "type='trigger' AND (%s)", zWhere);
82899 sqlite3DbFree(pParse->db, zWhere);
82913 static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
82921 v = sqlite3GetVdbe(pParse);
82923 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
82924 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
82929 for(pTrig=sqlite3TriggerList(pParse, pTab); pTrig; pTrig=pTrig->pNext){
82930 int iTrigDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
82940 zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName);
82948 if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
82958 ** in pParse->zErr (system tables may not be altered) and returns non-zero.
82962 static int isSystemTable(Parse *pParse, const char *zName){
82964 sqlite3ErrorMsg(pParse, "table %s may not be altered", zName);
82975 Parse *pParse, /* Parser context. */
82983 sqlite3 *db = pParse->db; /* Database connection */
82996 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
82998 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
83000 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
83012 sqlite3ErrorMsg(pParse,
83020 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
83023 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){ goto
83029 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
83036 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
83042 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
83058 v = sqlite3GetVdbe(pParse);
83062 sqlite3BeginWriteOperation(pParse, pVTab!=0, iDb);
83063 sqlite3ChangeCookie(pParse, iDb);
83072 int i = ++pParse->nMem;
83075 sqlite3MayAbort(pParse);
83088 if( (zWhere=whereForeignKeys(pParse, pTab))!=0 ){
83089 sqlite3NestedParse(pParse,
83099 sqlite3NestedParse(pParse,
83128 sqlite3NestedParse(pParse,
83139 if( (zWhere=whereTempTriggers(pParse, pTab))!=0 ){
83140 sqlite3NestedParse(pParse,
83155 reloadTableSchema(pParse, p->pFrom, pFrom->zName);
83162 reloadTableSchema(pParse, pTab, zName);
83175 SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){
83177 v = sqlite3GetVdbe(pParse);
83182 int r1 = sqlite3GetTempReg(pParse);
83183 int r2 = sqlite3GetTempReg(pParse);
83192 sqlite3ReleaseTempReg(pParse, r1);
83193 sqlite3ReleaseTempReg(pParse, r2);
83202 ** The Table structure pParse->pNewTable was extended to include
83205 SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
83206 Table *pNew; /* Copy of pParse->pNewTable */
83216 db = pParse->db;
83217 if( pParse->nErr || db->mallocFailed ) return;
83218 pNew = pParse->pNewTable;
83232 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
83250 sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column");
83254 sqlite3ErrorMsg(pParse, "Cannot add a UNIQUE column");
83258 sqlite3ErrorMsg(pParse,
83263 sqlite3ErrorMsg(pParse,
83278 sqlite3ErrorMsg(pParse, "Cannot add a column with non-constant default");
83293 sqlite3NestedParse(pParse,
83308 sqlite3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2);
83311 reloadTableSchema(pParse, pTab, pTab->zName);
83329 SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
83336 sqlite3 *db = pParse->db;
83339 assert( pParse->pNewTable==0 );
83342 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
83347 sqlite3ErrorMsg(pParse, "virtual tables may not be altered");
83354 sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
83357 if( SQLITE_OK!=isSystemTable(pParse, pTab->zName) ){
83373 pParse->pNewTable = pNew;
83399 sqlite3BeginWriteOperation(pParse, 0, iDb);
83400 v = sqlite3GetVdbe(pParse);
83402 sqlite3ChangeCookie(pParse, iDb);
83583 Parse *pParse, /* Parsing context */
83606 sqlite3 *db = pParse->db;
83608 Vdbe *v = sqlite3GetVdbe(pParse);
83627 ** of the new table in register pParse->regRoot. This is important
83629 sqlite3NestedParse(pParse,
83632 aRoot[i] = pParse->regRoot;
83641 sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab);
83643 sqlite3NestedParse(pParse,
84362 Parse *pParse, /* Parser context */
84369 sqlite3 *db = pParse->db; /* Database handle */
84390 pParse->nMem = MAX(pParse->nMem, iMem);
84391 v = sqlite3GetVdbe(pParse);
84408 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
84418 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
84421 pParse->nTab = MAX(pParse->nTab, iTab);
84422 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
84484 pParse->nMem = MAX(pParse->nMem, regPrev+nColTest);
84489 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
84550 char *pColl = (char*)sqlite3LocateCollSeq(pParse, pIdx->azColl[i]);
84592 regKey = sqlite3GetTempRange(pParse, pPk->nKeyCol);
84599 sqlite3ReleaseTempRange(pParse, regKey, pPk->nKeyCol);
84628 pParse->nMem = MAX(pParse->nMem, regCol+nCol);
84686 static void loadAnalysis(Parse *pParse, int iDb){
84687 Vdbe *v = sqlite3GetVdbe(pParse);
84696 static void analyzeDatabase(Parse *pParse, int iDb){
84697 sqlite3 *db = pParse->db;
84704 sqlite3BeginWriteOperation(pParse, 0, iDb);
84705 iStatCur = pParse->nTab;
84706 pParse->nTab += 3;
84707 openStatTable(pParse, iDb, iStatCur, 0, 0);
84708 iMem = pParse->nMem+1;
84709 iTab = pParse->nTab;
84713 analyzeOneTable(pParse, pTab, 0, iStatCur, iMem, iTab);
84715 loadAnalysis(pParse, iDb);
84723 static void analyzeTable(Parse *pParse, Table *pTab, Index *pOnlyIdx){
84728 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
84729 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
84730 sqlite3BeginWriteOperation(pParse, 0, iDb);
84731 iStatCur = pParse->nTab;
84732 pParse->nTab += 3;
84734 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
84736 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
84738 analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur,pParse->nMem+1,pParse->nTab);
84739 loadAnalysis(pParse, iDb);
84754 SQLITE_PRIVATE void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){
84755 sqlite3 *db = pParse->db;
84765 ** and code in pParse and return NULL. */
84766 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
84767 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
84776 analyzeDatabase(pParse, i);
84782 analyzeDatabase(pParse, iDb);
84787 analyzeTable(pParse, pIdx->pTable, pIdx);
84788 }else if( (pTab = sqlite3LocateTable(pParse, 0, z, 0))!=0 ){
84789 analyzeTable(pParse, pTab, 0);
84796 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
84802 analyzeTable(pParse, pIdx->pTable, pIdx);
84803 }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
84804 analyzeTable(pParse, pTab, 0);
84810 v = sqlite3GetVdbe(pParse);
85566 Parse *pParse, /* The parser context */
85577 sqlite3* db = pParse->db;
85581 sName.pParse = pParse;
85588 pParse->nErr++;
85600 rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
85608 v = sqlite3GetVdbe(pParse);
85609 regArgs = sqlite3GetTempRange(pParse, 4);
85610 sqlite3ExprCode(pParse, pFilename, regArgs);
85611 sqlite3ExprCode(pParse, pDbname, regArgs+1);
85612 sqlite3ExprCode(pParse, pKey, regArgs+2);
85639 SQLITE_PRIVATE void sqlite3Detach(Parse *pParse, Expr *pDbname){
85652 codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname);
85660 SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
85673 codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
85683 Parse *pParse, /* Error messages will be written here */
85690 db = pParse->db;
85692 pFix->pParse = pParse;
85711 ** pParse->zErrMsg and these routines return non-zero. If everything
85727 sqlite3ErrorMsg(pFix->pParse,
85732 sqlite3DbFree(pFix->pParse->db, pItem->zDatabase);
85783 if( pFix->pParse->db->init.busy ){
85786 sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType);
85924 ** Write an error message into pParse->zErrMsg that explains that the
85927 static void sqliteAuthBadReturnCode(Parse *pParse){
85928 sqlite3ErrorMsg(pParse, "authorizer malfunction");
85929 pParse->rc = SQLITE_ERROR;
85939 ** is treated as SQLITE_DENY. In this case an error is left in pParse.
85942 Parse *pParse, /* The parser context */
85947 sqlite3 *db = pParse->db; /* Database handle */
85951 rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext);
85954 sqlite3ErrorMsg(pParse, "access to %s.%s.%s is prohibited",zDb,zTab,zCol);
85956 sqlite3ErrorMsg(pParse, "access to %s.%s is prohibited", zTab, zCol);
85958 pParse->rc = SQLITE_AUTH;
85960 sqliteAuthBadReturnCode(pParse);
85975 Parse *pParse, /* The parser context */
85980 sqlite3 *db = pParse->db;
85988 iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
85997 pTab = pParse->pTriggerTab;
86020 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
86028 ** is returned, then the error count and error message in pParse are
86032 Parse *pParse,
86038 sqlite3 *db = pParse->db;
86051 rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext);
86053 sqlite3ErrorMsg(pParse, "not authorized");
86054 pParse->rc = SQLITE_AUTH;
86057 sqliteAuthBadReturnCode(pParse);
86065 ** popped. Or if pParse==0, this routine is a no-op.
86068 Parse *pParse,
86072 assert( pParse );
86073 pContext->pParse = pParse;
86074 pContext->zAuthContext = pParse->zAuthContext;
86075 pParse->zAuthContext = zContext;
86083 if( pContext->pParse ){
86084 pContext->pParse->zAuthContext = pContext->zAuthContext;
86085 pContext->pParse = 0;
86120 ** be parsed. Initialize the pParse structure as needed.
86122 SQLITE_PRIVATE void sqlite3BeginParse(Parse *pParse, int explainFlag){
86123 pParse->explain = (u8)explainFlag;
86124 pParse->nVar = 0;
86150 Parse *pParse, /* Parsing context */
86156 Parse *pToplevel = sqlite3ParseToplevel(pParse);
86189 static void codeTableLocks(Parse *pParse){
86193 pVdbe = sqlite3GetVdbe(pParse);
86196 for(i=0; i<pParse->nTableLock; i++){
86197 TableLock *p = &pParse->aTableLock[i];
86224 ** VDBE program and resets the pParse structure for the next
86230 SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){
86234 assert( pParse->pToplevel==0 );
86235 db = pParse->db;
86237 if( pParse->nested ) return;
86238 if( pParse->nErr ) return;
86243 v = sqlite3GetVdbe(pParse);
86244 assert( !pParse->isMultiWrite
86245 || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
86257 && (DbMaskNonZero(pParse->cookieMask) || pParse->pConstExpr)
86263 if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
86268 DbMaskTest(pParse->writeMask,iDb), /* P2 */
86269 pParse->cookieValue[iDb], /* P3 */
86275 for(i=0; i<pParse->nVtabLock; i++){
86276 char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
86279 pParse->nVtabLock = 0;
86286 codeTableLocks(pParse);
86290 sqlite3AutoincrementBegin(pParse);
86293 if( pParse->pConstExpr ){
86294 ExprList *pEL = pParse->pConstExpr;
86295 pParse->okConstFactor = 0;
86297 sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
86309 if( v && ALWAYS(pParse->nErr==0) && !db->mallocFailed ){
86310 assert( pParse->iCacheLevel==0 ); /* Disables and re-enables match */
86313 if( pParse->pAinc!=0 && pParse->nTab==0 ) pParse->nTab = 1;
86314 sqlite3VdbeMakeReady(v, pParse);
86315 pParse->rc = SQLITE_DONE;
86316 pParse->colNamesSet = 0;
86318 pParse->rc = SQLITE_ERROR;
86320 pParse->nTab = 0;
86321 pParse->nMem = 0;
86322 pParse->nSet = 0;
86323 pParse->nVar = 0;
86324 DbMaskZero(pParse->cookieMask);
86329 ** code for the SQL statement given onto the end of the pParse context
86339 SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
86343 sqlite3 *db = pParse->db;
86347 if( pParse->nErr ) return;
86348 assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
86355 pParse->nested++;
86356 memcpy(saveBuf, &pParse->nVar, SAVE_SZ);
86357 memset(&pParse->nVar, 0, SAVE_SZ);
86358 sqlite3RunParser(pParse, zSql, &zErrMsg);
86361 memcpy(&pParse->nVar, saveBuf, SAVE_SZ);
86362 pParse->nested--;
86399 ** error message in pParse->zErrMsg.
86402 ** routine leaves an error message in pParse->zErrMsg where
86406 Parse *pParse, /* context in which to report errors */
86414 ** and code in pParse and return NULL. */
86415 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
86419 p = sqlite3FindTable(pParse->db, zName, zDbase);
86423 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
86425 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
86427 pParse->checkSchema = 1;
86442 Parse *pParse,
86449 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
86450 zDb = pParse->db->aDb[iDb].zName;
86454 return sqlite3LocateTable(pParse, isView, p->zName, zDb);
86814 Parse *pParse, /* Parsing and code generating context */
86820 sqlite3 *db = pParse->db;
86824 sqlite3ErrorMsg(pParse, "corrupt database");
86825 pParse->nErr++;
86831 sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
86832 pParse->nErr++;
86850 SQLITE_PRIVATE int sqlite3CheckObjectName(Parse *pParse, const char *zName){
86851 if( !pParse->db->init.busy && pParse->nested==0
86852 && (pParse->db->flags & SQLITE_WriteSchema)==0
86854 sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s", zName);
86891 ** The new table record is initialized and put in pParse->pNewTable.
86898 Parse *pParse, /* Parser context */
86908 sqlite3 *db = pParse->db;
86930 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
86935 sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
86940 pParse->sNameToken = *pName;
86943 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
86952 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
86968 if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){
86983 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
86989 sqlite3ErrorMsg(pParse, "table %T already exists", pName);
86992 sqlite3CodeVerifySchema(pParse, iDb);
86997 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
87005 pParse->rc = SQLITE_NOMEM;
87006 pParse->nErr++;
87014 assert( pParse->pNewTable==0 );
87015 pParse->pNewTable = pTable;
87022 if( !pParse->nested && strcmp(zName, "sqlite_sequence")==0 ){
87036 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
87040 sqlite3BeginWriteOperation(pParse, 0, iDb);
87051 reg1 = pParse->regRowid = ++pParse->nMem;
87052 reg2 = pParse->regRoot = ++pParse->nMem;
87053 reg3 = ++pParse->nMem;
87069 ** The rowid for the new entry is left in register pParse->regRowid.
87070 ** The root page number of the new table is left in reg pParse->regRoot.
87080 pParse->addrCrTab = sqlite3VdbeAddOp2(v, OP_CreateTable, iDb, reg2);
87082 sqlite3OpenMasterTable(pParse, iDb);
87120 SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token *pName){
87125 sqlite3 *db = pParse->db;
87126 if( (p = pParse->pNewTable)==0 ) return;
87129 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
87137 sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
87170 SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){
87172 p = pParse->pNewTable;
87273 SQLITE_PRIVATE void sqlite3AddColumnType(Parse *pParse, Token *pType){
87277 p = pParse->pNewTable;
87281 pCol->zType = sqlite3NameFromToken(pParse->db, pType);
87295 SQLITE_PRIVATE void sqlite3AddDefaultValue(Parse *pParse, ExprSpan *pSpan){
87298 sqlite3 *db = pParse->db;
87299 p = pParse->pNewTable;
87303 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
87339 Parse *pParse, /* Parsing context */
87345 Table *pTab = pParse->pNewTable;
87351 sqlite3ErrorMsg(pParse,
87381 if( pList ) pParse->iPkSortOrder = pList->a[0].sortOrder;
87384 sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
87388 Vdbe *v = pParse->pVdbe;
87390 if( v ) pParse->addrSkipPK = sqlite3VdbeAddOp0(v, OP_Noop);
87391 p = sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
87395 if( v ) sqlite3VdbeJumpHere(v, pParse->addrSkipPK);
87401 sqlite3ExprListDelete(pParse->db, pList);
87409 Parse *pParse, /* Parsing context */
87413 Table *pTab = pParse->pNewTable;
87414 sqlite3 *db = pParse->db;
87418 pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
87419 if( pParse->constraintName.n ){
87420 sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
87425 sqlite3ExprDelete(pParse->db, pCheckExpr);
87433 SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){
87439 if( (p = pParse->pNewTable)==0 ) return;
87441 db = pParse->db;
87445 if( sqlite3LocateCollSeq(pParse, zColl) ){
87477 ** pParse.
87485 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
87486 sqlite3 *db = pParse->db;
87493 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
87516 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
87517 int r1 = sqlite3GetTempReg(pParse);
87518 sqlite3 *db = pParse->db;
87519 Vdbe *v = pParse->pVdbe;
87523 sqlite3ReleaseTempReg(pParse, r1);
87731 static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
87736 sqlite3 *db = pParse->db;
87737 Vdbe *v = pParse->pVdbe;
87743 if( pParse->addrCrTab ){
87745 sqlite3VdbeGetOp(v, pParse->addrCrTab)->opcode = OP_CreateIndex;
87751 if( pParse->addrSkipPK ){
87753 sqlite3VdbeGetOp(v, pParse->addrSkipPK)->opcode = OP_Goto;
87761 pList = sqlite3ExprListAppend(pParse, 0, 0);
87763 pList->a[0].zName = sqlite3DbStrDup(pParse->db,
87765 pList->a[0].sortOrder = pParse->iPkSortOrder;
87766 assert( pParse->pNewTable==pTab );
87767 pPk = sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0);
87853 Parse *pParse, /* Parse context */
87860 sqlite3 *db = pParse->db; /* The database connection */
87867 p = pParse->pNewTable;
87885 sqlite3ErrorMsg(pParse,
87890 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
87893 convertToWithoutRowidTable(pParse, p);
87903 sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck);
87926 v = sqlite3GetVdbe(pParse);
87948 ** new table is in register pParse->regRoot.
87963 assert(pParse->nTab==1);
87964 sqlite3VdbeAddOp3(v, OP_OpenWrite, 1, pParse->regRoot, iDb);
87966 pParse->nTab = 2;
87968 sqlite3Select(pParse, pSelect, &dest);
87970 if( pParse->nErr==0 ){
87971 pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect);
87986 Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd;
87987 n = (int)(pEnd2->z - pParse->sNameToken.z);
87990 "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
87998 sqlite3NestedParse(pParse,
88006 pParse->regRoot,
88008 pParse->regRowid
88011 sqlite3ChangeCookie(pParse, iDb);
88021 sqlite3NestedParse(pParse,
88048 pParse->pNewTable = 0;
88053 const char *zName = (const char *)pParse->sNameToken.z;
88071 Parse *pParse, /* The parsing context */
88086 sqlite3 *db = pParse->db;
88088 if( pParse->nVar>0 ){
88089 sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
88093 sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
88094 p = pParse->pNewTable;
88095 if( p==0 || pParse->nErr ){
88099 sqlite3TwoPartName(pParse, pName1, pName2, &pName);
88101 sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
88118 sqlite3ViewGetColumnNames(pParse, p);
88124 pParse->sLastToken;
88136 sqlite3EndTable(pParse, 0, &sEnd, 0, 0);
88145 ** of errors. If an error is seen leave an error message in pParse->zErrMsg.
88147 SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
88152 sqlite3 *db = pParse->db; /* Database connection for malloc errors */
88158 if( sqlite3VtabCallConnect(pParse, pTable) ){
88186 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
88202 n = pParse->nTab;
88203 sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
88209 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
88212 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
88215 pParse->nTab = n;
88308 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
88309 Vdbe *v = sqlite3GetVdbe(pParse);
88310 int r1 = sqlite3GetTempReg(pParse);
88312 sqlite3MayAbort(pParse);
88323 sqlite3NestedParse(pParse,
88325 pParse->db->aDb[iDb].zName, SCHEMA_TABLE(iDb), iTable, r1, r1);
88327 sqlite3ReleaseTempReg(pParse, r1);
88336 static void destroyTable(Parse *pParse, Table *pTab){
88339 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
88340 destroyRootPage(pParse, pTab->tnum, iDb);
88342 destroyRootPage(pParse, pIdx->tnum, iDb);
88381 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
88382 assert( iDb>=0 && iDb<pParse->db->nDb );
88383 destroyRootPage(pParse, iLargest, iDb);
88395 Parse *pParse, /* The parsing context */
88401 const char *zDbName = pParse->db->aDb[iDb].zName;
88405 if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
88406 sqlite3NestedParse(pParse,
88417 SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
88419 sqlite3 *db = pParse->db;
88423 v = sqlite3GetVdbe(pParse);
88425 sqlite3BeginWriteOperation(pParse, 1, iDb);
88437 pTrigger = sqlite3TriggerList(pParse, pTab);
88441 sqlite3DropTriggerPtr(pParse, pTrigger);
88452 sqlite3NestedParse(pParse,
88466 sqlite3NestedParse(pParse,
88470 destroyTable(pParse, pTab);
88480 sqlite3ChangeCookie(pParse, iDb);
88488 SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
88491 sqlite3 *db = pParse->db;
88497 assert( pParse->nErr==0 );
88500 pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
88504 if( noErr ) sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
88513 if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
88522 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
88543 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
88546 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
88553 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
88562 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
88566 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
88574 v = sqlite3GetVdbe(pParse);
88576 sqlite3BeginWriteOperation(pParse, 1, iDb);
88577 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
88578 sqlite3FkDropTable(pParse, pName, pTab);
88579 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
88597 ** under construction in the pParse->pNewTable field.
88603 Parse *pParse, /* Parsing context */
88609 sqlite3 *db = pParse->db;
88613 Table *p = pParse->pNewTable;
88625 sqlite3ErrorMsg(pParse, "foreign key on %s"
88632 sqlite3ErrorMsg(pParse,
88670 sqlite3ErrorMsg(pParse,
88723 SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
88727 if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return;
88744 static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
88746 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
88747 int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
88756 sqlite3 *db = pParse->db; /* The database connection */
88760 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
88767 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
88769 v = sqlite3GetVdbe(pParse);
88776 pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
88779 iSorter = pParse->nTab++;
88785 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
88787 regRecord = sqlite3GetTempReg(pParse);
88789 sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
88791 sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel);
88800 assert( pKey!=0 || db->mallocFailed || pParse->nErr );
88807 sqlite3UniqueConstraint(pParse, OE_Abort, pIndex);
88814 sqlite3ReleaseTempReg(pParse, regRecord);
88862 ** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
88863 ** as the table to be indexed. pParse->pNewTable is a table that is
88875 Parse *pParse, /* All information about this parse */
88878 SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
88894 sqlite3 *db = pParse->db;
88905 assert( pParse->nErr==0 ); /* Never called with prior errors */
88909 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
88923 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
88933 pTab = sqlite3SrcListLookup(pParse, pTblName);
88940 sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
88946 pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
88950 sqlite3ErrorMsg(pParse,
88959 pTab = pParse->pNewTable;
88966 assert( pParse->nErr==0 );
88969 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
88974 sqlite3ErrorMsg(pParse, "views may not be indexed");
88980 sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
89002 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
89007 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
89013 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
89016 sqlite3CodeVerifySchema(pParse, iDb);
89035 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
89040 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
89051 pList = sqlite3ExprListAppend(pParse, 0, 0);
89053 pList->a[0].zName = sqlite3DbStrDup(pParse->db,
89091 sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
89124 sqlite3ErrorMsg(pParse, "table %s has no column named %s",
89126 pParse->checkSchema = 1;
89145 if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
89171 if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex);
89173 if( pTab==pParse->pNewTable ){
89221 sqlite3ErrorMsg(pParse,
89266 else if( pParse->nErr==0 && (HasRowid(pTab) || pTblName!=0) ){
89269 int iMem = ++pParse->nMem;
89271 v = sqlite3GetVdbe(pParse);
89277 sqlite3BeginWriteOperation(pParse, 1, iDb);
89284 int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n;
89297 sqlite3NestedParse(pParse,
89311 sqlite3RefillIndex(pParse, pIndex, iMem);
89312 sqlite3ChangeCookie(pParse, iDb);
89398 SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
89401 sqlite3 *db = pParse->db;
89404 assert( pParse->nErr==0 ); /* Never called with prior errors */
89409 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
89415 sqlite3ErrorMsg(pParse, "no such index: %S", pName, 0);
89417 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
89419 pParse->checkSchema = 1;
89423 sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
89434 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
89438 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
89445 v = sqlite3GetVdbe(pParse);
89447 sqlite3BeginWriteOperation(pParse, 1, iDb);
89448 sqlite3NestedParse(pParse,
89452 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
89453 sqlite3ChangeCookie(pParse, iDb);
89454 destroyRootPage(pParse, pIndex->tnum, iDb);
89693 SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
89696 assert(pList || pParse->db->mallocFailed );
89700 pItem->iCursor = pParse->nTab++;
89702 sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
89745 Parse *pParse, /* Parsing context */
89755 sqlite3 *db = pParse->db;
89757 sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
89788 SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
89798 pItem->zIndex = sqlite3NameFromToken(pParse->db, pIndexedBy);
89832 SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){
89837 assert( pParse!=0 );
89838 db = pParse->db;
89841 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
89844 v = sqlite3GetVdbe(pParse);
89858 SQLITE_PRIVATE void sqlite3CommitTransaction(Parse *pParse){
89861 assert( pParse!=0 );
89862 assert( pParse->db!=0 );
89863 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ){
89866 v = sqlite3GetVdbe(pParse);
89875 SQLITE_PRIVATE void sqlite3RollbackTransaction(Parse *pParse){
89878 assert( pParse!=0 );
89879 assert( pParse->db!=0 );
89880 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ){
89883 v = sqlite3GetVdbe(pParse);
89893 SQLITE_PRIVATE void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
89894 char *zName = sqlite3NameFromToken(pParse->db, pName);
89896 Vdbe *v = sqlite3GetVdbe(pParse);
89901 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
89902 sqlite3DbFree(pParse->db, zName);
89911 ** the number of errors. Leave any error messages in the pParse structure.
89913 SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *pParse){
89914 sqlite3 *db = pParse->db;
89915 if( db->aDb[1].pBt==0 && !pParse->explain ){
89927 sqlite3ErrorMsg(pParse, "unable to open a temporary database "
89929 pParse->rc = rc;
89948 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
89949 Parse *pToplevel = sqlite3ParseToplevel(pParse);
89969 SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
89970 sqlite3 *db = pParse->db;
89975 sqlite3CodeVerifySchema(pParse, i);
89993 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
89994 Parse *pToplevel = sqlite3ParseToplevel(pParse);
89995 sqlite3CodeVerifySchema(pParse, iDb);
90007 SQLITE_PRIVATE void sqlite3MultiWrite(Parse *pParse){
90008 Parse *pToplevel = sqlite3ParseToplevel(pParse);
90028 SQLITE_PRIVATE void sqlite3MayAbort(Parse *pParse){
90029 Parse *pToplevel = sqlite3ParseToplevel(pParse);
90039 Parse *pParse, /* Parsing context */
90046 Vdbe *v = sqlite3GetVdbe(pParse);
90049 sqlite3MayAbort(pParse);
90059 Parse *pParse, /* Parsing context */
90069 errMsg.db = pParse->db;
90078 sqlite3HaltConstraint(pParse,
90089 Parse *pParse, /* Parsing context */
90096 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
90100 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
90103 sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC,
90131 static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
90136 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
90137 sqlite3BeginWriteOperation(pParse, 0, iDb);
90138 sqlite3RefillIndex(pParse, pIndex, -1);
90150 static void reindexDatabases(Parse *pParse, char const *zColl){
90153 sqlite3 *db = pParse->db; /* The database connection */
90162 reindexTable(pParse, pTab, zColl);
90182 SQLITE_PRIVATE void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
90189 sqlite3 *db = pParse->db; /* The database connection */
90193 ** and code in pParse and return NULL. */
90194 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
90199 reindexDatabases(pParse, 0);
90204 zColl = sqlite3NameFromToken(pParse->db, pName1);
90208 reindexDatabases(pParse, zColl);
90214 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
90221 reindexTable(pParse, pTab, 0);
90228 sqlite3BeginWriteOperation(pParse, 0, iDb);
90229 sqlite3RefillIndex(pParse, pIndex, -1);
90232 sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
90246 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
90247 if( pParse->nErr ) return 0;
90249 if( pIdx->pKeyInfo && pIdx->pKeyInfo->db!=pParse->db ){
90260 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
90262 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
90270 sqlite3LocateCollSeq(pParse, zColl);
90273 if( pParse->nErr ){
90289 Parse *pParse, /* Parsing context */
90295 sqlite3 *db = pParse->db;
90301 zName = sqlite3NameFromToken(pParse->db, pName);
90306 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
90436 Parse *pParse, /* Parsing context */
90442 sqlite3 *db = pParse->db;
90460 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
90476 SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){
90479 sqlite3 *db = pParse->db;
90480 CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);
90863 SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
90867 pTab = sqlite3LocateTableItem(pParse, 0, pItem);
90868 sqlite3DeleteTable(pParse->db, pItem->pTab);
90873 if( sqlite3IndexedByLookup(pParse, pItem) ){
90884 SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, int viewOk){
90893 ** In either case leave an error message in pParse and return non-zero.
90896 && sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 )
90898 && (pParse->db->flags & SQLITE_WriteSchema)==0
90899 && pParse->nested==0 )
90901 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
90907 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
90922 Parse *pParse, /* Parsing context */
90930 sqlite3 *db = pParse->db;
90941 pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0);
90943 sqlite3Select(pParse, pSel, &dest);
90958 Parse *pParse, /* The parser context */
90976 sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType);
90998 pSelectRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0);
91000 pEList = sqlite3ExprListAppend(pParse, 0, pSelectRowid);
91005 pSelectSrc = sqlite3SrcListDup(pParse->db, pSrc, 0);
91007 sqlite3ExprListDelete(pParse->db, pEList);
91012 pSelect = sqlite3SelectNew(pParse,pEList,pSelectSrc,pWhere,0,0,
91017 pWhereRowid = sqlite3PExpr(pParse, TK_ROW, 0, 0, 0);
91019 pInClause = sqlite3PExpr(pParse, TK_IN, pWhereRowid, 0, 0);
91024 sqlite3ExprSetHeight(pParse, pInClause);
91029 sqlite3SelectDelete(pParse->db, pSelect);
91033 sqlite3ExprDelete(pParse->db, pWhere);
91034 sqlite3ExprListDelete(pParse->db, pOrderBy);
91035 sqlite3ExprDelete(pParse->db, pLimit);
91036 sqlite3ExprDelete(pParse->db, pOffset);
91050 Parse *pParse, /* The parser context */
91091 db = pParse->db;
91092 if( pParse->nErr || db->mallocFailed ){
91102 pTab = sqlite3SrcListLookup(pParse, pTabList);
91109 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
91122 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
91126 if( sqlite3IsReadOnly(pParse, pTab, (pTrigger?1:0)) ){
91132 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb);
91142 iTabCur = pTabList->a[0].iCursor = pParse->nTab++;
91144 pParse->nTab++;
91150 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
91155 v = sqlite3GetVdbe(pParse);
91159 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
91160 sqlite3BeginWriteOperation(pParse, 1, iDb);
91167 sqlite3MaterializeView(pParse, pTab, pWhere, iTabCur);
91175 sNC.pParse = pParse;
91185 memCnt = ++pParse->nMem;
91195 && 0==sqlite3FkRequired(pParse, pTab, 0, 0)
91198 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
91214 iRowSet = ++pParse->nMem;
91222 iPk = pParse->nMem+1;
91223 pParse->nMem += nPk;
91224 iEphCur = pParse->nTab++;
91226 sqlite3VdbeSetP4KeyInfo(pParse, pPk);
91232 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0,
91251 iKey = pParse->nMem + 1;
91252 iKey = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iTabCur, iKey, 0);
91253 if( iKey>pParse->nMem ) pParse->nMem = iKey;
91275 iKey = ++pParse->nMem;
91301 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, iTabCur, aToOpen,
91332 sqlite3VtabMakeWritable(pParse, pTab);
91335 sqlite3MayAbort(pParse);
91339 int count = (pParse->nested==0); /* True to count changes */
91340 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
91368 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
91369 sqlite3AutoincrementEnd(pParse);
91376 if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
91420 Parse *pParse, /* Parsing context */
91431 Vdbe *v = pParse->pVdbe; /* Vdbe */
91454 if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
91462 pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf
91464 mask |= sqlite3FkOldmask(pParse, pTab);
91465 iOld = pParse->nMem+1;
91466 pParse->nMem += (1 + pTab->nCol);
91481 sqlite3CodeRowTrigger(pParse, pTrigger,
91499 sqlite3FkCheck(pParse, pTab, iOld, 0, 0, 0);
91506 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, 0);
91516 sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0);
91519 sqlite3CodeRowTrigger(pParse, pTrigger,
91549 Parse *pParse, /* Parsing and code generating context */
91563 v = pParse->pVdbe;
91570 r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 1,
91574 sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel);
91611 Parse *pParse, /* Parsing context */
91620 Vdbe *v = pParse->pVdbe;
91629 pParse->iPartIdxTab = iDataCur;
91630 sqlite3ExprCachePush(pParse);
91631 sqlite3ExprIfFalse(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel,
91638 regBase = sqlite3GetTempRange(pParse, nCol);
91655 sqlite3ReleaseTempRange(pParse, regBase, nCol);
91664 SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel(Parse *pParse, int iLabel){
91666 sqlite3VdbeResolveLabel(pParse->pVdbe, iLabel);
91667 sqlite3ExprCachePop(pParse);
93600 ** into pParse. If an OOM error occurs, non-zero is returned and the
93601 ** pParse->db->mallocFailed flag is set.
93604 Parse *pParse, /* Parse context to store any error in */
93618 assert( pParse );
93642 aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
93699 if( !pParse->disableTriggers ){
93700 sqlite3ErrorMsg(pParse,
93704 sqlite3DbFree(pParse->db, aiCol);
93739 Parse *pParse, /* Parse context */
93750 Vdbe *v = sqlite3GetVdbe(pParse); /* Vdbe to add code to */
93751 int iCur = pParse->nTab - 1; /* Cursor number to use */
93775 int regTemp = sqlite3GetTempReg(pParse);
93795 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
93800 sqlite3ReleaseTempReg(pParse, regTemp);
93803 int regTemp = sqlite3GetTempRange(pParse, nCol);
93804 int regRec = sqlite3GetTempReg(pParse);
93807 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
93842 sqlite3ReleaseTempReg(pParse, regRec);
93843 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
93847 if( !pFKey->isDeferred && !(pParse->db->flags & SQLITE_DeferFKs)
93848 && !pParse->pToplevel
93849 && !pParse->isMultiWrite
93856 sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY,
93860 sqlite3ParseToplevel(pParse)->mayAbort = 1;
93879 Parse *pParse, /* Parsing and code generating context */
93887 sqlite3 *db = pParse->db;
93897 pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl);
93954 Parse *pParse, /* Parse context */
93963 sqlite3 *db = pParse->db; /* Database handle */
93969 Vdbe *v = sqlite3GetVdbe(pParse);
93997 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
94002 pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight, 0);
94022 pLeft = exprTableRegister(pParse, pTab, regData, -1);
94024 pNe = sqlite3PExpr(pParse, TK_NE, pLeft, pRight, 0);
94031 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
94033 pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight, 0);
94036 pNe = sqlite3PExpr(pParse, TK_NOT, pAll, 0, 0);
94044 sNameContext.pParse = pParse;
94051 pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0, 0, 0, 0);
94053 sqlite3ParseToplevel(pParse)->mayAbort = 1;
94122 SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){
94123 sqlite3 *db = pParse->db;
94126 Vdbe *v = sqlite3GetVdbe(pParse);
94144 pParse->disableTriggers = 1;
94145 sqlite3DeleteFrom(pParse, sqlite3SrcListDup(db, pName, 0), 0);
94146 pParse->disableTriggers = 0;
94160 sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY,
94255 Parse *pParse, /* Parse context */
94262 sqlite3 *db = pParse->db; /* Database handle */
94266 int isIgnoreErrors = pParse->disableTriggers;
94297 ** schema items cannot be located, set an error in pParse and return
94299 if( pParse->disableTriggers ){
94302 pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb);
94304 if( !pTo || sqlite3FkLocateIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){
94315 Vdbe *v = sqlite3GetVdbe(pParse);
94344 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
94353 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
94354 pParse->nTab++;
94360 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1,isIgnore);
94365 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1,isIgnore);
94383 && !pParse->pToplevel && !pParse->isMultiWrite
94391 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){
94405 pItem->iCursor = pParse->nTab++;
94408 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1);
94417 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1);
94433 Parse *pParse, /* Parse context */
94437 if( pParse->db->flags&SQLITE_ForeignKeys ){
94445 sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0);
94470 Parse *pParse, /* Parse context */
94475 if( pParse->db->flags&SQLITE_ForeignKeys ){
94530 Parse *pParse, /* Parse context */
94535 sqlite3 *db = pParse->db; /* Database handle */
94556 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0;
94579 pEq = sqlite3PExpr(pParse, TK_EQ,
94580 sqlite3PExpr(pParse, TK_DOT,
94581 sqlite3PExpr(pParse, TK_ID, 0, 0, &tOld),
94582 sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol)
94584 sqlite3PExpr(pParse, TK_ID, 0, 0, &tFromCol)
94594 pEq = sqlite3PExpr(pParse, TK_IS,
94595 sqlite3PExpr(pParse, TK_DOT,
94596 sqlite3PExpr(pParse, TK_ID, 0, 0, &tOld),
94597 sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol),
94599 sqlite3PExpr(pParse, TK_DOT,
94600 sqlite3PExpr(pParse, TK_ID, 0, 0, &tNew),
94601 sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol),
94610 pNew = sqlite3PExpr(pParse, TK_DOT,
94611 sqlite3PExpr(pParse, TK_ID, 0, 0, &tNew),
94612 sqlite3PExpr(pParse, TK_ID, 0, 0, &tToCol)
94619 pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
94622 pNew = sqlite3PExpr(pParse, TK_NULL, 0, 0, 0);
94624 pList = sqlite3ExprListAppend(pParse, pList, pNew);
94625 sqlite3ExprListSetName(pParse, pList, &tFromCol, 0);
94643 pSelect = sqlite3SelectNew(pParse,
94644 sqlite3ExprListAppend(pParse, 0, pRaise),
94671 pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0, 0);
94716 Parse *pParse, /* Parse context */
94727 if( pParse->db->flags&SQLITE_ForeignKeys ){
94731 Trigger *pAct = fkActionTrigger(pParse, pTab, pFKey, pChanges);
94733 sqlite3CodeRowTriggerDirect(pParse, pAct, pTab, regOld, OE_Abort, 0);
94812 Parse *pParse, /* Generate code into this VDBE */
94820 v = sqlite3GetVdbe(pParse);
94822 sqlite3TableLock(pParse, iDb, pTab->tnum,
94832 sqlite3VdbeSetP4KeyInfo(pParse, pPk);
94996 Parse *pParse, /* Parsing context */
95002 Parse *pToplevel = sqlite3ParseToplevel(pParse);
95008 pInfo = sqlite3DbMallocRaw(pParse->db, sizeof(*pInfo));
95027 SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){
95029 sqlite3 *db = pParse->db; /* The database connection */
95033 Vdbe *v = pParse->pVdbe; /* VDBE under construction */
95037 assert( pParse->pTriggerTab==0 );
95038 assert( pParse==sqlite3ParseToplevel(pParse) );
95041 for(p = pParse->pAinc; p; p = p->pNext){
95045 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
95070 static void autoIncStep(Parse *pParse, int memId, int regRowid){
95072 sqlite3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid);
95083 SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){
95085 Vdbe *v = pParse->pVdbe;
95086 sqlite3 *db = pParse->db;
95089 for(p = pParse->pAinc; p; p = p->pNext){
95095 iRec = sqlite3GetTempReg(pParse);
95097 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
95105 sqlite3ReleaseTempReg(pParse, iRec);
95120 Parse *pParse, /* Parser context */
95222 Parse *pParse, /* Parser context */
95268 db = pParse->db;
95270 if( pParse->nErr || db->mallocFailed ){
95290 pTab = sqlite3SrcListLookup(pParse, pTabList);
95298 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){
95307 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
95323 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
95329 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
95335 v = sqlite3GetVdbe(pParse);
95337 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
95338 sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
95350 if( pColumn==0 && xferOptimization(pParse, pTab, pSelect, onError, iDb) ){
95360 regAutoinc = autoIncBegin(pParse, iDb, pTab);
95365 regRowid = regIns = pParse->nMem+1;
95366 pParse->nMem += pTab->nCol + 1;
95369 pParse->nMem++;
95404 sqlite3ErrorMsg(pParse, "table %S has no column named %s",
95406 pParse->checkSchema = 1;
95424 regYield = ++pParse->nMem;
95430 rc = sqlite3Select(pParse, pSelect, &dest);
95432 assert( pParse->nErr==0 || rc );
95448 if( pTrigger || readsTable(pParse, iDb, pTab) ){
95467 srcTab = pParse->nTab++;
95468 regRec = sqlite3GetTempReg(pParse);
95469 regTempRowid = sqlite3GetTempReg(pParse);
95477 sqlite3ReleaseTempReg(pParse, regRec);
95478 sqlite3ReleaseTempReg(pParse, regTempRowid);
95486 sNC.pParse = pParse;
95514 sqlite3ErrorMsg(pParse,
95520 sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
95527 regRowCount = ++pParse->nMem;
95534 nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, -1, 0,
95541 aRegIdx[i] = ++pParse->nMem;
95575 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
95592 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
95616 sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regCols+i+1);
95621 sqlite3ExprCodeAndCache(pParse, pList->a[j].pExpr, regCols+i+1);
95635 sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_BEFORE,
95638 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
95656 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
95687 autoIncStep(pParse, regAutoinc, regRowid);
95718 sqlite3ExprCodeFactorable(pParse, pTab->aCol[i].pDflt, iRegStore);
95726 sqlite3ExprCode(pParse, pList->a[j].pExpr, iRegStore);
95736 sqlite3VtabMakeWritable(pParse, pTab);
95739 sqlite3MayAbort(pParse);
95744 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
95747 sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0);
95748 sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
95761 sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_AFTER,
95791 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
95792 sqlite3AutoincrementEnd(pParse);
95800 if( (db->flags&SQLITE_CountRows) && !pParse->nested && !pParse->pTriggerTab ){
95906 ** Or if overrideError==OE_Default, then the pParse->onError parameter
95907 ** is used. Or if pParse->onError==OE_Default then the onError value
95911 Parse *pParse, /* The parser context */
95941 db = pParse->db;
95942 v = sqlite3GetVdbe(pParse);
95983 sqlite3MayAbort(pParse);
96003 sqlite3ExprCode(pParse, pTab->aCol[i].pDflt, regNewData+1+i);
96015 pParse->ckBase = regNewData+1;
96019 sqlite3ExprIfTrue(pParse, pCheck->a[i].pExpr, allOk, SQLITE_JUMPIFNULL);
96026 sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_CHECK,
96086 sqlite3RowidConstraint(pParse, onError, pTab);
96114 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
96116 if( pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0) ){
96117 sqlite3MultiWrite(pParse);
96118 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
96121 sqlite3MultiWrite(pParse);
96122 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, 0);
96164 pParse->ckBase = regNewData+1;
96165 sqlite3ExprIfFalse(pParse, pIdx->pPartIdxWhere, addrUniqueOk,
96167 pParse->ckBase = 0;
96173 regIdx = sqlite3GetTempRange(pParse, pIdx->nColumn);
96189 sqlite3ExprCacheAffinityChange(pParse, regIdx, pIdx->nColumn);
96203 sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn);
96218 regR = (pIdx==pPk) ? regIdx : sqlite3GetTempRange(pParse, nPkField);
96254 char *p4 = (char*)sqlite3LocateCollSeq(pParse, pPk->azColl[i]);
96278 sqlite3UniqueConstraint(pParse, onError, pIdx);
96288 sqlite3MultiWrite(pParse);
96290 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
96292 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
96299 sqlite3ReleaseTempRange(pParse, regIdx, pIdx->nColumn);
96300 if( regR!=regIdx ) sqlite3ReleaseTempRange(pParse, regR, nPkField);
96321 Parse *pParse, /* The parser context */
96339 v = sqlite3GetVdbe(pParse);
96353 assert( pParse->nested==0 );
96360 regRec = sqlite3GetTempReg(pParse);
96363 sqlite3ExprCacheAffinityChange(pParse, regData, pTab->nCol);
96364 if( pParse->nested ){
96377 if( !pParse->nested ){
96402 Parse *pParse, /* Parsing context */
96423 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
96424 v = sqlite3GetVdbe(pParse);
96426 if( iBase<0 ) iBase = pParse->nTab;
96430 sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
96432 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
96443 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
96447 if( iBase>pParse->nTab ) pParse->nTab = iBase;
96544 Parse *pParse, /* Parser context */
96568 if( pParse->pWith || pSelect->pWith ){
96574 if( sqlite3TriggerList(pParse, pDest) ){
96629 pSrc = sqlite3LocateTableItem(pParse, 0, pItem);
96697 if( (pParse->db->flags & SQLITE_ForeignKeys)!=0 && pDest->pFKey!=0 ){
96701 if( (pParse->db->flags & SQLITE_CountRows)!=0 ){
96712 iDbSrc = sqlite3SchemaToIndex(pParse->db, pSrc->pSchema);
96713 v = sqlite3GetVdbe(pParse);
96714 sqlite3CodeVerifySchema(pParse, iDbSrc);
96715 iSrc = pParse->nTab++;
96716 iDest = pParse->nTab++;
96717 regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
96718 regData = sqlite3GetTempReg(pParse);
96719 regRowid = sqlite3GetTempReg(pParse);
96720 sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
96745 sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
96751 sqlite3RowidConstraint(pParse, onError, pDest);
96753 autoIncStep(pParse, regAutoinc, regRowid);
96768 sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
96769 sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
96777 sqlite3VdbeSetP4KeyInfo(pParse, pSrcIdx);
96780 sqlite3VdbeSetP4KeyInfo(pParse, pDestIdx);
96792 sqlite3ReleaseTempReg(pParse, regRowid);
96793 sqlite3ReleaseTempReg(pParse, regData);
98768 static int invalidateTempStorage(Parse *pParse){
98769 sqlite3 *db = pParse->db;
98772 sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "
98790 static int changeTempStorage(Parse *pParse, const char *zStorageType){
98792 sqlite3 *db = pParse->db;
98794 if( invalidateTempStorage( pParse ) != SQLITE_OK ){
98805 static void returnSingleInt(Parse *pParse, const char *zLabel, i64 value){
98806 Vdbe *v = sqlite3GetVdbe(pParse);
98807 int mem = ++pParse->nMem;
98808 i64 *pI64 = sqlite3DbMallocRaw(pParse->db, sizeof(value));
98907 Parse *pParse,
98921 sqlite3 *db = pParse->db; /* The database connection */
98923 Vdbe *v = sqlite3GetVdbe(pParse); /* Prepared statement */
98927 pParse->nMem = 2;
98931 iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
98938 if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
98952 if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
98968 int mem = ++pParse->nMem;
98979 sqlite3ErrorMsg(pParse, "%s", aFcntl[0]);
98982 pParse->nErr++;
98983 pParse->rc = rc;
99004 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
99045 pParse->nMem += 2;
99052 sqlite3BeginWriteOperation(pParse, 0, iDb);
99078 returnSingleInt(pParse, "page_size", size);
99113 returnSingleInt(pParse, "secure_delete", b);
99136 sqlite3CodeVerifySchema(pParse, iDb);
99137 iReg = ++pParse->nMem;
99256 returnSingleInt(pParse, "journal_size_limit", iLimit);
99274 returnSingleInt(pParse, "auto_vacuum", sqlite3BtreeGetAutoVacuum(pBt));
99325 sqlite3BeginWriteOperation(pParse, 0, iDb);
99351 returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);
99396 returnSingleInt(pParse, "mmap_size", sz);
99398 pParse->nErr++;
99399 pParse->rc = rc;
99417 returnSingleInt(pParse, "temp_store", db->temp_store);
99419 changeTempStorage(pParse, zRight);
99449 sqlite3ErrorMsg(pParse, "not a writable directory");
99457 invalidateTempStorage(pParse);
99499 sqlite3ErrorMsg(pParse, "not a writable directory");
99551 sqlite3ErrorMsg(pParse, "failed to set lock proxy file");
99570 returnSingleInt(pParse, "synchronous", pDb->safety_level-1);
99573 sqlite3ErrorMsg(pParse,
99587 returnSingleInt(pParse, aPragmaNames[mid].zName,
99637 pParse->nMem = 6;
99638 sqlite3CodeVerifySchema(pParse, iDb);
99645 sqlite3ViewGetColumnNames(pParse, pTab);
99678 v = sqlite3GetVdbe(pParse);
99680 pParse->nMem = 4;
99681 sqlite3CodeVerifySchema(pParse, iDb);
99715 pParse->nMem = 3;
99716 sqlite3CodeVerifySchema(pParse, iDb);
99738 v = sqlite3GetVdbe(pParse);
99740 pParse->nMem = 3;
99741 sqlite3CodeVerifySchema(pParse, iDb);
99758 pParse->nMem = 3;
99778 pParse->nMem = 2;
99797 v = sqlite3GetVdbe(pParse);
99802 pParse->nMem = 8;
99803 sqlite3CodeVerifySchema(pParse, iDb);
99856 regResult = pParse->nMem+1;
99857 pParse->nMem += 4;
99858 regKey = ++pParse->nMem;
99859 regRow = ++pParse->nMem;
99860 v = sqlite3GetVdbe(pParse);
99866 sqlite3CodeVerifySchema(pParse, iDb);
99870 pTab = sqlite3LocateTable(pParse, 0, zRight, zDb);
99877 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
99878 if( pTab->nCol+regRow>pParse->nMem ) pParse->nMem = pTab->nCol + regRow;
99879 sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead);
99886 sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
99887 x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, 0);
99890 sqlite3OpenTable(pParse, i, iDb, pParent, OP_OpenRead);
99893 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
99900 assert( pParse->nErr>0 || pFK==0 );
99902 if( pParse->nTab<i ) pParse->nTab = i;
99909 x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, &aiCols);
100019 pParse
100042 sqlite3CodeVerifySchema(pParse, i);
100071 pParse->nMem = MAX( pParse->nMem, cnt+8 );
100101 sqlite3ExprCacheClear(pParse);
100102 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead,
100108 pParse->nMem = MAX(pParse->nMem, 8+j);
100135 r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3,
100181 sqlite3ResolvePartIdxLabel(pParse, jmp3);
100252 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
100259 sqlite3VdbeChangeP4(v, -1, encnames[ENC(pParse->db)].zName, P4_STATIC);
100273 ENC(pParse->db) = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE;
100278 sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
100376 pParse->nMem = 1;
100403 pParse->nMem = 3;
100425 returnSingleInt(pParse, "wal_autocheckpoint",
100457 returnSingleInt(pParse, "timeout", db->busyTimeout);
100473 returnSingleInt(pParse, "soft_heap_limit", sqlite3_soft_heap_limit64(-1));
100487 pParse->nMem = 2;
100995 SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse){
100997 sqlite3 *db = pParse->db;
101000 rc = sqlite3Init(db, &pParse->zErrMsg);
101003 pParse->rc = rc;
101004 pParse->nErr++;
101012 ** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies
101013 ** make no changes to pParse->rc.
101015 static void schemaIsValid(Parse *pParse){
101016 sqlite3 *db = pParse->db;
101021 assert( pParse->checkSchema );
101047 pParse->rc = SQLITE_SCHEMA;
101090 ** Free all memory allocations in the pParse object
101092 SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){
101093 if( pParse ){
101094 sqlite3 *db = pParse->db;
101095 sqlite3DbFree(db, pParse->aLabel);
101096 sqlite3ExprListDelete(db, pParse->pConstExpr);
101112 Parse *pParse; /* Parsing context */
101118 pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
101119 if( pParse==0 ){
101123 pParse->pReprepare = pReprepare;
101167 pParse->db = db;
101168 pParse->nQueryLoop = 0; /* Logarithmic, so 0 really means 1 */
101181 sqlite3RunParser(pParse, zSqlCopy, &zErrMsg);
101183 pParse->zTail = &zSql[pParse->zTail-zSqlCopy];
101185 pParse->zTail = &zSql[nBytes];
101188 sqlite3RunParser(pParse, zSql, &zErrMsg);
101190 assert( 0==pParse->nQueryLoop );
101193 pParse->rc = SQLITE_NOMEM;
101195 if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK;
101196 if( pParse->checkSchema ){
101197 schemaIsValid(pParse);
101200 pParse->rc = SQLITE_NOMEM;
101203 *pzTail = pParse->zTail;
101205 rc = pParse->rc;
101208 if( rc==SQLITE_OK && pParse->pVdbe && pParse->explain ){
101214 if( pParse->explain==2 ){
101215 sqlite3VdbeSetNumCols(pParse->pVdbe, 4);
101219 sqlite3VdbeSetNumCols(pParse->pVdbe, 8);
101224 sqlite3VdbeSetColName(pParse->pVdbe, i-iFirst, COLNAME_NAME,
101231 Vdbe *pVdbe = pParse->pVdbe;
101232 sqlite3VdbeSetSql(pVdbe, zSql, (int)(pParse->zTail-zSql), saveSqlFlag);
101234 if( pParse->pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){
101235 sqlite3VdbeFinalize(pParse->pVdbe);
101238 *ppStmt = (sqlite3_stmt*)pParse->pVdbe;
101249 while( pParse->pTriggerPrg ){
101250 TriggerPrg *pT = pParse->pTriggerPrg;
101251 pParse->pTriggerPrg = pT->pNext;
101257 sqlite3ParserReset(pParse);
101258 sqlite3StackFree(db, pParse);
101529 Parse *pParse, /* Parsing context */
101542 sqlite3 *db = pParse->db;
101551 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ALL,0));
101572 assert( pNew->pSrc!=0 || pParse->nErr>0 );
101611 ** a join type, but put an error in the pParse structure.
101613 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
101658 sqlite3ErrorMsg(pParse, "unknown or unsupported join type: "
101663 sqlite3ErrorMsg(pParse,
101727 Parse *pParse, /* Parsing context */
101736 sqlite3 *db = pParse->db;
101749 pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2, 0);
101810 static int sqliteProcessJoin(Parse *pParse, Select *p){
101832 sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
101843 addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, j,
101852 sqlite3ErrorMsg(pParse, "cannot have both ON and USING "
101862 p->pWhere = sqlite3ExprAnd(pParse->db, p->pWhere, pRight->pOn);
101886 sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
101890 addWhereTerm(pParse, pSrc, iLeft, iLeftCol, i+1, iRightCol,
101900 Parse *pParse, /* Parsing context */
101911 Parse *pParse, /* Parser context */
101916 Vdbe *v = pParse->pVdbe;
101918 int regRecord = ++pParse->nMem;
101919 int regBase = pParse->nMem+1;
101923 pParse->nMem += nExpr+2; /* nExpr+2 registers allocated at regBase */
101924 sqlite3ExprCacheClear(pParse);
101925 sqlite3ExprCodeExprList(pParse, pSort->pOrderBy, regBase, 0);
101927 sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+1, 1);
101937 regPrevKey = pParse->nMem+1;
101938 pParse->nMem += pSort->nOBSat;
101943 if( pParse->db->mallocFailed ) return;
101948 pOp->p4.pKeyInfo = keyInfoFromExprList(pParse, pSort->pOrderBy, nOBSat, 1);
101952 pSort->regReturn = ++pParse->nMem;
102010 Parse *pParse, /* Parsing and code generating context */
102019 v = pParse->pVdbe;
102020 r1 = sqlite3GetTempReg(pParse);
102024 sqlite3ReleaseTempReg(pParse, r1);
102036 Parse *pParse, /* Parse context. */
102042 sqlite3ErrorMsg(pParse, "only a single result allowed for "
102061 Parse *pParse, /* The parser context */
102071 Vdbe *v = pParse->pVdbe;
102093 pDest->iSdst = pParse->nMem+1;
102094 pParse->nMem += nResultCol;
102095 }else if( pDest->iSdst+nResultCol > pParse->nMem ){
102101 pParse->nMem += nResultCol;
102114 sqlite3ExprCodeExprList(pParse, pEList, regResult,
102130 regPrev = pParse->nMem+1;
102131 pParse->nMem += nResultCol;
102147 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[i].pExpr);
102158 assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
102170 codeDistinct(pParse, pDistinct->tabTnct, iContinue, nResultCol, regResult);
102186 r1 = sqlite3GetTempReg(pParse);
102189 sqlite3ReleaseTempReg(pParse, r1);
102209 int r1 = sqlite3GetTempReg(pParse);
102227 pushOntoSorter(pParse, pSort, p, r1);
102229 int r2 = sqlite3GetTempReg(pParse);
102233 sqlite3ReleaseTempReg(pParse, r2);
102235 sqlite3ReleaseTempReg(pParse, r1);
102253 pushOntoSorter(pParse, pSort, p, regResult);
102255 int r1 = sqlite3GetTempReg(pParse);
102257 sqlite3ExprCacheAffinityChange(pParse, regResult, 1);
102259 sqlite3ReleaseTempReg(pParse, r1);
102279 pushOntoSorter(pParse, pSort, p, regResult);
102281 sqlite3ExprCodeMove(pParse, regResult, iParm, 1);
102293 int r1 = sqlite3GetTempReg(pParse);
102295 pushOntoSorter(pParse, pSort, p, r1);
102296 sqlite3ReleaseTempReg(pParse, r1);
102301 sqlite3ExprCacheAffinityChange(pParse, regResult, nResultCol);
102322 r1 = sqlite3GetTempReg(pParse);
102323 r2 = sqlite3GetTempRange(pParse, nKey+2);
102347 sqlite3ReleaseTempReg(pParse, r1);
102348 sqlite3ReleaseTempRange(pParse, r2, nKey+2);
102444 Parse *pParse, /* Parsing context */
102452 sqlite3 *db = pParse->db;
102461 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
102497 static void explainTempTable(Parse *pParse, const char *zUsage){
102498 if( pParse->explain==2 ){
102499 Vdbe *v = pParse->pVdbe;
102500 char *zMsg = sqlite3MPrintf(pParse->db, "USE TEMP B-TREE FOR %s", zUsage);
102501 sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
102536 Parse *pParse, /* Parse context */
102543 if( pParse->explain==2 ){
102544 Vdbe *v = pParse->pVdbe;
102546 pParse->db, "COMPOUND SUBQUERIES %d AND %d %s(%s)", iSub1, iSub2,
102549 sqlite3VdbeAddOp4(v, OP_Explain, pParse->iSelectId, 0, 0, zMsg, P4_DYNAMIC);
102564 Parse *pParse, /* Parsing context */
102570 Vdbe *v = pParse->pVdbe; /* The prepared statement */
102588 addrOnce = sqlite3CodeOnce(pParse); VdbeCoverage(v);
102591 regRow = sqlite3GetTempReg(pParse);
102593 pseudoTab = pParse->nTab++;
102597 regRowid = sqlite3GetTempReg(pParse);
102601 int regSortOut = ++pParse->nMem;
102602 int ptab2 = pParse->nTab++;
102632 sqlite3ExprCacheAffinityChange(pParse, regRow, 1);
102638 sqlite3ExprCodeMove(pParse, regRow, iParm, 1);
102657 sqlite3ExprCacheAffinityChange(pParse, pDest->iSdst, nColumn);
102664 sqlite3ReleaseTempReg(pParse, regRow);
102665 sqlite3ReleaseTempReg(pParse, regRowid);
102788 sNC.pParse = pNC->pParse;
102806 if( pNC->pParse ){
102807 pParse->db, pTab->pSchema);
102808 zOrigDb = pNC->pParse->db->aDb[iDb].zName;
102833 sNC.pParse = pNC->pParse;
102857 Parse *pParse, /* Parser context */
102862 Vdbe *v = pParse->pVdbe;
102866 sNC.pParse = pParse;
102897 Parse *pParse, /* Parser context */
102901 Vdbe *v = pParse->pVdbe;
102903 sqlite3 *db = pParse->db;
102908 if( pParse->explain ){
102913 if( pParse->colNamesSet || NEVER(v==0) || db->mallocFailed ) return;
102914 pParse->colNamesSet = 1;
102957 generateColumnTypes(pParse, pTabList, pEList);
102974 Parse *pParse, /* Parsing context */
102979 sqlite3 *db = pParse->db; /* Database connection */
103077 Parse *pParse, /* Parsing contexts */
103081 sqlite3 *db = pParse->db;
103103 pColl = sqlite3ExprCollSeq(pParse, p);
103115 SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect){
103117 sqlite3 *db = pParse->db;
103123 sqlite3SelectPrep(pParse, pSelect, 0);
103124 if( pParse->nErr ) return 0;
103137 selectColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
103138 selectAddColumnTypeAndCollation(pParse, pTab, pSelect);
103149 ** If an error occurs, return NULL and leave a message in pParse.
103151 SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse *pParse){
103152 Vdbe *v = pParse->pVdbe;
103154 v = pParse->pVdbe = sqlite3VdbeCreate(pParse);
103156 if( pParse->pToplevel==0
103157 && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst)
103159 pParse->okConstFactor = 1;
103190 static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
103203 sqlite3ExprCacheClear(pParse);
103206 p->iLimit = iLimit = ++pParse->nMem;
103207 v = sqlite3GetVdbe(pParse);
103218 sqlite3ExprCode(pParse, p->pLimit, iLimit);
103224 p->iOffset = iOffset = ++pParse->nMem;
103225 pParse->nMem++; /* Allocate an extra register for limit+offset */
103226 sqlite3ExprCode(pParse, p->pOffset, iOffset);
103250 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
103253 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
103259 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
103273 static KeyInfo *multiSelectOrderByKeyInfo(Parse *pParse, Select *p, int nExtra){
103276 sqlite3 *db = pParse->db;
103286 pColl = sqlite3ExprCollSeq(pParse, pTerm);
103288 pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1);
103291 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
103340 Parse *pParse, /* Parsing context */
103346 Vdbe *v = pParse->pVdbe; /* The prepared statement under construction */
103363 if( sqlite3AuthCheck(pParse, SQLITE_RECURSIVE, 0, 0, 0) ) return;
103367 computeLimitRegisters(pParse, p, addrBreak);
103387 iQueue = pParse->nTab++;
103390 iDistinct = pParse->nTab++;
103397 regCurrent = ++pParse->nMem;
103400 KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1);
103418 rc = sqlite3Select(pParse, pSetup, &destQueue);
103437 selectInnerLoop(pParse, p, p->pEList, iCurrent,
103449 sqlite3Select(pParse, p, &destQueue);
103458 sqlite3ExprListDelete(pParse->db, p->pOrderBy);
103468 Parse *pParse, /* Parsing context */
103506 Parse *pParse, /* Parsing context */
103526 db = pParse->db;
103530 sqlite3ErrorMsg(pParse,"ORDER BY clause should come after %s not before",
103536 sqlite3ErrorMsg(pParse,"LIMIT clause should come after %s not before",
103542 v = sqlite3GetVdbe(pParse);
103560 sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms");
103562 sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
103571 generateWithRecursiveQuery(pParse, p, &dest);
103578 return multiSelectOrderBy(pParse, p, pDest);
103592 explainSetInteger(iSub1, pParse->iNextSelectId);
103593 rc = sqlite3Select(pParse, pPrior, &dest);
103606 explainSetInteger(iSub2, pParse->iNextSelectId);
103607 rc = sqlite3Select(pParse, p, &dest);
103646 unionTab = pParse->nTab++;
103659 explainSetInteger(iSub1, pParse->iNextSelectId);
103660 rc = sqlite3Select(pParse, pPrior, &uniondest);
103679 explainSetInteger(iSub2, pParse->iNextSelectId);
103680 rc = sqlite3Select(pParse, p, &uniondest);
103705 generateColumnNames(pParse, 0, pFirst->pEList);
103709 computeLimitRegisters(pParse, p, iBreak);
103712 selectInnerLoop(pParse, p, p->pEList, unionTab,
103733 tab1 = pParse->nTab++;
103734 tab2 = pParse->nTab++;
103746 explainSetInteger(iSub1, pParse
103747 rc = sqlite3Select(pParse, pPrior, &intersectdest);
103763 explainSetInteger(iSub2, pParse->iNextSelectId);
103764 rc = sqlite3Select(pParse, p, &intersectdest);
103780 generateColumnNames(pParse, 0, pFirst->pEList);
103784 computeLimitRegisters(pParse, p, iBreak);
103786 r1 = sqlite3GetTempReg(pParse);
103789 sqlite3ReleaseTempReg(pParse, r1);
103790 selectInnerLoop(pParse, p, p->pEList, tab1,
103801 explainComposite(pParse, p->op, iSub1, iSub2, p->op!=TK_ALL);
103827 *apColl = multiSelectCollSeq(pParse, p, i);
103880 Parse *pParse, /* Parsing context */
103889 Vdbe *v = pParse->pVdbe;
103908 if( pParse->db->mallocFailed ) return 0;
103919 int r1 = sqlite3GetTempReg(pParse);
103920 int r2 = sqlite3GetTempReg(pParse);
103927 sqlite3ReleaseTempReg(pParse, r2);
103928 sqlite3ReleaseTempReg(pParse, r1);
103942 r1 = sqlite3GetTempReg(pParse);
103944 sqlite3ExprCacheAffinityChange(pParse, pIn->iSdst, 1);
103946 sqlite3ReleaseTempReg(pParse, r1);
103966 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, 1);
103977 pDest->iSdst = sqlite3GetTempRange(pParse, pIn->nSdst);
103980 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSdst, pDest->nSdst);
103996 sqlite3ExprCacheAffinityChange(pParse, pIn->iSdst, pIn->nSdst);
104102 Parse *pParse, /* Parsing context */
104147 db = pParse->db;
104148 v = pParse->pVdbe;
104179 pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
104200 pKeyMerge = multiSelectOrderByKeyInfo(pParse, p, 1);
104208 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
104219 regPrev = pParse->nMem+1;
104220 pParse->nMem += nExpr+1;
104226 pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
104236 sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
104238 sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
104242 computeLimitRegisters(pParse, p, labelEnd);
104244 regLimitA = ++pParse->nMem;
104245 regLimitB = ++pParse->nMem;
104257 regAddrA = ++pParse->nMem;
104258 regAddrB = ++pParse->nMem;
104259 regOutA = ++pParse->nMem;
104260 regOutB = ++pParse->nMem;
104271 explainSetInteger(iSub1, pParse->iNextSelectId);
104272 sqlite3Select(pParse, pPrior, &destA);
104286 explainSetInteger(iSub2, pParse->iNextSelectId);
104287 sqlite3Select(pParse, p, &destB);
104296 addrOutA = generateOutputSubroutine(pParse,
104305 addrOutB = generateOutputSubroutine(pParse,
104393 generateColumnNames(pParse, 0, pFirst->pEList);
104406 explainComposite(pParse, p->op, iSub1, iSub2, 0);
104627 Parse *pParse, /* Parsing context */
104633 const char *zSavedAuthContext = pParse->zAuthContext;
104644 sqlite3 *db = pParse->db;
104764 pParse->zAuthContext = pSubitem->zName;
104765 TESTONLY(i =) sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0);
104767 pParse->zAuthContext = zSavedAuthContext;
104856 Parse *pToplevel = sqlite3ParseToplevel(pParse);
105085 ** SQLITE_ERROR and leave an error in pParse. Otherwise, populate
105088 SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){
105098 sqlite3ErrorMsg(pParse, "no such index: %s", zIndex, 0);
105099 pParse->checkSchema = 1;
105134 Parse *pParse;
105149 pParse = pWalker->pParse;
105150 db = pParse->db;
105154 pNewSrc = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&dummy,pNew,0,0);
105158 p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ALL, 0));
105216 SQLITE_PRIVATE void sqlite3WithPush(Parse *pParse, With *pWith, u8 bFree){
105217 assert( bFree==0 || pParse->pWith==0 );
105219 pWith->pOuter = pParse->pWith;
105220 pParse->pWith = pWith;
105221 pParse->bFreeWith = bFree;
105244 Parse *pParse = pWalker->pParse;
105245 sqlite3 *db = pParse->db;
105251 pCte = searchWith(pParse->pWith, pFrom, &pWith);
105258 With *pSavedWith; /* Initial value of pParse->pWith */
105261 ** recursive reference to CTE pCte. Leave an error in pParse and return
105265 sqlite3ErrorMsg(pParse, pCte->zErr, pCte->zName);
105304 pParse, "multiple references to recursive table: %s", pCte->zName
105311 pSavedWith = pParse->pWith;
105312 pParse->pWith = pWith;
105319 sqlite3ErrorMsg(pParse, "table %s has %d values for %d columns",
105322 pParse->pWith = pSavedWith;
105328 selectColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
105338 pParse->pWith = pSavedWith;
105355 Parse *pParse = pWalker->pParse;
105358 assert( pParse->pWith==pWith );
105359 pParse->pWith = pWith->pOuter;
105391 Parse *pParse = pWalker->pParse;
105396 sqlite3 *db = pParse->db;
105409 sqlite3WithPush(pParse, findRightmost(p)->pWith, 0);
105414 sqlite3SrcListAssignCursors(pParse, pTabList);
105449 selectColumnsFromExprList(pParse, pSel->pEList, &pTab->nCol, &pTab->aCol);
105457 pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
105460 sqlite3ErrorMsg(pParse, "too many references to \"%s\": max 65535",
105469 if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
105478 if( sqlite3IndexedByLookup(pParse, pFrom) ){
105485 if( db->mallocFailed || sqliteProcessJoin(pParse, p) ){
105514 int flags = pParse->db->flags;
105532 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
105611 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
105614 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr, 0);
105623 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
105626 sqlite3ExprListSetName(pParse, pNew, &sColname, 0);
105644 sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
105646 sqlite3ErrorMsg(pParse, "no tables specified");
105656 sqlite3ErrorMsg(pParse, "too many columns in result set");
105685 ** If anything goes wrong, an error message is written into pParse.
105686 ** The calling function can detect the problem by looking at pParse->nErr
105687 ** and/or pParse->db->mallocFailed.
105689 static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){
105693 w.pParse = pParse;
105694 if( pParse->hasCompound ){
105719 Parse *pParse;
105727 pParse = pWalker->pParse;
105736 selectAddColumnTypeAndCollation(pParse, pTab, pSel);
105752 static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){
105758 w.pParse = pParse;
105777 Parse *pParse, /* The parser context */
105783 db = pParse->db;
105786 sqlite3SelectExpand(pParse, p);
105787 if( pParse->nErr || db->mallocFailed ) return;
105788 sqlite3ResolveSelectNames(pParse, p, pOuterNC);
105789 if( pParse->nErr || db->mallocFailed ) return;
105790 sqlite3SelectAddTypeInfo(pParse, p);
105801 static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
105802 Vdbe *v = pParse->pVdbe;
105826 sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
105830 KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->x.pList, 0, 0);
105842 static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
105843 Vdbe *v = pParse->pVdbe;
105858 static void updateAccumulator(Parse *pParse, AggInfo *pAggInfo){
105859 Vdbe *v = pParse->pVdbe;
105875 regAgg = sqlite3GetTempRange(pParse, nArg);
105876 sqlite3ExprCodeExprList(pParse, pList, regAgg, SQLITE_ECEL_DUP);
105884 codeDistinct(pParse, pF->iDistinct, addrNext, 1, regAgg);
105892 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
105895 pColl = pParse->db->pDfltColl;
105897 if( regHit==0 && pAggInfo->nAccumulator ) regHit = ++pParse->nMem;
105903 sqlite3ExprCacheAffinityChange(pParse, regAgg, nArg);
105904 sqlite3ReleaseTempRange(pParse, regAgg, nArg);
105907 sqlite3ExprCacheClear(pParse);
105924 sqlite3ExprCacheClear(pParse);
105926 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
105929 sqlite3ExprCacheClear(pParse);
105941 Parse *pParse, /* Parse context */
105945 if( pParse->explain==2 ){
105947 char *zEqp = sqlite3MPrintf(pParse->db, "SCAN TABLE %s%s%s",
105953 pParse->pVdbe, OP_Explain, pParse->iSelectId, 0, 0, zEqp, P4_DYNAMIC
105969 ** pParse->zErrMsg.
105975 Parse *pParse, /* The parser context */
105996 int iRestoreSelectId = pParse->iSelectId;
105997 pParse->iSelectId = pParse->iNextSelectId++;
106000 db = pParse->db;
106001 if( p==0 || db->mallocFailed || pParse->nErr ){
106004 if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
106022 sqlite3SelectPrep(pParse, p, 0);
106027 if( pParse->nErr || db->mallocFailed ){
106035 v = sqlite3GetVdbe(pParse);
106042 if( checkForMultiColumnSelectError(pParse, pDest, pEList->nExpr) ){
106078 pParse->nHeight += sqlite3SelectExprHeight(p);
106081 if( flattenSubquery(pParse, p, i, isAgg, isAggSub) ){
106095 pItem->regReturn = ++pParse->nMem;
106100 explainSetInteger(pItem->iSelectId, (u8)pParse->iNextSelectId);
106101 sqlite3Select(pParse, pSub, &dest);
106107 sqlite3ClearTempRegCache(pParse);
106118 pItem->regReturn = ++pParse->nMem;
106125 onceAddr = sqlite3CodeOnce(pParse); VdbeCoverage(v);
106131 explainSetInteger(pItem->iSelectId, (u8)pParse->iNextSelectId);
106132 sqlite3Select(pParse, pSub, &dest);
106138 sqlite3ClearTempRegCache(pParse);
106140 if( /*pParse->nErr ||*/ db->mallocFailed ){
106143 pParse->nHeight -= sqlite3SelectExprHeight(p);
106160 rc = multiSelect(pParse, p, pDest);
106161 explainSetInteger(pParse->iSelectId, iRestoreSelectId);
106203 pKeyInfo = keyInfoFromExprList(pParse, sSort.pOrderBy, 0, 0);
106204 sSort.iECursor = pParse->nTab++;
106223 computeLimitRegisters(pParse, p, iEnd);
106232 sDistinct.tabTnct = pParse->nTab++;
106235 (char*)keyInfoFromExprList(pParse, p->pEList,0,0),
106248 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, sSort.pOrderBy,
106273 selectInnerLoop(pParse, p, pEList, -1, &sSort, &sDistinct, pDest,
106335 sNC.pParse = pParse;
106338 sAggInfo.mnReg = pParse->nMem+1;
106353 sAggInfo.mxReg = pParse->nMem;
106375 sAggInfo.sortingIdx = pParse->nTab++;
106376 pKeyInfo = keyInfoFromExprList(pParse, pGroupBy, 0, 0);
106383 iUseFlag = ++pParse->nMem;
106384 iAbortFlag = ++pParse->nMem;
106385 regOutputRow = ++pParse->nMem;
106387 regReset = ++pParse->nMem;
106389 iAMem = pParse->nMem + 1;
106390 pParse->nMem += pGroupBy->nExpr;
106391 iBMem = pParse->nMem + 1;
106392 pParse->nMem += pGroupBy->nExpr;
106405 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, 0,
106426 explainTempTable(pParse,
106440 regBase = sqlite3GetTempRange(pParse, nCol);
106441 sqlite3ExprCacheClear(pParse);
106442 sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0);
106451 r2 = sqlite3ExprCodeGetColumn(pParse,
106459 regRecord = sqlite3GetTempReg(pParse);
106462 sqlite3ReleaseTempReg(pParse, regRecord);
106463 sqlite3ReleaseTempRange(pParse, regBase, nCol);
106465 sAggInfo.sortingIdxPTab = sortPTab = pParse->nTab++;
106466 sortOut = sqlite3GetTempReg(pParse);
106471 sqlite3ExprCacheClear(pParse);
106495 sqlite3ExprCacheClear(pParse);
106505 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
106522 sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
106534 updateAccumulator(pParse, &sAggInfo);
106573 finalizeAggFunctions(pParse, &sAggInfo);
106574 sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL);
106575 selectInnerLoop(pParse, p, p->pEList, -1, &sSort,
106584 resetAccumulator(pParse, &sAggInfo);
106606 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
106607 const int iCsr = pParse->nTab++; /* Cursor to scan b-tree */
106613 sqlite3CodeVerifySchema(pParse, iDb);
106614 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
106637 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest);
106647 explainSimpleCount(pParse, pTab, pBest);
106699 resetAccumulator(pParse, &sAggInfo);
106700 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMax,0,flag,0);
106705 updateAccumulator(pParse, &sAggInfo);
106713 finalizeAggFunctions(pParse, &sAggInfo);
106717 sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
106718 selectInnerLoop(pParse, p, p->pEList, -1, 0, 0,
106727 explainTempTable(pParse, "DISTINCT");
106734 explainTempTable(pParse, sSort.nOBSat>0 ? "RIGHT PART OF ORDER BY":"ORDER BY");
106735 generateSortTail(pParse, p, &sSort, pEList->nExpr, pDest);
106751 explainSetInteger(pParse->iSelectId, iRestoreSelectId);
106756 generateColumnNames(pParse, pTabList, pEList);
107105 SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
107106 Schema * const pTmpSchema = pParse->db->aDb[1].pSchema;
107109 if( pParse->disableTriggers ){
107115 assert( sqlite3SchemaMutexHeld(pParse->db, 0, pTmpSchema) );
107134 ** in pParse->pNewTrigger. After the trigger actions have been parsed, the
107139 Parse *pParse, /* The parse context of the CREATE TRIGGER statement */
107153 sqlite3 *db = pParse->db; /* The database connection */
107166 sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name");
107173 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
107200 pTab = sqlite3SrcListLookup(pParse, pTableName);
107209 sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName);
107213 pTab = sqlite3SrcListLookup(pParse, pTableName);
107230 sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables");
107237 if( !zName || SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
107244 sqlite3ErrorMsg(pParse, "trigger %T already exists", pName);
107247 sqlite3CodeVerifySchema(pParse, iDb);
107254 sqlite3ErrorMsg(pParse, "cannot create trigger on system table");
107255 pParse->nErr++;
107263 sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S",
107268 sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF"
107280 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
107283 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){
107310 assert( pParse->pNewTrigger==0 );
107311 pParse->pNewTrigger = pTrigger;
107318 if( !pParse->pNewTrigger ){
107321 assert( pParse->pNewTrigger==pTrigger );
107330 Parse *pParse, /* Parser context */
107334 Trigger *pTrig = pParse->pNewTrigger; /* Trigger being finished */
107336 sqlite3 *db = pParse->db; /* The database */
107341 pParse->pNewTrigger = 0;
107342 if( NEVER(pParse->nErr) || !pTrig ) goto triggerfinish_cleanup;
107344 iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
107352 sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken);
107367 v = sqlite3GetVdbe(pParse);
107369 sqlite3BeginWriteOperation(pParse, 0, iDb);
107371 sqlite3NestedParse(pParse,
107376 sqlite3ChangeCookie(pParse, iDb);
107400 assert( !pParse->pNewTrigger );
107545 SQLITE_PRIVATE void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){
107551 sqlite3 *db = pParse->db;
107554 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
107572 sqlite3ErrorMsg(pParse, "no such trigger: %S", pName, 0);
107574 sqlite3CodeVerifyNamedSchema(pParse, zDb);
107576 pParse->checkSchema = 1;
107579 sqlite3DropTriggerPtr(pParse, pTrigger);
107598 SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){
107601 sqlite3 *db = pParse->db;
107604 iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
107615 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
107616 sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
107625 if( (v = sqlite3GetVdbe(pParse))!=0 ){
107640 sqlite3BeginWriteOperation(pParse, 0, iDb);
107641 sqlite3OpenMasterTable(pParse, iDb);
107645 sqlite3ChangeCookie(pParse, iDb);
107648 if( pParse->nMem<3 ){
107649 pParse->nMem = 3;
107701 Parse *pParse, /* Parse context */
107711 if( (pParse->db->flags & SQLITE_EnableTrigger)!=0 ){
107712 pList = sqlite3TriggerList(pParse, pTab);
107737 Parse *pParse, /* The parsing context */
107743 pSrc = sqlite3SrcListAppend(pParse->db, 0, &pStep->target, 0);
107747 iDb = sqlite3SchemaToIndex(pParse->db, pStep->pTrig->pSchema);
107749 sqlite3 *db = pParse->db;
107750 assert( iDb<pParse->db->nDb );
107762 Parse *pParse, /* The parser context */
107767 Vdbe *v = pParse->pVdbe;
107768 sqlite3 *db = pParse->db;
107770 assert( pParse->pTriggerTab && pParse->pToplevel );
107787 pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf;
107788 assert( pParse->okConstFactor==0 );
107792 pParse,
107793 targetSrcList(pParse, pStep),
107796 pParse->eOrconf
107801 sqlite3Insert(pParse,
107802 targetSrcList(pParse, pStep),
107805 pParse->eOrconf
107810 sqlite3DeleteFrom(pParse,
107811 targetSrcList(pParse, pStep),
107820 sqlite3Select(pParse, pSelect, &sDest);
107872 Parse *pParse, /* Current parse context */
107877 Parse *pTop = sqlite3ParseToplevel(pParse);
107878 sqlite3 *db = pParse->db; /* Database handle */
107910 sNC.pParse = pSubParse;
107916 pSubParse->nQueryLoop = pParse->nQueryLoop;
107958 transferParseError(pParse, pSubParse);
107986 Parse *pParse, /* Current parse context */
107991 Parse *pRoot = sqlite3ParseToplevel(pParse);
108007 pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf);
108020 Parse *pParse, /* Parse context */
108027 Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */
108029 pPrg = getRowTrigger(pParse, p, pTab, orconf);
108030 assert( pPrg || pParse->nErr || pParse->db->mallocFailed );
108035 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
108037 sqlite3VdbeAddOp3(v, OP_Program, reg, ignoreJump, ++pParse->nMem);
108092 Parse *pParse, /* Parse context */
108116 || p->pSchema==pParse->db->aDb[1].pSchema );
108123 sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
108154 Parse *pParse, /* Parse context */
108172 pPrg = getRowTrigger(pParse, p, pTab, orconf);
108204 Parse *pParse, /* The parsing context */
108274 Parse *pParse, /* The parser context */
108329 db = pParse->db;
108330 if( pParse->nErr || db->mallocFailed ){
108337 pTab = sqlite3SrcListLookup(pParse, pTabList);
108339 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
108345 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
108358 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
108361 if( sqlite3IsReadOnly(pParse, pTab, tmask) ){
108370 pTabList->a[0].iCursor = iBaseCur = iDataCur = pParse->nTab++;
108375 iDataCur = pParse->nTab;
108378 pParse->nTab++;
108394 sNC.pParse = pParse;
108426 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName);
108427 pParse->checkSchema = 1;
108434 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
108455 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey);
108464 reg = ++pParse->nMem;
108469 reg = ++pParse->nMem;
108479 v = sqlite3GetVdbe(pParse);
108481 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
108482 sqlite3BeginWriteOperation(pParse, 1, iDb);
108487 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
108496 regRowSet = ++pParse->nMem;
108497 regOldRowid = regNewRowid = ++pParse->nMem;
108499 regOld = pParse->nMem + 1;
108500 pParse->nMem += pTab->nCol;
108503 regNewRowid = ++pParse->nMem;
108505 regNew = pParse->nMem + 1;
108506 pParse->nMem += pTab->nCol;
108510 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
108518 sqlite3MaterializeView(pParse, pTab, pWhere, iDataCur);
108534 pParse, pTabList, pWhere, 0, 0, WHERE_ONEPASS_DESIRED, iIdxCur
108556 iPk = pParse->nMem+1;
108557 pParse->nMem += nPk;
108558 regKey = ++pParse->nMem;
108559 iEph = pParse->nTab++;
108562 sqlite3VdbeSetP4KeyInfo(pParse, pPk);
108563 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0,
108585 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab ){
108586 regRowCount = ++pParse->nMem;
108612 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, iBaseCur, aToOpen,
108647 sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
108654 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
108655 oldmask |= sqlite3TriggerColmask(pParse,
108688 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
108697 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, regNew+i);
108718 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
108753 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
108758 sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);
108770 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx);
108781 sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);
108785 sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
108792 sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);
108798 if( (db->flags & SQLITE_CountRows) && !pParse->pTriggerTab){
108802 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
108831 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
108832 sqlite3AutoincrementEnd(pParse);
108840 if( (db->flags&SQLITE_CountRows) && !pParse->pTriggerTab && !pParse->nested ){
108885 Parse *pParse, /* The parsing context */
108894 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
108902 sqlite3 *db = pParse->db; /* Database connection */
108909 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, "_rowid_"));
108911 pEList = sqlite3ExprListAppend(pParse, pEList,
108921 pEList = sqlite3ExprListAppend(pParse, pEList, pExpr);
108923 pSelect = sqlite3SelectNew(pParse, pEList, pSrc, pWhere, 0, 0, 0, 0, 0, 0);
108929 ephemTab = pParse->nTab++;
108936 sqlite3Select(pParse, pSelect, &dest);
108939 iReg = ++pParse->nMem;
108940 pParse->nMem += pTab->nCol+1;
108947 sqlite3VtabMakeWritable(pParse, pTab);
108950 sqlite3MayAbort(pParse);
109063 SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse){
109064 Vdbe *v = sqlite3GetVdbe(pParse);
109635 Parse *pParse, /* Parsing context */
109645 sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, ifNotExists);
109646 pTable = pParse->pNewTable;
109650 db = pParse->db;
109659 pParse->sNameToken.n = (int)(&pModuleName->z[pModuleName->n] - pName1->z);
109668 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
109669 pTable->azModuleArg[0], pParse->db->aDb[iDb].zName);
109676 ** in pParse->zArg[] and appends it to the list of arguments on the
109677 ** virtual table currently under construction in pParse->pTable.
109679 static void addArgumentToVtab(Parse *pParse){
109680 if( pParse->sArg.z && pParse->pNewTable ){
109681 const char *z = (const char*)pParse->sArg.z;
109682 int n = pParse->sArg.n;
109683 sqlite3 *db = pParse->db;
109684 addModuleArgument(db, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));
109692 SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
109693 Table *pTab = pParse->pNewTable; /* The table being constructed */
109694 sqlite3 *db = pParse->db; /* The database connection */
109697 addArgumentToVtab(pParse);
109698 pParse->sArg.z = 0;
109715 pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n;
109717 zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
109723 ** The VM register number pParse->regRowid holds the rowid of an
109728 sqlite3NestedParse(pParse,
109736 pParse->regRowid
109739 v = sqlite3GetVdbe(pParse);
109740 sqlite3ChangeCookie(pParse, iDb);
109766 pParse->pNewTable = 0;
109774 SQLITE_PRIVATE void sqlite3VtabArgInit(Parse *pParse){
109775 addArgumentToVtab(pParse);
109776 pParse->sArg.z = 0;
109777 pParse->sArg.n = 0;
109784 SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse *pParse, Token *p){
109785 Token *pArg = &pParse->sArg;
109909 ** and an error left in pParse.
109913 SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
109914 sqlite3 *db = pParse->db;
109930 sqlite3ErrorMsg(pParse, "no such module: %s", zModule);
109936 sqlite3ErrorMsg(pParse, "%s", zErr);
110025 Parse *pParse;
110039 pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
110040 if( pParse==0 ){
110043 pParse->declareVtab = 1;
110044 pParse->db = db;
110045 pParse->nQueryLoop = 1;
110047 if( SQLITE_OK==sqlite3RunParser(pParse, zCreateTable, &zErr)
110048 && pParse->pNewTable
110050 && !pParse->pNewTable->pSelect
110051 && (pParse->pNewTable->tabFlags & TF_Virtual)==0
110054 pTab->aCol = pParse->pNewTable->aCol;
110055 pTab->nCol = pParse->pNewTable->nCol;
110056 pParse->pNewTable->nCol = 0;
110057 pParse->pNewTable->aCol = 0;
110065 pParse->declareVtab = 0;
110067 if( pParse->pVdbe ){
110068 sqlite3VdbeFinalize(pParse->pVdbe);
110070 sqlite3DeleteTable(db, pParse->pNewTable);
110071 sqlite3ParserReset(pParse);
110072 sqlite3StackFree(db, pParse);
110352 ** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]
110357 SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
110358 Parse *pToplevel = sqlite3ParseToplevel(pParse);
110843 Parse *pParse; /* Parsing and code generating context */
110860 int savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */
111064 sqlite3 *db = pWC->pWInfo->pParse->db;
111105 sqlite3 *db = pWC->pWInfo->pParse->db;
111278 static void exprCommute(Parse *pParse, Expr *pExpr){
111288 }else if( sqlite3ExprCollSeq(pParse, pExpr->pLeft)!=0 ){
111374 Parse *pParse = pWC->pWInfo->pParse;
111380 pColl = sqlite3BinaryCompareCollSeq(pParse,
111382 if( pColl==0 ) pColl = pParse->db->pDfltColl;
111531 Parse *pParse, /* Parsing and code generating context */
111543 sqlite3 *db = pParse->db; /* Database connection */
111568 Vdbe *pReprepare = pParse->pReprepare;
111574 sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
111591 Vdbe *v = pParse->pVdbe;
111600 int r1 = sqlite3GetTempReg(pParse);
111601 sqlite3ExprCodeTarget(pParse, pRight, r1);
111603 sqlite3ReleaseTempReg(pParse, r1);
111741 Parse *pParse = pWInfo->pParse; /* Parser context */
111742 sqlite3 *db = pParse->db; /* Database connection */
111940 pList = sqlite3ExprListAppend(pWInfo->pParse, pList, pDup);
111945 pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0, 0);
112000 Parse *pParse = pWInfo->pParse; /* Parsing context */
112001 sqlite3 *db = pParse->db; /* Database connection */
112073 exprCommute(pParse, pDup);
112109 pNewExpr = sqlite3PExpr(pParse, ops[i],
112146 && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
112177 pNewExpr1 = sqlite3PExpr(pParse, TK_GE,
112178 sqlite3ExprAddCollateToken(pParse,pNewExpr1,&sCollSeqName),
112185 pNewExpr2 = sqlite3PExpr(pParse, TK_LT,
112186 sqlite3ExprAddCollateToken(pParse,pNewExpr2,&sCollSeqName),
112220 pNewExpr = sqlite3PExpr(pParse, TK_MATCH,
112259 pNewExpr = sqlite3PExpr(pParse, TK_GT,
112261 sqlite3PExpr(pParse, TK_NULL, 0, 0, 0), 0);
112294 Parse *pParse, /* Parse context */
112309 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pList->a[i].pExpr);
112327 Parse *pParse, /* Parsing context */
112371 int iIdxCol = findIndexCol(pParse, pDistinct, iBase, pIdx, i);
112469 Parse *pParse, /* The parsing context */
112496 v = pParse->pVdbe;
112498 addrInit = sqlite3CodeOnce(pParse); VdbeCoverage(v);
112520 if( whereLoopResize(pParse->db, pLoop, nKeyCol+1) ) return;
112552 pIdx = sqlite3AllocateIndexObject(pParse->db, nKeyCol+1, 0, &zNotUsed);
112569 pColl = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight);
112599 pLevel->iIdxCur = pParse->nTab++;
112601 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
112606 regRecord = sqlite3GetTempReg(pParse);
112607 sqlite3GenerateIndexKey(pParse, pIdx, pLevel->iTabCur, regRecord, 0, 0, 0, 0);
112613 sqlite3ReleaseTempReg(pParse, regRecord);
112627 Parse *pParse,
112672 pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo)
112676 sqlite3ErrorMsg(pParse, "out of memory");
112736 ** If an error occurs, pParse is populated with an error message and a
112744 static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
112745 sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
112755 pParse->db->mallocFailed = 1;
112757 sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc));
112759 sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg);
112767 sqlite3ErrorMsg(pParse,
112772 return pParse->nErr;
112788 Parse *pParse, /* Database connection */
112802 UNUSED_PARAMETER( pParse );
112826 || pParse->db->mallocFailed );
112832 || pParse->db->mallocFailed );
112835 || pParse->db->mallocFailed );
112932 Parse *pParse, /* Parsing & code generating context */
112940 sqlite3 *db = pParse->db;
112952 pColl = sqlite3LocateCollSeq(pParse, p->azColl[nEq]);
112954 rc = sqlite3Stat4ValueFromExpr(pParse, pLower->pExpr->pRight, aff, &p1);
112958 rc = sqlite3Stat4ValueFromExpr(pParse, pUpper->pExpr->pRight, aff, &p2);
113045 Parse *pParse, /* Parsing & code generating context */
113061 && OptimizationEnabled(pParse->db, SQLITE_Stat3)
113100 whereKeyStats(pParse, p, pRec, 0, a);
113110 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, aff, nEq, &bOk);
113113 whereKeyStats(pParse, p, pRec, 0, a);
113125 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, aff, nEq, &bOk);
113128 whereKeyStats(pParse, p, pRec, 1, a);
113152 rc = whereRangeSkipScanEst(pParse, pLower, pUpper, pLoop, &bDone);
113157 UNUSED_PARAMETER(pParse);
113195 ** in the pParse structure.
113198 Parse *pParse, /* Parsing & code generating context */
113231 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, aff, nEq-1, &bOk);
113237 whereKeyStats(pParse, p, pRec, 0, a);
113260 ** in the pParse structure.
113263 Parse *pParse, /* Parsing & code generating context */
113279 rc = whereEqualScanEst(pParse, pBuilder, pList->a[i].pExpr, &nEst);
113344 static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){
113345 Vdbe *v = pParse->pVdbe;
113347 assert( pParse->db->mallocFailed );
113368 sqlite3ExprCacheAffinityChange(pParse, base, n);
113385 Parse *pParse, /* The parsing context */
113393 Vdbe *v = pParse->pVdbe;
113398 iReg = sqlite3ExprCodeTarget(pParse, pX->pRight, iTarget);
113419 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0);
113435 sqlite3DbReallocOrFree(pParse->db, pLevel->u.in.aInLoop,
113503 Parse *pParse, /* Parsing context */
113511 Vdbe *v = pParse->pVdbe; /* The vm under construction */
113530 regBase = pParse->nMem + 1;
113532 pParse->nMem += nReg;
113534 zAff = sqlite3DbStrDup(pParse->db, sqlite3IndexAffinityStr(v, pIdx));
113536 pParse->db->mallocFailed = 1;
113569 r1 = codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, regBase+j);
113572 sqlite3ReleaseTempReg(pParse, regBase);
113687 Parse *pParse, /* Parse context */
113695 if( pParse->explain==2 )
113699 Vdbe *v = pParse->pVdbe; /* VM being constructed */
113700 sqlite3 *db = pParse->db; /* Database handle */
113702 int iId = pParse->iSelectId; /* Select id (left-most output column) */
113789 Parse *pParse; /* Parsing context */
113798 pParse = pWInfo->pParse;
113799 v = pParse->pVdbe;
113801 db = pParse->db;
113830 pLevel->iLeftJoin = ++pParse->nMem;
113854 sqlite3ExprCachePush(pParse);
113855 iReg = sqlite3GetTempRange(pParse, nConstraint+2);
113862 codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, iTarget);
113865 sqlite3ExprCode(pParse, pTerm->pExpr->pRight, iTarget);
113883 sqlite3ReleaseTempRange(pParse, iReg, nConstraint+2);
113884 sqlite3ExprCachePop(pParse);
113902 iReleaseReg = ++pParse->nMem;
113903 iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, 0, bRev, iReleaseReg);
113904 if( iRowidReg!=iReleaseReg ) sqlite3ReleaseTempReg(pParse, iReleaseReg);
113909 sqlite3ExprCacheAffinityChange(pParse, iRowidReg, 1);
113910 sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
113956 r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &rTemp);
113963 sqlite3ExprCacheAffinityChange(pParse, r1, 1);
113964 sqlite3ReleaseTempReg(pParse, rTemp);
113978 memEndValue = ++pParse->nMem;
113979 sqlite3ExprCode(pParse, pX->pRight, memEndValue);
113993 iRowidReg = ++pParse->nMem;
113995 sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
114116 regBase = codeAllEqualityTerms(pParse,pLevel,bRev,nExtraReg,&zStartAff);
114144 sqlite3ExprCode(pParse, pRight, regBase+nEq);
114170 codeApplyAffinity(pParse, regBase, nConstraint - bSeekPastNull, zStartAff);
114188 sqlite3ExprCacheRemove(pParse, regBase+nEq, 1);
114189 sqlite3ExprCode(pParse, pRight, regBase+nEq);
114199 codeApplyAffinity(pParse, regBase+nEq, 1, &cEndAff);
114229 iRowidReg = ++pParse->nMem;
114231 sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
114235 iRowidReg = sqlite3GetTempRange(pParse, pPk->nKeyCol);
114311 int iCovCur = pParse->nTab++; /* Cursor used for index scans (if any) */
114313 int regReturn = ++pParse->nMem; /* Register used with OP_Gosub */
114368 regRowset = ++pParse->nMem;
114372 regRowset = pParse->nTab++;
114374 sqlite3VdbeSetP4KeyInfo(pParse, pPk);
114376 regRowid = ++pParse->nMem;
114408 pAndExpr = sqlite3PExpr(pParse, TK_AND, 0, pAndExpr, 0);
114429 pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0,
114431 assert( pSubWInfo || pParse->nErr || db->mallocFailed );
114435 pParse, pOrTab, &pSubWInfo->a[0], iLevel, pLevel->iFrom, 0
114446 r = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iCur, regRowid, 0);
114455 r = sqlite3GetTempRange(pParse, nPk);
114458 sqlite3ExprCodeGetColumn(pParse, pTab, iCol, iCur, r+iPk, 0);
114483 sqlite3ReleaseTempRange(pParse, r, nPk);
114586 sqlite3ExprIfFalse(pParse, pE, addrCont, SQLITE_JUMPIFNULL);
114618 sqlite3ExprIfFalse(pParse, pEAlt, addrCont, SQLITE_JUMPIFNULL);
114630 sqlite3ExprCacheClear(pParse);
114640 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
114708 Vdbe *v = pWInfo->pParse->pVdbe;
115004 sqlite3 *db = pWInfo->pParse->db;
115109 if( !OptimizationEnabled(pWC->pWInfo->pParse->db, SQLITE_AdjustOutEst) ){
115157 Parse *pParse = pWInfo->pParse; /* Parsing context */
115158 sqlite3 *db = pParse->db; /* Database connection malloc context */
115306 whereRangeScanEst(pParse, pBuilder, pBtm, pTop, pNew);
115330 rc = whereEqualScanEst(pParse, pBuilder, pExpr->pRight, &nOut);
115332 rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut);
115557 && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0
115645 && OptimizationEnabled(pWInfo->pParse->db, SQLITE_CoverIdxScan)
115690 Parse *pParse; /* The parsing context */
115709 pParse = pWInfo->pParse;
115710 db = pParse->db;
115716 pIdxInfo = allocateIndexInfo(pParse, pWC, pSrc, pBuilder->pOrderBy);
115774 rc = vtabBestIndex(pParse, pTab, pIdxInfo);
115791 sqlite3ErrorMsg(pParse, "%s.xBestIndex() malfunction", pTab->zName);
115968 sqlite3 *db = pWInfo->pParse->db;
116043 sqlite3 *db = pWInfo->pParse->db; /* Database connection */
116105 pColl = sqlite3ExprCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr);
116108 pColl = sqlite3ExprCollSeq(pWInfo->pParse, pTerm->pExpr);
116189 pColl = sqlite3ExprCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr);
116351 Parse *pParse; /* Parsing context */
116370 pParse = pWInfo->pParse;
116371 db = pParse->db;
116421 aFrom[0].nRow = MIN(pParse->nQueryLoop, 46); assert( 46==sqlite3LogEst(25) );
116618 sqlite3ErrorMsg(pParse, "no query solution");
116853 Parse *pParse, /* The parser context */
116864 Vdbe *v = pParse->pVdbe; /* The virtual database engine */
116876 db = pParse->db;
116895 sqlite3ErrorMsg(pParse, "at most %d tables in a join", BMS);
116922 pWInfo->pParse = pParse;
116928 pWInfo->savedNQueryLoop = pParse->nQueryLoop;
116951 sqlite3ExprIfFalse(pParse, sWLB.pWC->a[ii].pExpr, pWInfo->iBreak,
117007 if( isDistinctRedundant(pParse, pTabList, &pWInfo->sWC, pResultSet) ){
117023 Vdbe *v = pParse->pVdbe;
117064 if( pParse->nErr || NEVER(db->mallocFailed) ){
117126 pWInfo->pParse->nQueryLoop += pWInfo->nRowOut;
117174 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
117187 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
117216 iIndexCur = pParse->nTab++;
117223 sqlite3VdbeSetP4KeyInfo(pParse, pIx);
117227 if( iDb>=0 ) sqlite3CodeVerifySchema(pParse, iDb);
117242 constructAutomaticIndex(pParse, &pWInfo->sWC,
117247 explainOneScan(pParse, pTabList, pLevel, ii, pLevel->iFrom, wctrlFlags);
117260 pParse->nQueryLoop = pWInfo->savedNQueryLoop;
117271 Parse *pParse = pWInfo->pParse;
117272 Vdbe *v = pParse->pVdbe;
117277 sqlite3 *db = pParse->db;
117282 sqlite3ExprCacheClear(pParse);
117443 pParse->nQueryLoop = pWInfo->savedNQueryLoop;
117523 static void spanExpr(ExprSpan *pOut, Parse *pParse, int op, Token *pValue){
117524 pOut->pExpr = sqlite3PExpr(pParse, op, 0, 0, pValue);
117534 Parse *pParse, /* The parsing context. Errors accumulate here */
117539 pOut->pExpr = sqlite3PExpr(pParse, op, pLeft->pExpr, pRight->pExpr, 0);
117548 Parse *pParse, /* Parsing context to record errors */
117553 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
117560 static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
117561 sqlite3 *db = pParse->db;
117573 Parse *pParse, /* Parsing context to record errors */
117578 pOut->pExpr = sqlite3PExpr(pParse, op, pOperand->pExpr, 0, 0);
117658 #define sqlite3ParserARG_SDECL Parse *pParse;
117659 #define sqlite3ParserARG_PDECL ,Parse *pParse
117660 #define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse
117661 #define sqlite3ParserARG_STORE yypParser->pParse = pParse
118833 sqlite3SelectDelete(pParse->db, (yypminor->yy3));
118839 sqlite3ExprDelete(pParse->db, (yypminor->yy346).pExpr);
118854 sqlite3ExprListDelete(pParse->db, (yypminor->yy14));
118862 sqlite3SrcListDelete(pParse->db, (yypminor->yy65));
118868 sqlite3WithDelete(pParse->db, (yypminor->yy59));
118879 sqlite3ExprDelete(pParse->db, (yypminor->yy132));
118886 sqlite3IdListDelete(pParse->db, (yypminor->yy408));
118892 sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy473));
118897 sqlite3IdListDelete(pParse->db, (yypminor->yy378).b);
119085 sqlite3ErrorMsg(pParse, "parser stack overflow");
119524 { sqlite3BeginParse(pParse, 0); }
119527 { sqlite3BeginParse(pParse, 1); }
119530 { sqlite3BeginParse(pParse, 2); }
119533 { sqlite3FinishCoding(pParse); }
119536 {sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy328);}
119550 {sqlite3CommitTransaction(pParse);}
119553 {sqlite3RollbackTransaction(pParse);}
119557 sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &yymsp[0].minor.yy0);
119562 sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &yymsp[0].minor.yy0);
119567 sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
119572 sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy328,0,0,yymsp[-2].minor.yy328);
119577 pParse->db->lookaside.bEnabled = 0;
119604 sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy186,0);
119609 sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy3);
119610 sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy3);
119622 sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
119629 yygotominor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-2].minor.yy0.z) + pParse->sLastToken.n;
119634 sqlite3AddColumn(pParse,&yymsp[0].minor.yy0);
119636 pParse->constraintName.n = 0;
119661 {sqlite3AddColumnType(pParse,&yymsp[0].minor.yy0);}
119680 {pParse->constraintName = yymsp[0].minor.yy0;}
119684 {sqlite3AddDefaultValue(pParse,&yymsp[0].minor.yy346);}
119687 {sqlite3AddDefaultValue(pParse,&yymsp[-1].minor.yy346);}
119692 v.pExpr = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy346.pExpr, 0, 0);
119695 sqlite3AddDefaultValue(pParse,&v);
119701 spanExpr(&v, pParse, TK_STRING, &yymsp[0].minor.yy0);
119702 sqlite3AddDefaultValue(pParse,&v);
119706 {sqlite3AddNotNull(pParse, yymsp[0].minor.yy328);}
119709 {sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy328,yymsp[0].minor.yy328,yymsp[-2].minor.yy328);}
119712 {sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy328,0,0,0,0);}
119715 {sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy346.pExpr);}
119718 {sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy14,yymsp[0].minor.yy328);}
119721 {sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy328);}
119724 {sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
119770 {pParse->constraintName.n = 0;}
119773 {sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy14,yymsp[0].minor.yy328,yymsp[-2].minor.yy328,0);}
119776 {sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy14,yymsp[0].minor.yy328,0,0,0,0);}
119779 {sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy346.pExpr);}
119783 sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy14, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[-1].minor.yy328);
119784 sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy328);
119804 sqlite3DropTable(pParse, yymsp[0].minor.yy65, 0, yymsp[-1].minor.yy328);
119809 sqlite3CreateView(pParse, &yymsp[-7].minor.yy0, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, yymsp[0].minor.yy3, yymsp[-6].minor.yy328, yymsp[-4].minor.yy328);
119814 sqlite3DropTable(pParse, yymsp[0].minor.yy65, 1, yymsp[-1].minor.yy328);
119820 sqlite3Select(pParse, yymsp[0].minor.yy3, &dest);
119821 sqlite3ExplainBegin(pParse->pVdbe);
119822 sqlite3ExplainSelect(pParse->pVdbe, yymsp[0].minor.yy3);
119823 sqlite3ExplainFinish(pParse->pVdbe);
119824 sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy3);
119839 mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT];
119841 sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
119845 sqlite3WithDelete(pParse->db, yymsp[-1].minor.yy59);
119861 pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0);
119862 pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0,0);
119867 if( yymsp[-1].minor.yy328!=TK_ALL ) pParse->hasCompound = 1;
119869 sqlite3SelectDelete(pParse->db, yymsp[-2].minor.yy3);
119879 yygotominor.yy3 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy14,yymsp[-5].minor.yy65,yymsp[-4].minor.yy132,yymsp[-3].minor.yy14,yymsp[-2].minor.yy132,yymsp[-1].minor.yy14,yymsp[-7].minor.yy381,yymsp[0].minor.yy476.pLimit,yymsp[0].minor.yy476.pOffset);
119884 yygotominor.yy3 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy14,0,0,0,0,0,SF_Values,0,0);
119889 Select *pRight = sqlite3SelectNew(pParse,yymsp[-1].minor.yy14,0,0,0,0,0,SF_Values,0,0);
119919 yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy14, yymsp[-1].minor.yy346.pExpr);
119920 if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[0].minor.yy0, 1);
119921 sqlite3ExprListSetSpan(pParse,yygotominor.yy14,&yymsp[-1].minor.yy346);
119926 Expr *p = sqlite3Expr(pParse->db, TK_ALL, 0);
119927 yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-1].minor.yy14, p);
119932 Expr *pRight = sqlite3PExpr(pParse, TK_ALL, 0, 0, &yymsp[0].minor.yy0);
119933 Expr *pLeft = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
119934 Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight, 0);
119935 yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14, pDot);
119942 {yygotominor.yy65 = sqlite3DbMallocZero(pParse->db, sizeof(*yygotominor.yy65));}
119961 yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,&yymsp[-5].minor.yy0,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,0,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
119962 sqlite3SrcListIndexedBy(pParse, yygotominor.yy65, &yymsp[-2].minor.yy0);
119967 yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,0,0,&yymsp[-2].minor.yy0,yymsp[-4].minor.yy3,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
119975 yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,0,0,&yymsp[-2].minor.yy0,0,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
119985 sqlite3SrcListDelete(pParse->db, yymsp[-4].minor.yy65);
119989 pSubquery = sqlite3SelectNew(pParse,0,yymsp[-4].minor.yy65,0,0,0,0,SF_NestedFrom,0,0);
119990 yygotominor.yy65 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-6].minor.yy65,0,0,&yymsp[-2].minor.yy0,pSubquery,yymsp[-1].minor.yy132,yymsp[0].minor.yy408);
119999 {yygotominor.yy65 = sqlite3SrcListAppend(pParse->db,0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);}
120005 { yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); }
120008 { yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); }
120011 { yygotominor.yy328 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0); }
120045 yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14,yymsp[-1].minor.yy346.pExpr);
120051 yygotominor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[-1].minor.yy346.pExpr);
120076 sqlite3WithPush(pParse, yymsp[-5].minor.yy59, 1);
120077 sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy65, &yymsp[-1].minor.yy0);
120078 sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy65,yymsp[0].minor.yy132);
120083 sqlite3WithPush(pParse, yymsp[-7].minor.yy59, 1);
120084 sqlite3SrcListIndexedBy(pParse, yymsp[-4].minor.yy65, &yymsp[-3].minor.yy0);
120085 sqlite3ExprListCheckLength(pParse,yymsp[-1].minor.yy14,"set list");
120086 sqlite3Update(pParse,yymsp[-4].minor.yy65,yymsp[-1].minor.yy14,yymsp[0].minor.yy132,yymsp[-5].minor.yy186);
120091 yygotominor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[0].minor.yy346.pExpr);
120092 sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1);
120097 yygotominor.yy14 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy346.pExpr);
120098 sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1);
120103 sqlite3WithPush(pParse, yymsp[-5].minor.yy59, 1);
120104 sqlite3Insert(pParse, yymsp[-2].minor.yy65, yymsp[0].minor.yy3, yymsp[-1].minor.yy408, yymsp[-4].minor.yy186);
120109 sqlite3WithPush(pParse, yymsp[-6].minor.yy59, 1);
120110 sqlite3Insert(pParse, yymsp[-3].minor.yy65, 0, yymsp[-2].minor.yy408, yymsp[-5].minor.yy186);
120120 {yygotominor.yy408 = sqlite3IdListAppend(pParse->db,yymsp[-2].minor.yy408,&yymsp[0].minor.yy0);}
120123 {yygotominor.yy408 = sqlite3IdListAppend(pParse->db,0,&yymsp[0].minor.yy0);}
120134 {spanExpr(&yygotominor.yy346, pParse, yymsp[0].major, &yymsp[0].minor.yy0);}
120138 {spanExpr(&yygotominor.yy346, pParse, TK_ID, &yymsp[0].minor.yy0);}
120142 Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
120143 Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
120144 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp2, 0);
120150 Expr *temp1 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-4].minor.yy0);
120151 Expr *temp2 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[-2].minor.yy0);
120152 Expr *temp3 = sqlite3PExpr(pParse, TK_ID, 0, 0, &yymsp[0].minor.yy0);
120153 Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3, 0);
120154 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_DOT, temp1, temp4, 0);
120164 if( pParse->nested==0 ){
120165 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &yymsp[0].minor.yy0);
120168 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_REGISTER, 0, 0, &yymsp[0].minor.yy0);
120172 spanExpr(&yygotominor.yy346, pParse, TK_VARIABLE, &yymsp[0].minor.yy0);
120173 sqlite3ExprAssignVarNumber(pParse, yygotominor.yy346.pExpr);
120180 yygotominor.yy346.pExpr = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy346.pExpr, &yymsp[0].minor.yy0);
120187 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_CAST, yymsp[-3].minor.yy346.pExpr, 0, &yymsp[-1].minor.yy0);
120193 if( yymsp[-1].minor.yy14 && yymsp[-1].minor.yy14->nExpr>pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG] ){
120194 sqlite3ErrorMsg(pParse, "too many arguments on function %T", &yymsp[-4].minor.yy0);
120196 yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0);
120205 yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0);
120211 yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0);
120223 {spanBinaryExpr(&yygotominor.yy346,pParse,yymsp[-1].major,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy346);}
120234 pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy346.pExpr);
120235 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy346.pExpr);
120236 yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy96.eOperator);
120237 if( yymsp[-1].minor.yy96.bNot ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
120246 pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr);
120247 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy346.pExpr);
120248 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy346.pExpr);
120249 yygotominor.yy346.pExpr = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy96.eOperator);
120250 if( yymsp[-3].minor.yy96.bNot ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
120257 {spanUnaryPostfix(&yygotominor.yy346,pParse,yymsp[0].major,&yymsp[-1].minor.yy346,&yymsp[0].minor.yy0);}
120260 {spanUnaryPostfix(&yygotominor.yy346,pParse,TK_NOTNULL,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy0);}
120264 spanBinaryExpr(&yygotominor.yy346,pParse,TK_IS,&yymsp[-2].minor.yy346,&yymsp[0].minor.yy346);
120265 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy346.pExpr, yygotominor.yy346.pExpr, TK_ISNULL);
120270 spanBinaryExpr(&yygotominor.yy346,pParse,TK_ISNOT,&yymsp[-3].minor.yy346,&yymsp[0].minor.yy346);
120271 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy346.pExpr, yygotominor.yy346.pExpr, TK_NOTNULL);
120276 {spanUnaryPrefix(&yygotominor.yy346,pParse,yymsp[-1].major,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);}
120279 {spanUnaryPrefix(&yygotominor.yy346,pParse,TK_UMINUS,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);}
120282 {spanUnaryPrefix(&yygotominor.yy346,pParse,TK_UPLUS,&yymsp[0].minor.yy346,&yymsp[-1].minor.yy0);}
120286 ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr);
120287 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy346.pExpr);
120288 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy346.pExpr, 0, 0);
120292 sqlite3ExprListDelete(pParse->db, pList);
120294 if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
120310 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_INTEGER, 0, 0, &sqlite3IntTokens[yymsp[-3].minor.yy328]);
120311 sqlite3ExprDelete(pParse->db, yymsp[-4].minor.yy346.pExpr);
120331 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
120338 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, yymsp[-3].minor.yy328 ? TK_NE : TK_EQ, yymsp[-4].minor.yy346.pExpr, pRHS, 0);
120340 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0);
120343 sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
120345 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
120347 if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
120355 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_SELECT, 0, 0, 0);
120359 sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
120361 sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
120369 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy346.pExpr, 0, 0);
120373 sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
120375 sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
120377 if( yymsp[-3].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
120384 SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0);
120385 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_IN, yymsp[-3].minor.yy346.pExpr, 0, 0);
120387 yygotominor.yy346.pExpr->x.pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
120389 sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
120391 sqlite3SrcListDelete(pParse->db, pSrc);
120393 if( yymsp[-2].minor.yy328 ) yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_NOT, yygotominor.yy346.pExpr, 0, 0);
120400 Expr *p = yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_EXISTS, 0, 0, 0);
120404 sqlite3ExprSetHeight(pParse, p);
120406 sqlite3SelectDelete(pParse->db, yymsp[-1].minor.yy3);
120414 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy132, 0, 0);
120416 yygotominor.yy346.pExpr->x.pList = yymsp[-1].minor.yy132 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[-1].minor.yy132) : yymsp[-2].minor.yy14;
120417 sqlite3ExprSetHeight(pParse, yygotominor.yy346.pExpr);
120419 sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14);
120420 sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy132);
120428 yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[-2].minor.yy346.pExpr);
120429 yygotominor.yy14 = sqlite3ExprListAppend(pParse,yygotominor.yy14, yymsp[0].minor.yy346.pExpr);
120434 yygotominor.yy14 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy346.pExpr);
120435 yygotominor.yy14 = sqlite3ExprListAppend(pParse,yygotominor.yy14, yymsp[0].minor.yy346.pExpr);
120439 {yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[0].minor.yy346.pExpr);}
120442 {yygotominor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy346.pExpr);}
120446 sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
120447 sqlite3SrcListAppend(pParse->db,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy14, yymsp[-10].minor.yy328,
120460 Expr *p = sqlite3ExprAddCollateToken(pParse, 0, &yymsp[-1].minor.yy0);
120461 yygotominor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, p);
120462 sqlite3ExprListSetName(pParse,yygotominor.yy14,&yymsp[-2].minor.yy0,1);
120463 sqlite3ExprListCheckLength(pParse, yygotominor.yy14, "index");
120469 Expr *p = sqlite3ExprAddCollateToken(pParse, 0, &yymsp[-1].minor.yy0);
120470 yygotominor.yy14 = sqlite3ExprListAppend(pParse,0, p);
120471 sqlite3ExprListSetName(pParse, yygotominor.yy14, &yymsp[-2].minor.yy0, 1);
120472 sqlite3ExprListCheckLength(pParse, yygotominor.yy14, "index");
120480 {sqlite3DropIndex(pParse, yymsp[0].minor.yy65, yymsp[-1].minor.yy328);}
120484 {sqlite3Vacuum(pParse);}
120487 {sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
120490 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
120493 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
120496 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
120499 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
120506 sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy473, &all);
120511 sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy328, yymsp[-4].minor.yy378.a, yymsp[-4].minor.yy378.b, yymsp[-2].minor.yy65, yymsp[0].minor.yy132, yymsp[-10].minor.yy328, yymsp[-8].minor.yy328);
120558 sqlite3ErrorMsg(pParse,
120565 sqlite3ErrorMsg(pParse,
120572 sqlite3ErrorMsg(pParse,
120578 { yygotominor.yy473 = sqlite3TriggerUpdateStep(pParse->db, &yymsp[-4].minor.yy0, yymsp[-1].minor.yy14, yymsp[0].minor.yy132, yymsp[-5].minor.yy186); }
120581 {yygotominor.yy473 = sqlite3TriggerInsertStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy408, yymsp[0].minor.yy3, yymsp[-4].minor.yy186);}
120584 {yygotominor.yy473 = sqlite3TriggerDeleteStep(pParse->db, &yymsp[-2].minor.yy0, yymsp[0].minor.yy132);}
120587 {yygotominor.yy473 = sqlite3TriggerSelectStep(pParse->db, yymsp[0].minor.yy3); }
120591 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, 0);
120601 yygotominor.yy346.pExpr = sqlite3PExpr(pParse, TK_RAISE, 0, 0, &yymsp[-1].minor.yy0);
120617 sqlite3DropTrigger(pParse,yymsp[0].minor.yy65,yymsp[-1].minor.yy328);
120622 sqlite3Attach(pParse, yymsp[-3].minor.yy346.pExpr, yymsp[-1].minor.yy346.pExpr, yymsp[0].minor.yy132);
120627 sqlite3Detach(pParse, yymsp[0].minor.yy346.pExpr);
120631 {sqlite3Reindex(pParse, 0, 0);}
120634 {sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
120637 {sqlite3Analyze(pParse, 0, 0);}
120640 {sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
120644 sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy65,&yymsp[0].minor.yy0);
120649 sqlite3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy0);
120654 pParse->db->lookaside.bEnabled = 0;
120655 sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy65);
120659 {sqlite3VtabFinishParse(pParse,0);}
120662 {sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
120666 sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy328);
120670 {sqlite3VtabArgInit(pParse);}
120675 {sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
120686 yygotominor.yy59 = sqlite3WithAdd(pParse, 0, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy14, yymsp[-1].minor.yy3);
120691 yygotominor.yy59 = sqlite3WithAdd(pParse, yymsp[-7].minor.yy59, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy14, yymsp[-1].minor.yy3);
120793 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);
121648 SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
121655 sqlite3 *db = pParse->db; /* The database connection */
121663 pParse->rc = SQLITE_OK;
121664 pParse->zTail = zSql;
121672 assert( pParse->pNewTable==0 );
121673 assert( pParse->pNewTrigger==0 );
121674 assert( pParse->nVar==0 );
121675 assert( pParse->nzVar==0 );
121676 assert( pParse->azVar==0 );
121681 pParse->sLastToken.z = &zSql[i];
121682 pParse->sLastToken.n = sqlite3GetToken((unsigned char*)&zSql[i],&tokenType);
121683 i += pParse->sLastToken.n;
121685 pParse->rc = SQLITE_TOOBIG;
121691 sqlite3ErrorMsg(pParse, "interrupt");
121692 pParse->rc = SQLITE_INTERRUPT;
121700 &pParse->sLastToken);
121705 pParse->zTail = &zSql[i];
121709 sqlite3Parser(pEngine, tokenType, pParse->sLastToken, pParse);
121711 if( pParse->rc!=SQLITE_OK ){
121719 if( zSql[i]==0 && nErr==0 && pParse->rc==SQLITE_OK ){
121721 sqlite3Parser(pEngine, TK_SEMI, pParse->sLastToken, pParse);
121722 pParse->zTail = &zSql[i];
121724 sqlite3Parser(pEngine, 0, pParse->sLastToken, pParse);
121734 pParse->rc = SQLITE_NOMEM;
121736 if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){
121737 sqlite3SetString(&pParse->zErrMsg, db, "%s", sqlite3ErrStr(pParse->rc));
121740 if( pParse->zErrMsg ){
121741 *pzErrMsg = pParse->zErrMsg;
121742 sqlite3_log(pParse->rc, "%s", *pzErrMsg);
121743 pParse->zErrMsg = 0;
121746 if( pParse->pVdbe && pParse->nErr>0 && pParse->nested==0 ){
121747 sqlite3VdbeDelete(pParse->pVdbe);
121748 pParse->pVdbe = 0;
121751 if( pParse->nested==0 ){
121752 sqlite3DbFree(db, pParse->aTableLock);
121753 pParse->aTableLock = 0;
121754 pParse->nTableLock = 0;
121758 sqlite3_free(pParse->apVtabLock);
121762 /* If the pParse->declareVtab flag is set, do not delete any table
121763 ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
121766 sqlite3DeleteTable(db, pParse->pNewTable);
121769 if( pParse->bFreeWith ) sqlite3WithDelete(db, pParse->pWith);
121770 sqlite3DeleteTrigger(db, pParse->pNewTrigger);
121771 for(i=pParse->nzVar-1; i>=0; i--) sqlite3DbFree(db, pParse->azVar[i]);
121772 sqlite3DbFree(db, pParse->azVar);
121773 while( pParse->pAinc ){
121774 AutoincInfo *p = pParse->pAinc;
121775 pParse->pAinc = p->pNext;
121778 while( pParse->pZombieTab ){
121779 Table *p = pParse->pZombieTab;
121780 pParse->pZombieTab = p->pNextZombie;
121783 if( nErr>0 && pParse->rc==SQLITE_OK ){
121784 pParse->rc = SQLITE_ERROR;
133352 ** and other information (column names etc.) in pParse. Create an Fts3Expr
133363 ParseContext *pParse, /* fts3 query parse context */
133369 sqlite3_tokenizer *pTokenizer = pParse->pTokenizer;
133383 rc = sqlite3Fts3OpenTokenizer(pTokenizer, pParse->iLangid, z, i, &pCursor);
133413 pParse->isNot = 1;
133415 }else if( pParse->bFts4 && iStart>0 && z[iStart-1]=='^' ){
133462 ParseContext *pParse, /* fts3 query parse context */
133466 sqlite3_tokenizer *pTokenizer = pParse->pTokenizer;
133497 pTokenizer, pParse->iLangid, zInput, nInput, &pCursor);
133540 p->pPhrase->iColumn = pParse->iDefaultCol;
133580 ParseContext *pParse, /* fts3 query parse context */
133605 pParse->isNot = 0;
133678 return getNextString(pParse, &zInput[1], ii-1, ppExpr);
133684 pParse->nNest++;
133685 rc = fts3ExprParse(pParse, zInput+1, nInput-1, ppExpr, &nConsumed);
133690 pParse->nNest--;
133708 iCol = pParse->iDefaultCol;
133710 for(ii=0; ii<pParse->nCol; ii++){
133711 const char *zStr = pParse->azCol[ii];
133721 rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
133798 ParseContext *pParse, /* fts3 query parse context */
133815 rc = getNextNode(pParse, zIn, nIn, &p, &nByte);
133822 && p->eType==FTSQUERY_PHRASE && pParse->isNot
