Lines Matching defs:pParse
17709 Parse *pParse; /* Current parse */
19397 Parse *pParse; /* The parser */
19925 #define IN_DECLARE_VTAB (pParse->eParseMode==PARSE_MODE_DECLARE_VTAB)
19931 #define IN_RENAME_OBJECT (pParse->eParseMode>=PARSE_MODE_RENAME)
19937 #define IN_SPECIAL_PARSE (pParse->eParseMode!=PARSE_MODE_NORMAL)
19946 Parse *pParse; /* The Parse structure */
20087 Parse *pParse; /* The parse that includes the RETURNING clause */
20279 Parse *pParse; /* Parser context. */
20314 Parse *pParse; /* The parsing context. Error messages written here */
20482 SQLITE_PRIVATE Select *sqlite3MultiValues(Parse *pParse, Select *pLeft, ExprList *pRow);
20483 SQLITE_PRIVATE void sqlite3MultiValuesEnd(Parse *pParse, Select *pVal);
20861 SQLITE_PRIVATE void sqlite3GenerateColumnNames(Parse *pParse, Select *pSelect);
20936 SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse);
20937 SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse);
20950 SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2);
21262 SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse);
21265 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char*zName);
21267 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr);
21268 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr);
21270 SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(const Parse *pParse, Expr*, const Token*, int);
21337 SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p);
21648 SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p);
23551 Parse *pParse; /* Parsing context used to create this Vdbe */
31071 if( db->pParse ){
31072 Parse *pParse;
31073 sqlite3ErrorMsg(db->pParse, "out of memory");
31074 db->pParse->rc = SQLITE_NOMEM_BKPT;
31075 for(pParse=db->pParse->pOuterParse; pParse; pParse = pParse->pOuterParse){
31076 pParse->nErr++;
31077 pParse->rc = SQLITE_NOMEM;
32049 const Parse *pParse;
32055 pParse = db->pParse;
32056 if( NEVER(pParse==0) ) return;
32057 zText =pParse->zTail;
35142 ** Add an error message to pParse->zErrMsg and increment pParse->nErr.
35151 SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
35154 sqlite3 *db = pParse->db;
35156 assert( db->pParse==pParse || db->pParse->pToplevel==pParse );
35165 pParse->nErr++;
35166 pParse->rc = SQLITE_NOMEM;
35169 pParse->nErr++;
35170 sqlite3DbFree(db, pParse->zErrMsg);
35171 pParse->zErrMsg = zMsg;
35172 pParse->rc = SQLITE_ERROR;
35173 pParse->pWith = 0;
35183 Parse *pParse;
35184 if( db==0 || (pParse = db->pParse)==0 ) return errCode;
35185 pParse->rc = errCode;
35186 pParse->nErr++;
35241 SQLITE_PRIVATE void sqlite3DequoteNumber(Parse *pParse, Expr *p){
35242 assert( p!=0 || pParse->db->mallocFailed );
35258 sqlite3ErrorMsg(pParse, "unrecognized token: \"%s\"", p->u.zToken);
84198 Parse *pParse;
84229 pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx);
84337 sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal));
84344 pCtx->pParse->nErr++;
84351 pCtx->pParse->rc = rc;
84537 if( pCtx==0 || NEVER(pCtx->pParse->nErr==0) )
84590 Parse *pParse, /* Parse context */
84598 sqlite3 *db = pParse->db;
84612 sqlite3VdbeSetVarmask(pParse->pVdbe, iBindVar);
84613 if( (v = pParse->pReprepare)!=0 ){
84618 pVal->db = pParse->db;
84665 Parse *pParse, /* Parse context */
84680 alloc.pParse = pParse;
84687 u8 aff = sqlite3IndexColumnAffinity(pParse->db, pIdx, iVal+i);
84689 rc = stat4ValueFromExpr(pParse, pElem, aff, &alloc, &pVal);
84710 Parse *pParse, /* Parse context */
84715 return stat4ValueFromExpr(pParse, pExpr, affinity, 0, ppVal);
84862 SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse *pParse){
84863 sqlite3 *db = pParse->db;
84876 p->pParse = pParse;
84877 pParse->pVdbe = p;
84878 assert( pParse->aLabel==0 );
84879 assert( pParse->nLabel==0 );
84881 assert( pParse->szOpAlloc==0 );
84890 return p->pParse;
85003 Parse *p = v->pParse;
85276 Parse *pParse, /* Parsing context */
85284 Vdbe *v = pParse->pVdbe;
85290 pCtx = sqlite3DbMallocRawNN(pParse->db, nByte);
85292 assert( pParse->db->mallocFailed );
85293 freeEphemeralFunction(pParse->db, (FuncDef*)pFunc);
85305 sqlite3MayAbort(pParse);
85332 SQLITE_PRIVATE int sqlite3VdbeExplainParent(Parse *pParse){
85334 if( pParse->addrExplain==0 ) return 0;
85335 pOp = sqlite3VdbeGetOp(pParse->pVdbe, pParse->addrExplain);
85356 SQLITE_PRIVATE int sqlite3VdbeExplain(Parse *pParse, u8 bPush, const char *zFmt, ...){
85361 if( pParse->explain==2 || IS_STMT_SCANSTATUS(pParse->db) )
85369 zMsg = sqlite3VMPrintf(pParse->db, zFmt, ap);
85371 v = pParse->pVdbe;
85373 addr = sqlite3VdbeAddOp4(v, OP_Explain, iThis, pParse->addrExplain, 0,
85377 pParse->addrExplain = iThis;
85387 SQLITE_PRIVATE void sqlite3VdbeExplainPop(Parse *pParse){
85389 pParse->addrExplain = sqlite3VdbeExplainParent(pParse);
85406 sqlite3MayAbort(p->pParse);
85420 v->pParse->nTempReg = 0;
85421 v->pParse->nRangeReg = 0;
85449 SQLITE_PRIVATE int sqlite3VdbeMakeLabel(Parse *pParse){
85450 return --pParse->nLabel;
85477 Parse *p = v->pParse;
85586 ** Check if the program stored in the VM associated with pParse may
85606 ** assert( sqlite3VdbeAssertMayAbort(pParse->pVdbe, pParse->mayAbort) );
85713 Parse *pParse = p->pParse;
85714 int *aLabel = pParse->aLabel;
85716 assert( pParse->db->mallocFailed==0 ); /* tag-20230419-1 */
85775 assert( ADDR(pOp->p2)<-pParse->nLabel );
85801 sqlite3DbNNFreeNN(p->db, pParse->aLabel);
85802 pParse->aLabel = 0;
85804 pParse->nLabel = 0;
85837 Parse *pParse;
85841 pParse = v->pParse;
85842 assert( pParse!=0 );
85843 if( pParse->nErr ) return;
85859 if( j>=-pParse->nLabel || pParse->aLabel[j]<0 ){
85862 iDest = pParse->aLabel[j];
85892 sqlite3MayAbort(pParse);
86328 Parse *pParse, /* Parsing context */
86334 if( N==0 || OptimizationDisabled(pParse->db, SQLITE_ReleaseReg) ) return;
86335 assert( pParse->pVdbe );
86337 assert( iFirst+N-1<=pParse->nMem );
86350 sqlite3VdbeAddOp3(pParse->pVdbe, OP_ReleaseReg, iFirst, N, *(int*)&mask);
86351 if( bUndefine ) sqlite3VdbeChangeP5(pParse->pVdbe, 1);
86455 SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse *pParse, Index *pIdx){
86456 Vdbe *v = pParse->pVdbe;
86460 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pIdx);
86473 assert( p->aOp==0 || p->aOp[p->nOp-1].zComment==0 || p->pParse->nErr>0 );
87463 Parse *pParse /* Parsing context */
87475 assert( pParse!=0 );
87477 assert( pParse==p->pParse );
87478 p->pVList = pParse->pVList;
87479 pParse->pVList = 0;
87482 nVar = pParse->nVar;
87483 nMem = pParse->nMem;
87484 nCursor = pParse->nTab;
87485 nArg = pParse->nMaxArg;
87502 x.nFree = ROUNDDOWN8(pParse->szOpAlloc - n); /* Bytes of unused memory */
87507 p->usesStmtJournal = (u8)(pParse->isMultiWrite && pParse->mayAbort);
87508 if( pParse->explain ){
87510 p->explain = pParse->explain;
106604 Parse *pParse;
106606 || ((pParse = pWalker->pParse)!=0 && IN_RENAME_OBJECT)
106793 Parse *pParse, /* Parsing context */
106808 db = pParse->db;
106818 pDup = sqlite3ExprAddCollateString(pParse, pDup, pExpr->u.zToken);
106828 sqlite3ExprDeferredDelete(pParse, pDup);
106933 Parse *pParse, /* Parsing context */
106938 Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLUMN, 0, 0);
106945 *ppList = sqlite3ExprListAppend(pParse, *ppList, pNew);
107000 ** in pParse and return WRC_Abort. Return WRC_Prune on success.
107003 Parse *pParse, /* The parsing context */
107014 sqlite3 *db = pParse->db; /* The database connection */
107075 assert( pTab->nCol>0 || pParse->nErr );
107116 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
107153 sqlite3RenameTokenRemap(pParse, 0, (void*)&pExpr->y.pTab);
107182 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
107249 if( pParse->pTriggerTab!=0 ){
107250 int op = pParse->eTriggerOp;
107252 if( pParse->bReturning ){
107255 || sqlite3StrICmp(zTab,pParse->pTriggerTab->zName)==0
107256 || isValidSchemaTableName(zTab, pParse->pTriggerTab, 0))
107259 pTab = pParse->pTriggerTab;
107263 pTab = pParse->pTriggerTab;
107266 pTab = pParse->pTriggerTab;
107320 if( pParse->bReturning ){
107335 pParse->oldmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
107339 pParse->newmask |= (iCol>=32 ? 0xffffffff : (((u32)1)<<iCol));
107404 sqlite3ErrorMsg(pParse, "misuse of aliased aggregate %s", zAs);
107410 sqlite3ErrorMsg(pParse, "misuse of aliased window function %s",zAs);
107414 sqlite3ErrorMsg(pParse, "row value misused");
107417 resolveAlias(pParse, pEList, j, pExpr, nSubquery);
107422 sqlite3RenameTokenRemap(pParse, 0, (void*)pExpr);
107470 sqlite3VdbeAddDblquoteStr(db, pParse->pVdbe, zCol);
107502 extendFJMatch(pParse, &pFJMatch, pMatch, pExpr->iColumn);
107515 sqlite3ErrorMsg(pParse, "%s: %s.%s.%s", zErr, zDb, zTab, zCol);
107517 sqlite3ErrorMsg(pParse, "%s: %s.%s", zErr, zTab, zCol);
107519 sqlite3ErrorMsg(pParse, "%s: \"%s\" - should this be a"
107523 sqlite3ErrorMsg(pParse, "%s: %s", zErr, zCol);
107525 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
107526 pParse->checkSchema = 1;
107568 if( pParse->db->xAuth
107571 sqlite3AuthRead(pParse, pExpr, pSchema, pNC->pSrcList);
107625 ** Parse *pParse, // Leave error message here
107637 Parse *pParse, /* Leave error message here */
107651 sqlite3ErrorMsg(pParse, "%s prohibited in %s", zMsg, zIn);
107653 sqlite3RecordErrorOffsetOfExpr(pParse->db, pError);
107687 Parse *pParse;
107691 pParse = pNC->pParse;
107692 assert( pParse==pWalker->pParse );
107699 assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab);
107788 sqlite3ExprDelete(pParse->db, pExpr->pLeft);
107816 sqlite3ResolveNotValid(pParse, pNC, "the \".\" operator",
107832 sqlite3RenameTokenRemap(pParse, (void*)pExpr, (void*)pRight);
107833 sqlite3RenameTokenRemap(pParse, (void*)&pExpr->y.pTab, (void*)pLeft);
107836 return lookupName(pParse, zDb, zTable, pRight, pNC, pExpr);
107849 u8 enc = ENC(pParse->db); /* The database encoding */
107857 pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0);
107859 pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0);
107872 sqlite3ErrorMsg(pParse,
107892 int auth = sqlite3AuthCheck(pParse, SQLITE_FUNCTION, 0,pDef->zName,0);
107895 sqlite3ErrorMsg(pParse, "not authorized to use function: %#T",
107918 sqlite3ResolveNotValid(pParse, pNC, "non-deterministic functions",
107926 && pParse->nested==0
107927 && (pParse->db->mDbFlags & DBFLAG_InternalFunc)==0
107939 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
107950 sqlite3ErrorMsg(pParse,
107965 sqlite3ErrorMsg(pParse, "misuse of %s function %#T()",zType,pExpr);
107971 sqlite3ErrorMsg(pParse,"misuse of aggregate function %#T()",pExpr);
107976 else if( no_such_func && pParse->db->init.busy==0
107978 && pParse->explain==0
107981 sqlite3ErrorMsg(pParse, "no such function: %#T", pExpr);
107984 sqlite3ErrorMsg(pParse,"wrong number of arguments to function %#T()",
107990 sqlite3ErrorMsg(pParse,
107998 sqlite3ExprOrderByAggregateError(pParse, pExpr);
108027 sqlite3WindowUpdate(pParse, pSel ? pSel->pWinDefn : 0, pWin, pDef);
108028 if( pParse->db->mallocFailed ) break;
108048 && sqlite3ReferencesSrcList(pParse, pExpr, pNC2->pSrcList)==0
108086 notValidImpl(pParse, pNC, "subqueries", pExpr, pExpr);
108104 sqlite3ResolveNotValid(pParse, pNC, "parameters",
108133 if( pParse->db->mallocFailed ) break;
108156 sqlite3ErrorMsg(pParse, "row value misused");
108157 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
108162 assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 );
108163 return pParse->nErr ? WRC_Abort : WRC_Continue;
108179 Parse *pParse, /* Parsing context for error messages */
108185 UNUSED_PARAMETER(pParse);
108221 Parse *pParse, /* Parsing context for error messages */
108238 nc.pParse = pParse;
108243 db = pParse->db;
108268 Parse *pParse, /* The error context into which to write the error */
108274 sqlite3ErrorMsg(pParse,
108277 sqlite3RecordErrorOffsetOfExpr(pParse->db, pError);
108296 Parse *pParse, /* Parsing context. Leave error messages here */
108307 db = pParse->db;
108309 sqlite3ErrorMsg(pParse, "too many terms in ORDER BY clause");
108333 resolveOutOfRangeError(pParse, "ORDER", i+1, pEList->nExpr, pE);
108337 iCol = resolveAsName(pParse, pEList, pE);
108353 iCol = resolveOrderByTermToExprList(pParse, pSelect, pDup);
108355 resolveOrderByTermToExprList(pParse, pSelect, pE);
108390 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
108405 ** If any errors are detected, add an error message to pParse and
108409 Parse *pParse, /* Parsing context. Leave error messages here */
108415 sqlite3 *db = pParse->db;
108419 if( pOrderBy==0 || pParse->db->mallocFailed || IN_RENAME_OBJECT ) return 0;
108421 sqlite3ErrorMsg(pParse, "too many terms in %s BY clause", zType);
108429 resolveOutOfRangeError(pParse, zType, i+1, pEList->nExpr, 0);
108432 resolveAlias(pParse, pEList, pItem->u.x.iOrderByCol-1, pItem->pExpr,0);
108483 ** an appropriate error message might be left in pParse. (OOM errors
108495 Parse *pParse; /* Parsing context */
108500 pParse = pNC->pParse;
108506 iCol = resolveAsName(pParse, pSelect->pEList, pE2);
108521 resolveOutOfRangeError(pParse, zType, i+1, nResult, pE2);
108543 return sqlite3ResolveOrderGroupBy(pParse, pSelect, pOrderBy, zType);
108554 Parse *pParse; /* Parsing context */
108566 pParse = pWalker->pParse;
108567 db = pParse->db;
108578 sqlite3SelectPrep(pParse, p, pOuterNC);
108579 return pParse->nErr ? WRC_Abort : WRC_Prune;
108594 sNC.pParse = pParse;
108622 const char *zSavedContext = pParse->zAuthContext;
108624 if( pItem->zName ) pParse->zAuthContext = pItem->zName;
108625 sqlite3ResolveSelectNames(pParse, pItem->pSelect, pOuterNC);
108626 pParse->zAuthContext = zSavedContext;
108627 if( pParse->nErr ) return WRC_Abort;
108683 sqlite3ErrorMsg(pParse, "HAVING clause on a non-aggregate query");
108764 sqlite3ErrorMsg(pParse, "aggregate functions are not allowed in "
108774 sqlite3SelectWrongNumTermsError(pParse, p->pNext);
108787 if( isCompound && resolveCompoundOrderBy(pParse, pLeftmost) ){
108839 ** An error message is left in pParse if anything is amiss. The number
108852 w.pParse = pNC->pParse;
108858 w.pParse->nHeight += pExpr->nHeight;
108859 if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
108866 w.pParse->nHeight -= pExpr->nHeight;
108874 return pNC->nNcErr>0 || w.pParse->nErr>0;
108893 w.pParse = pNC->pParse;
108904 w.pParse->nHeight += pExpr->nHeight;
108905 if( sqlite3ExprCheckHeight(w.pParse, w.pParse->nHeight) ){
108911 w.pParse->nHeight -= pExpr->nHeight;
108923 if( w.pParse->nErr>0 ) return SQLITE_ERROR;
108942 Parse *pParse, /* The parser context */
108952 w.pParse = pParse;
108973 ** Any errors cause an error message to be set in pParse.
108976 Parse *pParse, /* Parsing context */
108982 SrcList sSrc; /* Fake SrcList for pParse->pNewTable */
108983 NameContext sNC; /* Name context for pParse->pNewTable */
108996 if( pTab->pSchema!=pParse->db->aDb[1].pSchema ){
109002 sNC.pParse = pParse;
109030 static int exprCodeVector(Parse *pParse, Expr *p, int *piToFree);
109179 ** If a memory allocation error occurs, that fact is recorded in pParse->db
109183 const Parse *pParse, /* Parsing context */
109189 Expr *pNew = sqlite3ExprAlloc(pParse->db, TK_COLLATE, pCollName, dequote);
109199 const Parse *pParse, /* Parsing context */
109206 return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0);
109255 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, const Expr *pExpr){
109256 sqlite3 *db = pParse->db;
109285 pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken);
109310 if( sqlite3CheckCollSeq(pParse, pColl) ){
109326 SQLITE_PRIVATE CollSeq *sqlite3ExprNNCollSeq(Parse *pParse, const Expr *pExpr){
109327 CollSeq *p = sqlite3ExprCollSeq(pParse, pExpr);
109328 if( p==0 ) p = pParse->db->pDfltColl;
109336 SQLITE_PRIVATE int sqlite3ExprCollSeqMatch(Parse *pParse, const Expr *pE1, const Expr *pE2){
109337 CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pE1);
109338 CollSeq *pColl2 = sqlite3ExprNNCollSeq(pParse, pE2);
109430 Parse *pParse,
109437 pColl = sqlite3ExprCollSeq(pParse, pLeft);
109439 pColl = sqlite3ExprCollSeq(pParse, pRight);
109441 pColl = sqlite3ExprCollSeq(pParse, pLeft);
109443 pColl = sqlite3ExprCollSeq(pParse, pRight);
109457 SQLITE_PRIVATE CollSeq *sqlite3ExprCompareCollSeq(Parse *pParse, const Expr *p){
109459 return sqlite3BinaryCompareCollSeq(pParse, p->pRight, p->pLeft);
109461 return sqlite3BinaryCompareCollSeq(pParse, p->pLeft, p->pRight);
109469 Parse *pParse, /* The parsing (and code generating) context */
109482 if( pParse->nErr ) return 0;
109484 p4 = sqlite3BinaryCompareCollSeq(pParse, pRight, pLeft);
109486 p4 = sqlite3BinaryCompareCollSeq(pParse, pLeft, pRight);
109489 addr = sqlite3VdbeAddOp4(pParse->pVdbe, opcode, in2, dest, in1,
109491 sqlite3VdbeChangeP5(pParse->pVdbe, (u8)p5);
109580 Parse *pParse, /* Parsing context */
109604 pRet = sqlite3PExpr(pParse, TK_SELECT_COLUMN, 0, 0);
109623 pRet = sqlite3ExprDup(pParse->db, pVector, 0);
109636 static int exprCodeSubselect(Parse *pParse, Expr *pExpr){
109640 reg = sqlite3CodeSubselect(pParse, pExpr);
109665 Parse *pParse, /* Parse context */
109686 return sqlite3ExprCodeTemp(pParse, *ppExpr, pRegFree);
109703 Parse *pParse, /* Code generator context */
109709 Vdbe *v = pParse->pVdbe;
109718 int addrDone = sqlite3VdbeMakeLabel(pParse);
109722 if( pParse->nErr ) return;
109724 sqlite3ErrorMsg(pParse, "row value misused");
109741 regLeft = exprCodeSubselect(pParse, pLeft);
109742 regRight = exprCodeSubselect(pParse, pRight);
109751 r1 = exprVectorRegister(pParse, pLeft, i, regLeft, &pL, ®Free1);
109752 r2 = exprVectorRegister(pParse, pRight, i, regRight, &pR, ®Free2);
109754 codeCompare(pParse, pL, pR, opx, r1, r2, addrDone, p5, isCommuted);
109761 sqlite3ReleaseTempReg(pParse, regFree1);
109762 sqlite3ReleaseTempReg(pParse, regFree2);
109795 ** pParse.
109797 SQLITE_PRIVATE int sqlite3ExprCheckHeight(Parse *pParse, int nHeight){
109799 int mxHeight = pParse->db->aLimit[SQLITE_LIMIT_EXPR_DEPTH];
109801 sqlite3ErrorMsg(pParse,
109872 ** leave an error in pParse.
109877 SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){
109878 if( pParse->nErr ) return;
109880 sqlite3ExprCheckHeight(pParse, p->nHeight);
109897 SQLITE_PRIVATE void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p){
109898 if( pParse->nErr ) return;
110039 ** Expr node. Or, if an OOM error occurs, set pParse->db->mallocFailed,
110043 Parse *pParse, /* Parsing context */
110049 p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr));
110054 sqlite3ExprAttachSubtrees(pParse->db, p, pLeft, pRight);
110055 sqlite3ExprCheckHeight(pParse, p->nHeight);
110057 sqlite3ExprDelete(pParse->db, pLeft);
110058 sqlite3ExprDelete(pParse->db, pRight);
110067 SQLITE_PRIVATE void sqlite3PExprAddSelect(Parse *pParse, Expr *pExpr, Select *pSelect){
110071 sqlite3ExprSetHeightAndFlags(pParse, pExpr);
110073 assert( pParse->db->mallocFailed );
110074 sqlite3SelectDelete(pParse->db, pSelect);
110092 ** an error message is left in pParse.
110097 SQLITE_PRIVATE Select *sqlite3ExprListToValues(Parse *pParse, int nElem, ExprList *pEList){
110112 sqlite3ErrorMsg(pParse, "IN(...) element has %d term%s - expected %d",
110118 pSel = sqlite3SelectNew(pParse, pExpr->x.pList, 0, 0, 0, 0, 0, SF_Values,0);
110132 sqlite3ExprListDelete(pParse->db, pEList);
110144 SQLITE_PRIVATE Expr *sqlite3ExprAnd(Parse *pParse, Expr *pLeft, Expr *pRight){
110145 sqlite3 *db = pParse->db;
110155 sqlite3ExprDeferredDelete(pParse, pLeft);
110156 sqlite3ExprDeferredDelete(pParse, pRight);
110159 return sqlite3PExpr(pParse, TK_AND, pLeft, pRight);
110169 Parse *pParse, /* Parsing context */
110175 sqlite3 *db = pParse->db;
110183 pNew->w.iOfst = (int)(pToken->z - pParse->zTail);
110185 && pList->nExpr > pParse->db->aLimit[SQLITE_LIMIT_FUNCTION_ARG]
110186 && !pParse->nested
110188 sqlite3ErrorMsg(pParse, "too many arguments on function %T", pToken);
110193 sqlite3ExprSetHeightAndFlags(pParse, pNew);
110202 SQLITE_PRIVATE void sqlite3ExprOrderByAggregateError(Parse *pParse, Expr *p){
110203 sqlite3ErrorMsg(pParse,
110219 Parse *pParse, /* Parsing context */
110224 sqlite3 *db = pParse->db;
110239 sqlite3ParserAddCleanup(pParse, sqlite3ExprListDeleteGeneric, pOrderBy);
110243 sqlite3ExprOrderByAggregateError(pParse, pExpr);
110271 Parse *pParse, /* Parsing and code generating context */
110279 || (pParse->db->flags & SQLITE_TrustedSchema)==0
110288 sqlite3ErrorMsg(pParse, "unsafe use of %#T()", pExpr);
110309 SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr, u32 n){
110310 sqlite3 *db = pParse->db;
110323 x = (ynVar)(++pParse->nVar);
110342 sqlite3ErrorMsg(pParse, "variable number must be between ?1 and ?%d",
110344 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
110348 if( x>pParse->nVar ){
110349 pParse->nVar = (int)x;
110351 }else if( sqlite3VListNumToName(pParse->pVList, x)==0 ){
110359 x = (ynVar)sqlite3VListNameToNum(pParse->pVList, z, n);
110361 x = (ynVar)(++pParse->nVar);
110366 pParse->pVList = sqlite3VListAdd(db, pParse->pVList, z, n, x);
110371 sqlite3ErrorMsg(pParse, "too many SQL variables");
110372 sqlite3RecordErrorOffsetOfExpr(pParse->db, pExpr);
110451 ** Arrange to cause pExpr to be deleted when the pParse is deleted.
110453 ** deferred until the pParse is deleted.
110460 SQLITE_PRIVATE int sqlite3ExprDeferredDelete(Parse *pParse, Expr *pExpr){
110461 return 0==sqlite3ParserAddCleanup(pParse, sqlite3ExprDeleteGeneric, pExpr);
110467 SQLITE_PRIVATE void sqlite3ExprUnmapAndDelete(Parse *pParse, Expr *p){
110470 sqlite3RenameExprUnmap(pParse, p);
110472 sqlite3ExprDeleteNN(pParse->db, p);
110795 w.pParse = 0;
111053 Parse *pParse, /* Parsing context */
111059 return sqlite3ExprListAppendNew(pParse->db,pExpr);
111062 return sqlite3ExprListAppendGrow(pParse->db,pList,pExpr);
111082 Parse *pParse, /* Parsing context */
111087 sqlite3 *db = pParse->db;
111102 sqlite3ErrorMsg(pParse, "%d columns assigned %d values",
111108 Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i, pColumns->nId);
111111 pList = sqlite3ExprListAppend(pParse, pList, pSubExpr);
111135 sqlite3ExprUnmapAndDelete(pParse, pExpr);
111178 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
111182 Parse *pParse, /* Parsing context */
111187 assert( pList!=0 || pParse->db->mallocFailed!=0 );
111188 assert( pParse->eParseMode!=PARSE_MODE_UNMAP || dequote==0 );
111195 pItem->zEName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
111202 sqlite3RenameTokenMap(pParse, (const void*)pItem->zEName, pName);
111213 ** NULL. If a memory allocation fails, the pParse->db->mallocFailed flag
111217 Parse *pParse, /* Parsing context */
111222 sqlite3 *db = pParse->db;
111236 ** leave an error message in pParse.
111239 Parse *pParse,
111243 int mx = pParse->db->aLimit[SQLITE_LIMIT_COLUMN];
111247 sqlite3ErrorMsg(pParse, "too many columns in %s", zObject);
111410 db = pWalker->pParse->db;
111471 }else if( pWalker->pParse ){
111527 static int exprIsConst(Parse *pParse, Expr *p, int initFlag){
111530 w.pParse = pParse;
111548 ** The pParse parameter may be NULL. But if it is NULL, there is no way
111550 ** function calls will be considered to be non-constant. If pParse is
111554 SQLITE_PRIVATE int sqlite3ExprIsConstant(Parse *pParse, Expr *p){
111555 return exprIsConst(pParse, p, 1);
111568 ** can be added to the pParse->pConstExpr list and evaluated once when
111571 static int sqlite3ExprIsConstantNotJoin(Parse *pParse, Expr *p){
111572 return exprIsConst(pParse, p, 2);
111603 w.pParse = 0;
111708 CollSeq *pColl = sqlite3ExprNNCollSeq(pWalker->pParse, p);
111743 SQLITE_PRIVATE int sqlite3ExprIsConstantOrGroupBy(Parse *pParse, Expr *p, ExprList *pGroupBy){
111749 w.pParse = pParse;
112025 static int sqlite3InRhsIsConstant(Parse *pParse, Expr *pIn){
112031 res = sqlite3ExprIsConstant(pParse, pIn);
112122 Parse *pParse, /* Parsing context */
112133 Vdbe *v = sqlite3GetVdbe(pParse); /* Virtual machine being coded */
112137 iTab = pParse->nTab++;
112158 if( pParse->nErr==0 && (p = isCandidateForInOpt(pX))!=0 ){
112159 sqlite3 *db = pParse->db; /* Database connection */
112173 sqlite3CodeVerifySchema(pParse, iDb);
112174 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
112182 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
112184 ExplainQueryPlan((pParse, 0,
112242 CollSeq *pReq = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs);
112264 ExplainQueryPlan((pParse, 0,
112267 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
112278 *prRhsHasNull = ++pParse->nMem;
112300 && (!sqlite3InRhsIsConstant(pParse,pX) || pX->x.pList->nExpr<=2)
112302 pParse->nTab--; /* Back out the allocation of the unused cursor */
112311 u32 savedNQueryLoop = pParse->nQueryLoop;
112315 pParse->nQueryLoop = 0;
112317 *prRhsHasNull = rMayHaveNull = ++pParse->nMem;
112320 sqlite3CodeRhsOfIN(pParse, pX, iTab);
112324 pParse->nQueryLoop = savedNQueryLoop;
112346 static char *exprINAffinity(Parse *pParse, const Expr *pExpr){
112353 zRet = sqlite3DbMallocRaw(pParse->db, nVal+1);
112378 SQLITE_PRIVATE void sqlite3SubselectError(Parse *pParse, int nActual, int nExpect){
112379 if( pParse->nErr==0 ){
112381 sqlite3ErrorMsg(pParse, zFmt, nActual, nExpect);
112397 SQLITE_PRIVATE void sqlite3VectorErrorMsg(Parse *pParse, Expr *pExpr){
112400 sqlite3SubselectError(pParse, pExpr->x.pSelect->pEList->nExpr, 1);
112404 sqlite3ErrorMsg(pParse, "row value misused");
112432 Parse *pParse, /* Parsing context */
112443 v = pParse->pVdbe;
112456 if( !ExprHasProperty(pExpr, EP_VarSelect) && pParse->iSelfTab==0 ){
112464 ExplainQueryPlan((pParse, 0, "REUSE LIST SUBQUERY %d",
112480 pExpr->y.sub.regReturn = ++pParse->nMem;
112503 pKeyInfo = sqlite3KeyInfoAlloc(pParse->db, nVal, 1);
112514 ExplainQueryPlan((pParse, 1, "%sLIST SUBQUERY %d",
112525 dest.zAffSdst = exprINAffinity(pParse, pExpr);
112529 pCopy = sqlite3SelectDup(pParse->db, pSelect, 0);
112530 rc = pParse->db->mallocFailed ? 1 :sqlite3Select(pParse, pCopy, &dest);
112531 sqlite3SelectDelete(pParse->db, pCopy);
112532 sqlite3DbFree(pParse->db, dest.zAffSdst);
112544 pParse, p, pEList->a[i].pExpr
112569 pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
112573 r1 = sqlite3GetTempReg(pParse);
112574 r2 = sqlite3GetTempReg(pParse);
112583 if( addrOnce && !sqlite3ExprIsConstant(pParse, pE2) ){
112591 sqlite3ExprCode(pParse, pE2, r1);
112595 sqlite3ReleaseTempReg(pParse, r1);
112596 sqlite3ReleaseTempReg(pParse, r2);
112607 || pParse->nErr );
112611 sqlite3ClearTempRegCache(pParse);
112631 SQLITE_PRIVATE int sqlite3CodeSubselect(Parse *pParse, Expr *pExpr){
112642 Vdbe *v = pParse->pVdbe;
112644 if( pParse->nErr ) return 0;
112654 ExplainQueryPlan((pParse, 0, "REUSE SUBQUERY %d", pSel->selId));
112665 pExpr->y.sub.regReturn = ++pParse->nMem;
112693 ExplainQueryPlan2(addrExplain, (pParse, 1, "%sSCALAR SUBQUERY %d",
112697 sqlite3SelectDestInit(&dest, 0, pParse->nMem+1);
112698 pParse->nMem += nReg;
112713 sqlite3 *db = pParse->db;
112717 pLimit = sqlite3PExpr(pParse, TK_NE,
112720 sqlite3ExprDeferredDelete(pParse, pSel->pLimit->pLeft);
112724 pLimit = sqlite3Expr(pParse->db, TK_INTEGER, "1");
112725 pSel->pLimit = sqlite3PExpr(pParse, TK_LIMIT, pLimit, 0);
112728 if( sqlite3Select(pParse, pSel, &dest) ){
112743 || pParse->nErr );
112747 sqlite3ClearTempRegCache(pParse);
112759 SQLITE_PRIVATE int sqlite3ExprCheckIN(Parse *pParse, Expr *pIn){
112761 if( ExprUseXSelect(pIn) && !pParse->db->mallocFailed ){
112763 sqlite3SubselectError(pParse, pIn->x.pSelect->pEList->nExpr, nVector);
112767 sqlite3VectorErrorMsg(pParse, pIn->pLeft);
112801 Parse *pParse, /* Parsing and code generating context */
112823 u8 okConstFactor = pParse->okConstFactor;
112827 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
112828 zAff = exprINAffinity(pParse, pExpr);
112831 pParse->db, nVector*(sizeof(int) + sizeof(char)) + 1
112833 if( pParse->db->mallocFailed ) goto sqlite3ExprCodeIN_oom_error;
112839 v = pParse->pVdbe;
112842 eType = sqlite3FindInIndex(pParse, pExpr,
112847 assert( pParse->nErr || nVector==1 || eType==IN_INDEX_EPH
112872 assert( pParse->okConstFactor==okConstFactor );
112873 pParse->okConstFactor = 0;
112874 rLhsOrig = exprCodeVector(pParse, pLeft, &iDummy);
112875 pParse->okConstFactor = okConstFactor;
112882 rLhs = sqlite3GetTempRange(pParse, nVector);
112897 int labelOk = sqlite3VdbeMakeLabel(pParse);
112903 pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
112905 regCkNull = sqlite3GetTempReg(pParse);
112909 r2 = sqlite3ExprCodeTemp(pParse, pList->a[ii].pExpr, ®ToFree);
112913 sqlite3ReleaseTempReg(pParse, regToFree);
112938 sqlite3ReleaseTempReg(pParse, regCkNull);
112949 destStep2 = destStep6 = sqlite3VdbeMakeLabel(pParse);
112953 if( pParse->nErr ) goto sqlite3ExprCodeIN_oom_error;
113008 destNotNull = sqlite3VdbeMakeLabel(pParse);
113017 int r3 = sqlite3GetTempReg(pParse);
113019 pColl = sqlite3ExprCollSeq(pParse, p);
113024 sqlite3ReleaseTempReg(pParse, r3);
113041 if( rLhs!=rLhsOrig ) sqlite3ReleaseTempReg(pParse, rLhs);
113044 sqlite3DbFree(pParse->db, aiMap);
113045 sqlite3DbFree(pParse->db, zAff);
113076 static void codeInteger(Parse *pParse, Expr *pExpr, int negFlag, int iMem){
113077 Vdbe *v = pParse->pVdbe;
113091 sqlite3ErrorMsg(pParse, "oversized integer: %s%#T", negFlag?"-":"",pExpr);
113095 sqlite3ErrorMsg(pParse, "hex literal too big: %s%#T",
113115 Parse *pParse, /* The parsing context */
113125 pParse->iSelfTab = iTabCur + 1;
113126 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut);
113127 pParse->iSelfTab = 0;
113129 sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pIdx->pTable, iTabCur,
113140 Parse *pParse, /* Parsing context */
113146 Vdbe *v = pParse->pVdbe;
113147 int nErr = pParse->nErr;
113149 assert( pParse->iSelfTab!=0 );
113150 if( pParse->iSelfTab>0 ){
113151 iAddr = sqlite3VdbeAddOp3(v, OP_IfNullRow, pParse->iSelfTab-1, 0, regOut);
113155 sqlite3ExprCodeCopy(pParse, sqlite3ColumnExpr(pTab,pCol), regOut);
113160 if( pParse->nErr>nErr ) pParse->db->errByteOffset = -1;
113189 Parse *pParse = sqlite3VdbeParser(v);
113191 sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"",
113194 int savedSelfTab = pParse->iSelfTab;
113196 pParse->iSelfTab = iTabCur+1;
113197 sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, regOut);
113198 pParse->iSelfTab = savedSelfTab;
113225 Parse *pParse, /* Parsing and code generating context */
113232 assert( pParse->pVdbe!=0 );
113235 sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pTab, iTable, iColumn, iReg);
113237 VdbeOp *pOp = sqlite3VdbeGetLastOp(pParse->pVdbe);
113248 SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse *pParse, int iFrom, int iTo, int nReg){
113249 sqlite3VdbeAddOp3(pParse->pVdbe, OP_Move, iFrom, iTo, nReg);
113276 static int exprCodeVector(Parse *pParse, Expr *p, int *piFreeable){
113280 iResult = sqlite3ExprCodeTemp(pParse, p, piFreeable);
113287 iResult = sqlite3CodeSubselect(pParse, p);
113291 iResult = pParse->nMem+1;
113292 pParse->nMem += nResult;
113295 sqlite3ExprCodeFactorable(pParse, p->x.pList->a[i].pExpr, i+iResult);
113317 Parse *pParse, /* Parsing context */
113323 Vdbe *v = pParse->pVdbe;
113334 int endCoalesce = sqlite3VdbeMakeLabel(pParse);
113337 sqlite3ExprCode(pParse, pFarg->a[0].pExpr, target);
113341 sqlite3ExprCode(pParse, pFarg->a[i].pExpr, target);
113352 return sqlite3ExprCodeTarget(pParse, &caseExpr, target);
113370 target = sqlite3ExprCodeTarget(pParse, pFarg->a[0].pExpr, target);
113392 sqlite3ExprImpliesExpr(pParse,pFarg->a[0].pExpr, pFarg->a[1].pExpr,-1),
113434 ** Check to see if pExpr is one of the indexed expressions on pParse->pIdxEpr.
113440 Parse *pParse, /* The parsing context */
113446 for(p=pParse->pIdxEpr; p; p=p->pIENext){
113450 if( pParse->iSelfTab ){
113451 if( p->iDataCur!=pParse->iSelfTab-1 ) continue;
113465 v = pParse->pVdbe;
113477 p = pParse->pIdxEpr;
113478 pParse->pIdxEpr = 0;
113479 sqlite3ExprCode(pParse, pExpr, target);
113480 pParse->pIdxEpr = p;
113502 static int exprPartidxExprLookup(Parse *pParse, Expr *pExpr, int iTarget){
113504 for(p=pParse->pIdxPartExpr; p; p=p->pIENext){
113506 Vdbe *v = pParse->pVdbe;
113513 ret = sqlite3ExprCodeTarget(pParse, p->pExpr, iTarget);
113514 sqlite3VdbeAddOp4(pParse->pVdbe, OP_Affinity, ret, 1, 0,
113538 SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target){
113539 Vdbe *v = pParse->pVdbe; /* The VM under construction */
113548 assert( target>0 && target<=pParse->nMem );
113554 }else if( pParse->pIdxEpr!=0
113556 && (r1 = sqlite3IndexedExprLookup(pParse, pExpr, target))>=0
113621 iReg = sqlite3ExprCodeTarget(pParse, pExpr->pLeft,target);
113635 if( pParse->iSelfTab<0 ){
113639 ** 0-(pParse->iSelfTab). The rowid (if any) is in a register
113652 return -1-pParse->iSelfTab;
113656 iSrc = sqlite3TableColumnToStorage(pTab, iCol) - pParse->iSelfTab;
113660 sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"",
113666 sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, iSrc);
113682 iTab = pParse->iSelfTab - 1;
113685 else if( pParse->pIdxPartExpr
113686 && 0!=(r1 = exprPartidxExprLookup(pParse, pExpr, target))
113692 iReg = sqlite3ExprCodeGetColumn(pParse, pExpr->y.pTab,
113698 codeInteger(pParse, pExpr, 0, target);
113722 assert( op==TK_NULL || op==TK_ERROR || pParse->db->mallocFailed );
113755 sqlite3ExprCode(pParse, pExpr->pLeft, target);
113776 codeVectorCompare(pParse, pExpr, target, op, p5);
113778 r1 = sqlite3ExprCodeTemp(pParse, pLeft, ®Free1);
113779 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
113781 codeCompare(pParse, pLeft, pExpr->pRight, op, r1, r2,
113823 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113824 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
113834 codeInteger(pParse, pLeft, 1, target);
113847 r1 = sqlite3ExprCodeTemp(pParse, &tempX, ®Free1);
113848 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free2);
113858 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113866 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113881 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
113897 sqlite3ErrorMsg(pParse, "misuse of aggregate: %#T()", pExpr);
113910 sqlite3 *db = pParse->db; /* The database connection */
113920 if( ConstFactorOk(pParse)
113921 && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
113925 return sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
113935 if( pDef==0 && pParse->explain ){
113940 sqlite3ErrorMsg(pParse, "unknown function: %#T()", pExpr);
113946 return exprCodeInlineFunction(pParse, pFarg,
113949 sqlite3ExprFunctionUsable(pParse, pExpr, pDef);
113953 if( i<32 && sqlite3ExprIsConstant(pParse, pFarg->a[i].pExpr) ){
113958 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
113963 r1 = pParse->nMem+1;
113964 pParse->nMem += nFarg;
113966 r1 = sqlite3GetTempRange(pParse, nFarg);
113991 sqlite3ExprCodeExprList(pParse, pFarg, r1, 0, SQLITE_ECEL_FACTOR);
114018 sqlite3VdbeAddFunctionCall(pParse, constMask, r1, target, nFarg,
114022 sqlite3ReleaseTempRange(pParse, r1, nFarg);
114024 sqlite3VdbeReleaseRegisters(pParse, r1, nFarg, constMask, 1);
114035 if( pParse->db->mallocFailed ){
114041 sqlite3SubselectError(pParse, nCol, 1);
114043 return sqlite3CodeSubselect(pParse, pExpr);
114050 if( pLeft->iTable==0 || pParse->withinRJSubrtn > pLeft->op2 ){
114051 pLeft->iTable = sqlite3CodeSubselect(pParse, pLeft);
114052 pLeft->op2 = pParse->withinRJSubrtn;
114057 sqlite3ErrorMsg(pParse, "%d columns assigned %d values",
114063 int destIfFalse = sqlite3VdbeMakeLabel(pParse);
114064 int destIfNull = sqlite3VdbeMakeLabel(pParse);
114066 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
114088 exprCodeBetween(pParse, pExpr, target, 0, 0);
114100 sqlite3ExprCode(pParse, pExpr->pLeft, target);
114175 sqlite3ErrorMsg(pParse, "row value misused");
114187 u8 okConstFactor = pParse->okConstFactor;
114211 pParse->okConstFactor = 0; /* note (1) above */
114212 sqlite3ExprCode(pParse, pExpr->pLeft, target);
114214 pParse->okConstFactor = okConstFactor;
114251 sqlite3 *db = pParse->db;
114258 endLabel = sqlite3VdbeMakeLabel(pParse);
114266 exprToRegister(pDel, exprCodeVector(pParse, pDel, ®Free1));
114285 nextCase = sqlite3VdbeMakeLabel(pParse);
114287 sqlite3ExprIfFalse(pParse, pTest, nextCase, SQLITE_JUMPIFNULL);
114289 sqlite3ExprCode(pParse, aListelem[i+1].pExpr, target);
114294 sqlite3ExprCode(pParse, pEList->a[nExpr-1].pExpr, target);
114310 if( !pParse->pTriggerTab && !pParse->nested ){
114311 sqlite3ErrorMsg(pParse,
114316 sqlite3MayAbort(pParse);
114324 sqlite3HaltConstraint(pParse,
114325 pParse->pTriggerTab ? SQLITE_CONSTRAINT_TRIGGER : SQLITE_ERROR,
114333 sqlite3ReleaseTempReg(pParse, regFree1);
114334 sqlite3ReleaseTempReg(pParse, regFree2);
114356 Parse *pParse, /* Parsing context */
114361 assert( ConstFactorOk(pParse) );
114363 p = pParse->pConstExpr;
114375 pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
114377 Vdbe *v = pParse->pVdbe;
114381 pParse->okConstFactor = 0;
114382 if( !pParse->db->mallocFailed ){
114383 if( regDest<0 ) regDest = ++pParse->nMem;
114384 sqlite3ExprCode(pParse, pExpr, regDest);
114386 pParse->okConstFactor = 1;
114387 sqlite3ExprDelete(pParse->db, pExpr);
114390 p = sqlite3ExprListAppend(pParse, p, pExpr);
114394 if( regDest<0 ) regDest = ++pParse->nMem;
114397 pParse->pConstExpr = p;
114415 SQLITE_PRIVATE int sqlite3ExprCodeTemp(Parse *pParse, Expr *pExpr, int *pReg){
114418 if( ConstFactorOk(pParse)
114421 && sqlite3ExprIsConstantNotJoin(pParse, pExpr)
114424 r2 = sqlite3ExprCodeRunJustOnce(pParse, pExpr, -1);
114426 int r1 = sqlite3GetTempReg(pParse);
114427 r2 = sqlite3ExprCodeTarget(pParse, pExpr, r1);
114431 sqlite3ReleaseTempReg(pParse, r1);
114443 SQLITE_PRIVATE void sqlite3ExprCode(Parse *pParse, Expr *pExpr, int target){
114447 assert( target>0 && target<=pParse->nMem );
114448 assert( pParse->pVdbe!=0 || pParse->db->mallocFailed );
114449 if( pParse->pVdbe==0 ) return;
114450 inReg = sqlite3ExprCodeTarget(pParse, pExpr, target);
114462 sqlite3VdbeAddOp2(pParse->pVdbe, op, inReg, target);
114471 SQLITE_PRIVATE void sqlite3ExprCodeCopy(Parse *pParse, Expr *pExpr, int target){
114472 sqlite3 *db = pParse->db;
114474 if( !db->mallocFailed ) sqlite3ExprCode(pParse, pExpr, target);
114484 SQLITE_PRIVATE void sqlite3ExprCodeFactorable(Parse *pParse, Expr *pExpr, int target){
114485 if( pParse->okConstFactor && sqlite3ExprIsConstantNotJoin(pParse,pExpr) ){
114486 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target);
114488 sqlite3ExprCodeCopy(pParse, pExpr, target);
114513 Parse *pParse, /* Parsing context */
114522 Vdbe *v = pParse->pVdbe;
114525 assert( pParse->pVdbe!=0 ); /* Never gets this far otherwise */
114527 if( !ConstFactorOk(pParse) ) flags &= ~SQLITE_ECEL_FACTOR;
114544 && sqlite3ExprIsConstantNotJoin(pParse,pExpr)
114546 sqlite3ExprCodeRunJustOnce(pParse, pExpr, target+i);
114548 int inReg = sqlite3ExprCodeTarget(pParse, pExpr, target+i);
114588 Parse *pParse, /* Parsing and code generating context */
114599 sqlite3 *db = pParse->db;
114617 exprToRegister(pDel, exprCodeVector(pParse, pDel, ®Free1));
114619 xJump(pParse, &exprAnd, dest, jumpIfNull);
114627 sqlite3ExprCodeTarget(pParse, &exprAnd, dest);
114629 sqlite3ReleaseTempReg(pParse, regFree1);
114659 SQLITE_PRIVATE void sqlite3ExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
114660 Vdbe *v = pParse->pVdbe;
114676 sqlite3ExprIfTrue(pParse, pAlt, dest, jumpIfNull);
114678 int d2 = sqlite3VdbeMakeLabel(pParse);
114680 sqlite3ExprIfFalse(pParse, pExpr->pLeft, d2,
114682 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
114686 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
114687 sqlite3ExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull);
114693 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
114705 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
114708 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
114728 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114729 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
114730 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
114750 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114760 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfTrue, jumpIfNull);
114765 int destIfFalse = sqlite3VdbeMakeLabel(pParse);
114767 sqlite3ExprCodeIN(pParse, pExpr, destIfFalse, destIfNull);
114780 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
114789 sqlite3ReleaseTempReg(pParse, regFree1);
114790 sqlite3ReleaseTempReg(pParse, regFree2);
114802 SQLITE_PRIVATE void sqlite3ExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){
114803 Vdbe *v = pParse->pVdbe;
114850 sqlite3ExprIfFalse(pParse, pAlt, dest, jumpIfNull);
114853 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull);
114854 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
114856 int d2 = sqlite3VdbeMakeLabel(pParse);
114858 sqlite3ExprIfTrue(pParse, pExpr->pLeft, d2,
114860 sqlite3ExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull);
114867 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull);
114880 sqlite3ExprIfFalse(pParse, pExpr->pLeft, dest,
114885 sqlite3ExprIfTrue(pParse, pExpr->pLeft, dest,
114905 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114906 r2 = sqlite3ExprCodeTemp(pParse, pExpr->pRight, ®Free2);
114907 codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op,
114925 r1 = sqlite3ExprCodeTemp(pParse, pExpr->pLeft, ®Free1);
114935 exprCodeBetween(pParse, pExpr, dest, sqlite3ExprIfFalse, jumpIfNull);
114941 sqlite3ExprCodeIN(pParse, pExpr, dest, dest);
114943 int destIfNull = sqlite3VdbeMakeLabel(pParse);
114944 sqlite3ExprCodeIN(pParse, pExpr, dest, destIfNull);
114957 r1 = sqlite3ExprCodeTemp(pParse, pExpr, ®Free1);
114966 sqlite3ReleaseTempReg(pParse, regFree1);
114967 sqlite3ReleaseTempReg(pParse, regFree2);
114975 SQLITE_PRIVATE void sqlite3ExprIfFalseDup(Parse *pParse, Expr *pExpr, int dest,int jumpIfNull){
114976 sqlite3 *db = pParse->db;
114979 sqlite3ExprIfFalse(pParse, pCopy, dest, jumpIfNull);
114998 const Parse *pParse,
115006 sqlite3ValueFromExpr(pParse->db, pExpr, SQLITE_UTF8, SQLITE_AFF_BLOB, &pR);
115009 sqlite3VdbeSetVarmask(pParse->pVdbe, iVar);
115010 pL = sqlite3VdbeGetBoundValue(pParse->pReprepare, iVar, SQLITE_AFF_BLOB);
115046 ** If pParse is not NULL then TK_VARIABLE terms in pA with bindings in
115047 ** pParse->pReprepare can be matched against literals in pB. The
115048 ** pParse->pVdbe->expmask bitmask is updated for each variable referenced.
115049 ** If pParse is NULL (the normal case) then any TK_VARIABLE term in
115050 ** Argument pParse should normally be NULL. If it is not NULL and pA or
115054 const Parse *pParse,
115063 if( pParse && pA->op==TK_VARIABLE && exprCompareVariable(pParse, pA, pB) ){
115074 if( pA->op==TK_COLLATE && sqlite3ExprCompare(pParse, pA->pLeft,pB,iTab)<2 ){
115077 if( pB->op==TK_COLLATE && sqlite3ExprCompare(pParse, pA,pB->pLeft,iTab)<2 ){
115099 if( sqlite3WindowCompare(pParse, pA->y.pWin, pB->y.pWin, 1)!=0 ){
115122 && sqlite3ExprCompare(pParse, pA->pLeft, pB->pLeft, iTab) ) return 2;
115123 if( sqlite3ExprCompare(pParse, pA->pRight, pB->pRight, iTab) ) return 2;
115188 const Parse *pParse,/* Parsing context */
115196 if( sqlite3ExprCompare(pParse, p, pNN, iTab)==0 ){
115203 return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
115212 if( exprImpliesNotNull(pParse, pList->a[0].pExpr, pNN, iTab, 1)
115213 || exprImpliesNotNull(pParse, pList->a[1].pExpr, pNN, iTab, 1)
115217 return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
115237 if( exprImpliesNotNull(pParse, p->pRight, pNN, iTab, seenNot) ) return 1;
115244 return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, seenNot);
115249 return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
115253 return exprImpliesNotNull(pParse, p->pLeft, pNN, iTab, 1);
115275 ** If pParse is not NULL, then the values of bound variables in pE1 are
115276 ** compared against literal values in pE2 and pParse->pVdbe->expmask is
115277 ** modified to record which bound variables are referenced. If pParse
115285 const Parse *pParse,
115290 if( sqlite3ExprCompare(pParse, pE1, pE2, iTab)==0 ){
115294 && (sqlite3ExprImpliesExpr(pParse, pE1, pE2->pLeft, iTab)
115295 || sqlite3ExprImpliesExpr(pParse, pE1, pE2->pRight, iTab) )
115300 && exprImpliesNotNull(pParse, pE1, pE2->pLeft, iTab, 0)
115634 SQLITE_PRIVATE int sqlite3ReferencesSrcList(Parse *pParse, Expr *pExpr, SrcList *pSrcList){
115637 assert( pParse->db!=0 );
115644 x.db = pParse->db;
115660 if( x.aiExclude ) sqlite3DbNNFreeNN(pParse->db, x.aiExclude);
115687 Parse *pParse = pWalker->pParse;
115688 sqlite3 *db = pParse->db;
115695 if( pExpr && !sqlite3ExprDeferredDelete(pParse, pExpr) ){
115705 if( pExpr && !sqlite3ExprDeferredDelete(pParse, pExpr) ){
115718 SQLITE_PRIVATE void sqlite3AggInfoPersistWalkerInit(Walker *pWalker, Parse *pParse){
115720 pWalker->pParse = pParse;
115765 Parse *pParse, /* Parsing context */
115783 k = addAggInfoColumn(pParse->db, pAggInfo);
115786 assert( pParse->db->mallocFailed );
115833 Parse *pParse = pNC->pParse;
115843 assert( pParse->iSelfTab==0 );
115845 if( pParse->pIdxEpr==0 ) break;
115846 for(pIEpr=pParse->pIdxEpr; pIEpr; pIEpr=pIEpr->pIENext){
115858 if( pParse->nErr ){ return WRC_Abort; }
115868 findOrCreateAggInfoColumn(pParse, pAggInfo, &tmp);
115869 if( pParse->nErr ){ return WRC_Abort; }
115890 findOrCreateAggInfoColumn(pParse, pAggInfo, pExpr);
115915 u8 enc = ENC(pParse->db);
115916 i = addAggInfoFunc(pParse->db, pAggInfo);
115924 pItem->pFunc = sqlite3FindFunction(pParse->db,
115936 pItem->iOBTab = pParse->nTab++;
115956 pItem->iDistinct = pParse->nTab++;
115993 w.pParse = 0;
116017 SQLITE_PRIVATE int sqlite3GetTempReg(Parse *pParse){
116018 if( pParse->nTempReg==0 ){
116019 return ++pParse->nMem;
116021 return pParse->aTempReg[--pParse->nTempReg];
116028 SQLITE_PRIVATE void sqlite3ReleaseTempReg(Parse *pParse, int iReg){
116030 sqlite3VdbeReleaseRegisters(pParse, iReg, 1, 0, 0);
116031 if( pParse->nTempReg<ArraySize(pParse->aTempReg) ){
116032 pParse->aTempReg[pParse->nTempReg++] = iReg;
116040 SQLITE_PRIVATE int sqlite3GetTempRange(Parse *pParse, int nReg){
116042 if( nReg==1 ) return sqlite3GetTempReg(pParse);
116043 i = pParse->iRangeReg;
116044 n = pParse->nRangeReg;
116046 pParse->iRangeReg += nReg;
116047 pParse->nRangeReg -= nReg;
116049 i = pParse->nMem+1;
116050 pParse->nMem += nReg;
116054 SQLITE_PRIVATE void sqlite3ReleaseTempRange(Parse *pParse, int iReg, int nReg){
116056 sqlite3ReleaseTempReg(pParse, iReg);
116059 sqlite3VdbeReleaseRegisters(pParse, iReg, nReg, 0, 0);
116060 if( nReg>pParse->nRangeReg ){
116061 pParse->nRangeReg = nReg;
116062 pParse->iRangeReg = iReg;
116074 SQLITE_PRIVATE void sqlite3ClearTempRegCache(Parse *pParse){
116075 pParse->nTempReg = 0;
116076 pParse->nRangeReg = 0;
116083 SQLITE_PRIVATE void sqlite3TouchRegister(Parse *pParse, int iReg){
116084 if( pParse->nMem<iReg ) pParse->nMem = iReg;
116094 SQLITE_PRIVATE int sqlite3FirstAvailableRegister(Parse *pParse, int iMin){
116095 const ExprList *pList = pParse->pConstExpr;
116104 pParse->nTempReg = 0;
116105 pParse->nRangeReg = 0;
116116 SQLITE_PRIVATE int sqlite3NoTempsInRange(Parse *pParse, int iFirst, int iLast){
116118 if( pParse->nRangeReg>0
116119 && pParse->iRangeReg+pParse->nRangeReg > iFirst
116120 && pParse->iRangeReg <= iLast
116124 for(i=0; i<pParse->nTempReg; i++){
116125 if( pParse->aTempReg[i]>=iFirst && pParse->aTempReg[i]<=iLast ){
116129 if( pParse->pConstExpr ){
116130 ExprList *pList = pParse->pConstExpr;
116169 ** in pParse->zErr (system tables may not be altered) and returns non-zero.
116173 static int isAlterableTable(Parse *pParse, Table *pTab){
116178 && sqlite3ReadOnlyShadowTables(pParse->db)
116182 sqlite3ErrorMsg(pParse, "table %s may not be altered", pTab->zName);
116196 Parse *pParse, /* Parse context */
116202 pParse->colNamesSet = 1;
116203 sqlite3NestedParse(pParse,
116214 sqlite3NestedParse(pParse,
116232 static void renameFixQuotes(Parse *pParse, const char *zDb, int bTemp){
116233 sqlite3NestedParse(pParse,
116240 sqlite3NestedParse(pParse,
116253 static void renameReloadSchema(Parse *pParse, int iDb, u16 p5){
116254 Vdbe *v = pParse->pVdbe;
116256 sqlite3ChangeCookie(pParse, iDb);
116257 sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, iDb, 0, p5);
116258 if( iDb!=1 ) sqlite3VdbeAddParseSchemaOp(pParse->pVdbe, 1, 0, p5);
116267 Parse *pParse, /* Parser context. */
116275 sqlite3 *db = pParse->db; /* Database connection */
116283 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
116285 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
116287 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
116301 sqlite3ErrorMsg(pParse,
116309 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
116312 if( SQLITE_OK!=sqlite3CheckObjectName(pParse,zName,"table",zName) ){
116318 sqlite3ErrorMsg(pParse, "view %s may not be altered", pTab->zName);
116325 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
116331 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
116346 v = sqlite3GetVdbe(pParse);
116350 sqlite3MayAbort(pParse);
116358 sqlite3NestedParse(pParse,
116368 sqlite3NestedParse(pParse,
116389 sqlite3NestedParse(pParse,
116399 sqlite3NestedParse(pParse,
116417 int i = ++pParse->nMem;
116423 renameReloadSchema(pParse, iDb, INITFLAG_AlterRename);
116424 renameTestSchema(pParse, zDb, iDb==1, "after rename", 0);
116436 Parse *pParse, /* Parsing context */
116441 sqlite3NestedParse(pParse,
116452 ** The Table structure pParse->pNewTable was extended to include
116455 SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
116456 Table *pNew; /* Copy of pParse->pNewTable */
116468 db = pParse->db;
116469 assert( db->pParse==pParse );
116470 if( pParse->nErr ) return;
116472 pNew = pParse->pNewTable;
116486 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
116497 sqlite3ErrorMsg(pParse, "Cannot add a PRIMARY KEY column");
116501 sqlite3ErrorMsg(pParse,
116516 sqlite3ErrorIfNotEmpty(pParse, zDb, zTab,
116520 sqlite3ErrorIfNotEmpty(pParse, zDb, zTab,
116538 sqlite3ErrorIfNotEmpty(pParse, zDb, zTab,
116544 sqlite3ErrorIfNotEmpty(pParse, zDb, zTab, "cannot add a STORED column");
116559 sqlite3NestedParse(pParse,
116570 v = sqlite3GetVdbe(pParse);
116576 r1 = sqlite3GetTempReg(pParse);
116583 sqlite3ReleaseTempReg(pParse, r1);
116586 renameReloadSchema(pParse, iDb, INITFLAG_AlterAdd);
116593 sqlite3NestedParse(pParse,
116625 SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
116631 sqlite3 *db = pParse->db;
116634 assert( pParse->pNewTable==0 );
116637 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
116642 sqlite3ErrorMsg(pParse, "virtual tables may not be altered");
116649 sqlite3ErrorMsg(pParse, "Cannot add a column to a view");
116652 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ){
116656 sqlite3MayAbort(pParse);
116670 pParse->pNewTable = pNew;
116703 ** it loads an error message into pParse and returns non-zero.
116708 static int isRealTable(Parse *pParse, Table *pTab, int bDrop){
116721 sqlite3ErrorMsg(pParse, "cannot %s %s \"%s\"",
116739 Parse *pParse, /* Parsing context */
116744 sqlite3 *db = pParse->db; /* Database connection */
116754 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
116758 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_rename_column;
116759 if( SQLITE_OK!=isRealTable(pParse, pTab, 0) ) goto exit_rename_column;
116768 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, 0) ){
116781 sqlite3ErrorMsg(pParse, "no such column: \"%T\"", pOld);
116786 renameTestSchema(pParse, zDb, iSchema==1, "", 0);
116787 renameFixQuotes(pParse, zDb, iSchema==1);
116793 sqlite3MayAbort(pParse);
116798 sqlite3NestedParse(pParse,
116808 sqlite3NestedParse(pParse,
116816 renameReloadSchema(pParse, iSchema, INITFLAG_AlterRename);
116817 renameTestSchema(pParse, zDb, iSchema==1, "after rename", 1);
116886 static void renameTokenCheckAll(Parse *pParse, const void *pPtr){
116887 assert( pParse==pParse->db->pParse );
116888 assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 );
116889 if( pParse->nErr==0 ){
116892 for(p=pParse->pRename; p; p=p->pNext){
116911 ** in pParse->pRename.
116918 Parse *pParse,
116923 assert( pPtr || pParse->db->mallocFailed );
116924 renameTokenCheckAll(pParse, pPtr);
116925 if( ALWAYS(pParse->eParseMode!=PARSE_MODE_UNMAP) ){
116926 pNew = sqlite3DbMallocZero(pParse->db, sizeof(RenameToken));
116930 pNew->pNext = pParse->pRename;
116931 pParse->pRename = pNew;
116943 SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse *pParse, const void *pTo, const void *pFrom){
116945 renameTokenCheckAll(pParse, pTo);
116946 for(p=pParse->pRename; p; p=p->pNext){
116958 Parse *pParse = pWalker->pParse;
116959 sqlite3RenameTokenRemap(pParse, 0, (const void*)pExpr);
116961 sqlite3RenameTokenRemap(pParse, 0, (const void*)&pExpr->y.pTab);
116973 Parse *pParse = pWalker->pParse;
116983 pCopy = sqlite3WithDup(pParse->db, pWith);
116984 pCopy = sqlite3WithPush(pParse, pCopy, 1);
116990 sNC.pParse = pParse;
116991 if( pCopy ) sqlite3SelectPrep(sNC.pParse, p, &sNC);
116992 if( sNC.pParse->db->mallocFailed ) return;
116994 sqlite3RenameExprlistUnmap(pParse, pWith->a[i].pCols);
116996 if( pCopy && pParse->pWith==pCopy ){
116997 pParse->pWith = pCopy->pOuter;
117006 Parse *pParse,
117012 sqlite3RenameTokenRemap(pParse, 0, (const void*)pIdList->a[ii].zName);
117020 Parse *pParse = pWalker->pParse;
117022 if( pParse->nErr ) return WRC_Abort;
117032 sqlite3RenameTokenRemap(pParse, 0, (void*)pList->a[i].zEName);
117039 sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
117043 unmapColumnIdlistNames(pParse, pSrc->a[i].u3.pUsing);
117055 SQLITE_PRIVATE void sqlite3RenameExprUnmap(Parse *pParse, Expr *pExpr){
117056 u8 eMode = pParse->eParseMode;
117059 sWalker.pParse = pParse;
117062 pParse->eParseMode = PARSE_MODE_UNMAP;
117064 pParse->eParseMode = eMode;
117071 SQLITE_PRIVATE void sqlite3RenameExprlistUnmap(Parse *pParse, ExprList *pEList){
117076 sWalker.pParse = pParse;
117081 sqlite3RenameTokenRemap(pParse, 0, (void*)pEList->a[i].zEName);
117109 Parse *pParse,
117117 for(pp=&pParse->pRename; (*pp); pp=&(*pp)->pNext){
117160 && pWalker->pParse->pTriggerTab==p->pTab
117162 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
117168 renameTokenFind(pWalker->pParse, p, (void*)pExpr);
117198 ** object (either pParse->pNewTable, pNewIndex or pNewTrigger) as part of an
117200 ** sub-routine is currently stored in pParse->zErrMsg. This function
117208 Parse *pParse
117214 zErr = sqlite3MPrintf(pParse->db, "error in %s %s%s%s: %s",
117216 pParse->zErrMsg
117219 sqlite3DbFree(pParse->db, zErr);
117225 ** corresponding rename-token from Parse object pParse and add it
117229 Parse *pParse,
117242 renameTokenFind(pParse, pCtx, (const void*)zName);
117251 ** from Parse object pParse and add it to the RenameCtx pCtx.
117254 Parse *pParse,
117264 renameTokenFind(pParse, pCtx, (const void*)zName);
117443 ** Resolve all symbols in the trigger at pParse->pNewTrigger, assuming
117448 static int renameResolveTrigger(Parse *pParse){
117449 sqlite3 *db = pParse->db;
117450 Trigger *pNew = pParse->pNewTrigger;
117456 sNC.pParse = pParse;
117458 pParse->pTriggerTab = sqlite3FindTable(db, pNew->table,
117461 pParse->eTriggerOp = pNew->op;
117464 if( ALWAYS(pParse->pTriggerTab) ){
117465 rc = sqlite3ViewGetColumnNames(pParse, pParse->pTriggerTab)!=0;
117475 sqlite3SelectPrep(pParse, pStep->pSelect, &sNC);
117476 if( pParse->nErr ) rc = pParse->rc;
117479 SrcList *pSrc = sqlite3TriggerStepSrc(pParse, pStep);
117482 pParse, pStep->pExprList, pSrc, 0, 0, 0, 0, 0, 0
117498 sqlite3SelectPrep(pParse, pSel, 0);
117500 rc = pParse->nErr ? SQLITE_ERROR : SQLITE_OK;
117512 sqlite3SelectPrep(pParse, p->pSelect, 0);
117588 ** Free the contents of Parse object (*pParse). Do not free the memory
117591 static void renameParseCleanup(Parse *pParse){
117592 sqlite3 *db = pParse->db;
117594 if( pParse->pVdbe ){
117595 sqlite3VdbeFinalize(pParse->pVdbe);
117597 sqlite3DeleteTable(db, pParse->pNewTable);
117598 while( (pIdx = pParse->pNewIndex)!=0 ){
117599 pParse->pNewIndex = pIdx->pNext;
117602 sqlite3DeleteTrigger(db, pParse->pNewTrigger);
117603 sqlite3DbFree(db, pParse->zErrMsg);
117604 renameTokenFree(db, pParse->pRename);
117605 sqlite3ParseObjectReset(pParse);
117679 sWalker.pParse = &sParse;
117805 renameTokenFind(pWalker->pParse, p, (void*)&pExpr->y.pTab);
117823 assert( pWalker->pParse->db->mallocFailed );
117829 renameTokenFind(pWalker->pParse, p, pItem->zName);
117887 sWalker.pParse = &sParse;
117904 sNC.pParse = &sParse;
118011 renameTokenFind(pWalker->pParse, pWalker->u.pRename, (const void*)pExpr);
118072 sWalker.pParse = &sParse;
118187 sNC.pParse = &sParse;
118296 SQLITE_PRIVATE void sqlite3AlterDropColumn(Parse *pParse, SrcList *pSrc, const Token *pName){
118297 sqlite3 *db = pParse->db; /* Database handle */
118305 assert( pParse->pNewTable==0 );
118308 pTab = sqlite3LocateTableItem(pParse, 0, &pSrc->a[0]);
118313 if( SQLITE_OK!=isAlterableTable(pParse, pTab) ) goto exit_drop_column;
118314 if( SQLITE_OK!=isRealTable(pParse, pTab, 1) ) goto exit_drop_column;
118324 sqlite3ErrorMsg(pParse, "no such column: \"%T\"", pName);
118331 sqlite3ErrorMsg(pParse, "cannot drop %s column: \"%s\"",
118340 sqlite3ErrorMsg(pParse, "cannot drop column \"%s\": no other columns exist",zCol);
118350 if( sqlite3AuthCheck(pParse, SQLITE_ALTER_TABLE, zDb, pTab->zName, zCol) ){
118354 renameTestSchema(pParse, zDb, iDb==1, "", 0);
118355 renameFixQuotes(pParse, zDb, iDb==1);
118356 sqlite3NestedParse(pParse,
118364 renameReloadSchema(pParse, iDb, INITFLAG_AlterDrop);
118365 renameTestSchema(pParse, zDb, iDb==1, "after drop column", 1);
118368 if( pParse->nErr==0 && (pTab->aCol[iCol].colFlags & COLFLAG_VIRTUAL)==0 ){
118376 Vdbe *v = sqlite3GetVdbe(pParse);
118377 iCur = pParse->nTab++;
118378 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
118380 reg = ++pParse->nMem;
118383 pParse->nMem += pTab->nCol;
118386 pParse->nMem += pPk->nColumn;
118392 regRec = ++pParse->nMem;
118419 pParse->nMem++;
118623 Parse *pParse, /* Parsing context */
118642 sqlite3 *db = pParse->db;
118644 Vdbe *v = sqlite3GetVdbe(pParse);
118669 ** of the new table in register pParse->regRoot. This is important
118671 sqlite3NestedParse(pParse,
118674 aRoot[i] = (u32)pParse->regRoot;
118682 sqlite3TableLock(pParse, iDb, aRoot[i], 1, zTab);
118684 sqlite3NestedParse(pParse,
118690 sqlite3NestedParse(pParse, "DELETE FROM %Q.%s", pDb->zDbSName, zTab);
119390 static void callStatGet(Parse *pParse, int regStat, int iParam, int regOut){
119392 sqlite3VdbeAddOp2(pParse->pVdbe, OP_Integer, iParam, regStat+1);
119399 sqlite3VdbeAddFunctionCall(pParse, 0, regStat, regOut, 1+IsStat4,
119433 Parse *pParse, /* Parser context */
119440 sqlite3 *db = pParse->db; /* Database handle */
119466 sqlite3TouchRegister(pParse, iMem);
119467 assert( sqlite3NoTempsInRange(pParse, regNewRowid, iMem) );
119468 v = sqlite3GetVdbe(pParse);
119485 if( sqlite3AuthCheck(pParse, SQLITE_ANALYZE, pTab->zName, 0,
119499 sqlite3VdbeAddOp4(pParse->pVdbe, OP_Noop, 0, 0, 0,(char*)pStat1,P4_DYNAMIC);
119507 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
119510 pParse->nTab = MAX(pParse->nTab, iTab);
119511 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
119578 sqlite3TouchRegister(pParse, regPrev+nColTest);
119583 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
119611 sqlite3VdbeAddFunctionCall(pParse, 0, regStat+1, regStat, 4,
119620 int endDistinctTest = sqlite3VdbeMakeLabel(pParse);
119645 char *pColl = (char*)sqlite3LocateCollSeq(pParse, pIdx->azColl[i]);
119690 regKey = sqlite3GetTempRange(pParse, pPk->nKeyCol);
119698 sqlite3ReleaseTempRange(pParse, regKey, pPk->nKeyCol);
119704 sqlite3VdbeAddFunctionCall(pParse, 1, regStat, regTemp, 2+IsStat4,
119728 callStatGet(pParse, regStat, STAT_GET_STAT1, regStat1);
119774 sqlite3TouchRegister(pParse, regCol+mxCol);
119781 testcase( !sqlite3NoTempsInRange(pParse, regEq, regCol+mxCol) );
119783 sqlite3ClearTempRegCache(pParse); /* tag-20230325-1 */
119784 assert( sqlite3NoTempsInRange(pParse, regEq, regCol+mxCol) );
119786 assert( sqlite3NoTempsInRange(pParse, regEq, regCol+nCol) );
119789 callStatGet(pParse, regStat, STAT_GET_ROWID, regSampleRowid);
119792 callStatGet(pParse, regStat, STAT_GET_NEQ, regEq);
119793 callStatGet(pParse, regStat, STAT_GET_NLT, regLt);
119794 callStatGet(pParse, regStat, STAT_GET_NDLT, regDLt);
119798 sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iTabCur, i, regCol+i);
119839 static void loadAnalysis(Parse *pParse, int iDb){
119840 Vdbe *v = sqlite3GetVdbe(pParse);
119849 static void analyzeDatabase(Parse *pParse, int iDb){
119850 sqlite3 *db = pParse->db;
119857 sqlite3BeginWriteOperation(pParse, 0, iDb);
119858 iStatCur = pParse->nTab;
119859 pParse->nTab += 3;
119860 openStatTable(pParse, iDb, iStatCur, 0, 0);
119861 iMem = pParse->nMem+1;
119862 iTab = pParse->nTab;
119866 analyzeOneTable(pParse, pTab, 0, iStatCur, iMem, iTab);
119868 iMem = sqlite3FirstAvailableRegister(pParse, iMem);
119870 assert( iMem==sqlite3FirstAvailableRegister(pParse,iMem) );
119873 loadAnalysis(pParse, iDb);
119881 static void analyzeTable(Parse *pParse, Table *pTab, Index *pOnlyIdx){
119886 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
119887 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
119888 sqlite3BeginWriteOperation(pParse, 0, iDb);
119889 iStatCur = pParse->nTab;
119890 pParse->nTab += 3;
119892 openStatTable(pParse, iDb, iStatCur, pOnlyIdx->zName, "idx");
119894 openStatTable(pParse, iDb, iStatCur, pTab->zName, "tbl");
119896 analyzeOneTable(pParse, pTab, pOnlyIdx, iStatCur,pParse->nMem+1,pParse->nTab);
119897 loadAnalysis(pParse, iDb);
119912 SQLITE_PRIVATE void sqlite3Analyze(Parse *pParse, Token *pName1, Token *pName2){
119913 sqlite3 *db = pParse->db;
119923 ** and code in pParse and return NULL. */
119924 assert( sqlite3BtreeHoldsAllMutexes(pParse->db) );
119925 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
119934 analyzeDatabase(pParse, i);
119938 analyzeDatabase(pParse, iDb);
119941 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pTableName);
119947 analyzeTable(pParse, pIdx->pTable, pIdx);
119948 }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
119949 analyzeTable(pParse, pTab, 0);
119955 if( db->nSqlExec==0 && (v = sqlite3GetVdbe(pParse))!=0 ){
120819 Parse *pParse, /* The parser context */
120830 sqlite3* db = pParse->db;
120833 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ) goto attach_end;
120835 if( pParse->nErr ) goto attach_end;
120837 sName.pParse = pParse;
120856 rc = sqlite3AuthCheck(pParse, type, zAuthArg, 0, 0);
120864 v = sqlite3GetVdbe(pParse);
120865 regArgs = sqlite3GetTempRange(pParse, 4);
120866 sqlite3ExprCode(pParse, pFilename, regArgs);
120867 sqlite3ExprCode(pParse, pDbname, regArgs+1);
120868 sqlite3ExprCode(pParse, pKey, regArgs+2);
120872 sqlite3VdbeAddFunctionCall(pParse, 0, regArgs+3-pFunc->nArg, regArgs+3,
120892 SQLITE_PRIVATE void sqlite3Detach(Parse *pParse, Expr *pDbname){
120904 codeAttach(pParse, SQLITE_DETACH, &detach_func, pDbname, 0, 0, pDbname);
120912 SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
120924 codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
120935 if( pFix->pParse->db->init.busy ){
120938 sqlite3ErrorMsg(pFix->pParse, "%s cannot use variables", pFix->zType);
120952 sqlite3 *db = pFix->pParse->db;
120961 sqlite3ErrorMsg(pFix->pParse,
120997 Parse *pParse, /* Error messages will be written here */
121002 sqlite3 *db = pParse->db;
121004 pFix->pParse = pParse;
121010 pFix->w.pParse = pParse;
121030 ** pParse->zErrMsg and these routines return non-zero. If everything
121183 ** Write an error message into pParse->zErrMsg that explains that the
121186 static void sqliteAuthBadReturnCode(Parse *pParse){
121187 sqlite3ErrorMsg(pParse, "authorizer malfunction");
121188 pParse->rc = SQLITE_ERROR;
121198 ** is treated as SQLITE_DENY. In this case an error is left in pParse.
121201 Parse *pParse, /* The parser context */
121206 sqlite3 *db = pParse->db; /* Database handle */
121211 rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext
121219 sqlite3ErrorMsg(pParse, "access to %z is prohibited", z);
121220 pParse->rc = SQLITE_AUTH;
121222 sqliteAuthBadReturnCode(pParse);
121237 Parse *pParse, /* The parser context */
121250 assert( pParse->db->xAuth!=0 );
121251 iDb = sqlite3SchemaToIndex(pParse->db, pSchema);
121259 pTab = pParse->pTriggerTab;
121281 assert( iDb>=0 && iDb<pParse->db->nDb );
121282 if( SQLITE_IGNORE==sqlite3AuthReadCol(pParse, pTab->zName, zCol, iDb) ){
121290 ** is returned, then the error count and error message in pParse are
121294 Parse *pParse,
121300 sqlite3 *db = pParse->db;
121320 testcase( pParse->zAuthContext==0 );
121322 rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext
121328 sqlite3ErrorMsg(pParse, "not authorized");
121329 pParse->rc = SQLITE_AUTH;
121332 sqliteAuthBadReturnCode(pParse);
121340 ** popped. Or if pParse==0, this routine is a no-op.
121343 Parse *pParse,
121347 assert( pParse );
121348 pContext->pParse = pParse;
121349 pContext->zAuthContext = pParse->zAuthContext;
121350 pParse->zAuthContext = zContext;
121358 if( pContext->pParse ){
121359 pContext->pParse->zAuthContext = pContext->zAuthContext;
121360 pContext->pParse = 0;
121417 Parse *pParse, /* Parsing context */
121429 pToplevel = sqlite3ParseToplevel(pParse);
121453 Parse *pParse, /* Parsing context */
121460 if( !sqlite3BtreeSharable(pParse->db->aDb[iDb].pBt) ) return;
121461 lockTable(pParse, iDb, iTab, isWriteLock, zName);
121468 static void codeTableLocks(Parse *pParse){
121470 Vdbe *pVdbe = pParse->pVdbe;
121473 for(i=0; i<pParse->nTableLock; i++){
121474 TableLock *p = &pParse->aTableLock[i];
121501 ** VDBE program and resets the pParse structure for the next
121507 SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){
121512 assert( pParse->pToplevel==0 );
121513 db = pParse->db;
121514 assert( db->pParse==pParse );
121515 if( pParse->nested ) return;
121516 if( pParse->nErr ){
121517 if( db->mallocFailed ) pParse->rc = SQLITE_NOMEM;
121525 v = pParse->pVdbe;
121528 pParse->rc = SQLITE_DONE;
121531 v = sqlite3GetVdbe(pParse);
121532 if( v==0 ) pParse->rc = SQLITE_ERROR;
121534 assert( !pParse->isMultiWrite
121535 || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
121537 if( pParse->bReturning ){
121538 Returning *pReturning = pParse->u1.pReturning;
121560 if( pParse->nTableLock>0 && db->init.busy==0 ){
121563 sqlite3ErrorMsg(pParse, "user not authenticated");
121564 pParse->rc = SQLITE_AUTH_USER;
121576 assert( pParse->nErr>0 || sqlite3VdbeGetOp(v, 0)->opcode==OP_Init );
121582 if( DbMaskTest(pParse->cookieMask, iDb)==0 ) continue;
121588 DbMaskTest(pParse->writeMask,iDb), /* P2 */
121594 "usesStmtJournal=%d", pParse->mayAbort && pParse->isMultiWrite));
121597 for(i=0; i<pParse->nVtabLock; i++){
121598 char *vtab = (char *)sqlite3GetVTable(db, pParse->apVtabLock[i]);
121601 pParse->nVtabLock = 0;
121609 if( pParse->nTableLock ) codeTableLocks(pParse);
121614 if( pParse->pAinc ) sqlite3AutoincrementBegin(pParse);
121618 if( pParse->pConstExpr ){
121619 ExprList *pEL = pParse->pConstExpr;
121620 pParse->okConstFactor = 0;
121623 sqlite3ExprCode(pParse, pEL->a[i].pExpr, pEL->a[i].u.iConstExprReg);
121627 if( pParse->bReturning ){
121628 Returning *pRet = pParse->u1.pReturning;
121640 assert( v!=0 || pParse->nErr );
121641 assert( db->mallocFailed==0 || pParse->nErr );
121642 if( pParse->nErr==0 ){
121645 assert( pParse->pAinc==0 || pParse->nTab>0 );
121646 sqlite3VdbeMakeReady(v, pParse);
121647 pParse->rc = SQLITE_DONE;
121649 pParse->rc = SQLITE_ERROR;
121655 ** code for the SQL statement given onto the end of the pParse context
121666 SQLITE_PRIVATE void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
121669 sqlite3 *db = pParse->db;
121673 if( pParse->nErr ) return;
121674 if( pParse->eParseMode ) return;
121675 assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
121683 if( !db->mallocFailed ) pParse->rc = SQLITE_TOOBIG;
121684 pParse->nErr++;
121687 pParse->nested++;
121688 memcpy(saveBuf, PARSE_TAIL(pParse), PARSE_TAIL_SZ);
121689 memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
121691 sqlite3RunParser(pParse, zSql);
121694 memcpy(PARSE_TAIL(pParse), saveBuf, PARSE_TAIL_SZ);
121695 pParse->nested--;
121792 ** error message in pParse->zErrMsg.
121795 ** routine leaves an error message in pParse->zErrMsg where
121799 Parse *pParse, /* context in which to report errors */
121805 sqlite3 *db = pParse->db;
121808 ** and code in pParse and return NULL. */
121810 && SQLITE_OK!=sqlite3ReadSchema(pParse)
121821 if( (pParse->prepFlags & SQLITE_PREPARE_NO_VTAB)==0 && db->init.busy==0 ){
121826 if( pMod && sqlite3VtabEponymousTableInit(pParse, pMod) ){
121833 pParse->checkSchema = 1;
121834 }else if( IsVirtual(p) && (pParse->prepFlags & SQLITE_PREPARE_NO_VTAB)!=0 ){
121841 sqlite3ErrorMsg(pParse, "%s: %s.%s", zMsg, zDbase, zName);
121843 sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
121862 Parse *pParse,
121869 int iDb = sqlite3SchemaToIndex(pParse->db, p->pSchema);
121870 zDb = pParse->db->aDb[iDb].zDbSName;
121874 return sqlite3LocateTable(pParse, flags, p->zName, zDb);
122063 Parse *pParse, /* Parsing context */
122076 pTab->u.tab.pDfltList = sqlite3ExprListAppend(pParse, pList, pExpr);
122078 sqlite3ExprDelete(pParse->db, pList->a[pCol->iDflt-1].pExpr);
122356 Parse *pParse, /* Parsing and code generating context */
122362 sqlite3 *db = pParse->db;
122367 sqlite3ErrorMsg(pParse, "corrupt database");
122373 sqlite3ErrorMsg(pParse, "unknown database %T", pName1);
122411 Parse *pParse, /* Parsing context */
122416 sqlite3 *db = pParse->db;
122429 sqlite3ErrorMsg(pParse, ""); /* corruptSchema() will supply the error */
122433 if( (pParse->nested==0 && 0==sqlite3StrNICmp(zName, "sqlite_", 7))
122436 sqlite3ErrorMsg(pParse, "object name reserved for internal use: %s",
122554 static void sqlite3ForceNotReadOnly(Parse *pParse){
122555 int iReg = ++pParse->nMem;
122556 Vdbe *v = sqlite3GetVdbe(pParse);
122573 ** The new table record is initialized and put in pParse->pNewTable.
122580 Parse *pParse, /* Parser context */
122590 sqlite3 *db = pParse->db;
122602 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
122607 sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
122613 sqlite3RenameTokenMap(pParse, (void*)zName, pName);
122616 pParse->sNameToken = *pName;
122618 if( sqlite3CheckObjectName(pParse, zName, isView?"view":"table", zName) ){
122633 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
122636 if( !isVirtual && sqlite3AuthCheck(pParse, (int)aCode[isTemp+2*isView],
122652 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
122658 sqlite3ErrorMsg(pParse, "%s %T already exists",
122662 sqlite3CodeVerifySchema(pParse, iDb);
122663 sqlite3ForceNotReadOnly(pParse);
122668 sqlite3ErrorMsg(pParse, "there is already an index named %s", zName);
122676 pParse->rc = SQLITE_NOMEM_BKPT;
122677 pParse->nErr++;
122689 assert( pParse->pNewTable==0 );
122690 pParse->pNewTable = pTable;
122700 if( !db->init.busy && (v = sqlite3GetVdbe(pParse))!=0 ){
122706 sqlite3BeginWriteOperation(pParse, 1, iDb);
122717 reg1 = pParse->regRowid = ++pParse->nMem;
122718 reg2 = pParse->regRoot = ++pParse->nMem;
122719 reg3 = ++pParse->nMem;
122733 ** The rowid for the new entry is left in register pParse->regRowid.
122734 ** The root page number of the new table is left in reg pParse->regRoot.
122744 assert( !pParse->bReturning );
122745 pParse->u1.addrCrTab =
122748 sqlite3OpenSchemaTable(pParse, iDb);
122761 pParse->checkSchema = 1;
122808 SQLITE_PRIVATE void sqlite3AddReturning(Parse *pParse, ExprList *pList){
122811 sqlite3 *db = pParse->db;
122812 if( pParse->pNewTrigger ){
122813 sqlite3ErrorMsg(pParse, "cannot use RETURNING in a trigger");
122815 assert( pParse->bReturning==0 || pParse->ifNotExists );
122817 pParse->bReturning = 1;
122823 pParse->u1.pReturning = pRet;
122824 pRet->pParse = pParse;
122826 sqlite3ParserAddCleanup(pParse, sqlite3DeleteReturning, pRet);
122827 testcase( pParse->earlyCleanup );
122830 "sqlite_returning_%p", pParse);
122843 || pParse->nErr || pParse->ifNotExists );
122858 SQLITE_PRIVATE void sqlite3AddColumn(Parse *pParse, Token sName, Token sType){
122864 sqlite3 *db = pParse->db;
122871 if( (p = pParse->pNewTable)==0 ) return;
122873 sqlite3ErrorMsg(pParse, "too many columns on %s", p->zName);
122915 if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, &sName);
122922 sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
122962 pParse->constraintName.n = 0;
122971 SQLITE_PRIVATE void sqlite3AddNotNull(Parse *pParse, int onError){
122974 p = pParse->pNewTable;
123097 Parse *pParse, /* Parsing context */
123104 sqlite3 *db = pParse->db;
123105 p = pParse->pNewTable;
123110 sqlite3ErrorMsg(pParse, "default value of column [%s] is not constant",
123116 sqlite3ErrorMsg(pParse, "cannot use DEFAULT on a generated column");
123130 sqlite3ColumnSetExpr(pParse, p, pCol, pDfltExpr);
123134 sqlite3RenameExprUnmap(pParse, pExpr);
123166 static void makeColumnPartOfPrimaryKey(Parse *pParse, Column *pCol){
123172 sqlite3ErrorMsg(pParse,
123197 Parse *pParse, /* Parsing context */
123203 Table *pTab = pParse->pNewTable;
123209 sqlite3ErrorMsg(pParse,
123217 makeColumnPartOfPrimaryKey(pParse, pCol);
123232 makeColumnPartOfPrimaryKey(pParse, pCol);
123246 sqlite3RenameTokenRemap(pParse, &pTab->iPKey, pCExpr);
123252 if( pList ) pParse->iPkSortOrder = pList->a[0].fg.sortFlags;
123253 (void)sqlite3HasExplicitNulls(pParse, pList);
123256 sqlite3ErrorMsg(pParse, "AUTOINCREMENT is only allowed on an "
123260 sqlite3CreateIndex(pParse, 0, 0, 0, pList, onError, 0,
123266 sqlite3ExprListDelete(pParse->db, pList);
123274 Parse *pParse, /* Parsing context */
123280 Table *pTab = pParse->pNewTable;
123281 sqlite3 *db = pParse->db;
123285 pTab->pCheck = sqlite3ExprListAppend(pParse, pTab->pCheck, pCheckExpr);
123286 if( pParse->constraintName.n ){
123287 sqlite3ExprListSetName(pParse, pTab->pCheck, &pParse->constraintName, 1);
123294 sqlite3ExprListSetName(pParse, pTab->pCheck, &t, 1);
123299 sqlite3ExprDelete(pParse->db, pCheckExpr);
123307 SQLITE_PRIVATE void sqlite3AddCollateType(Parse *pParse, Token *pToken){
123313 if( (p = pParse->pNewTable)==0 || IN_RENAME_OBJECT ) return;
123315 db = pParse->db;
123319 if( sqlite3LocateCollSeq(pParse, zColl) ){
123340 SQLITE_PRIVATE void sqlite3AddGenerated(Parse *pParse, Expr *pExpr, Token *pType){
123343 Table *pTab = pParse->pNewTable;
123351 sqlite3ErrorMsg(pParse, "virtual tables cannot use computed columns");
123370 makeColumnPartOfPrimaryKey(pParse, pCol); /* For the error message */
123377 pExpr = sqlite3PExpr(pParse, TK_UPLUS, pExpr, 0);
123380 sqlite3ColumnSetExpr(pParse, pTab, pCol, pExpr);
123385 sqlite3ErrorMsg(pParse, "error in generated column \"%s\"",
123388 sqlite3ExprDelete(pParse->db, pExpr);
123392 sqlite3ErrorMsg(pParse, "generated columns not supported");
123393 sqlite3ExprDelete(pParse->db, pExpr);
123416 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
123417 sqlite3 *db = pParse->db;
123418 Vdbe *v = pParse->pVdbe;
123711 static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
123717 sqlite3 *db = pParse->db;
123718 Vdbe *v = pParse->pVdbe;
123736 assert( !pParse->bReturning );
123737 if( pParse->u1.addrCrTab ){
123739 sqlite3VdbeChangeP3(v, pParse->u1.addrCrTab, BTREE_BLOBKEY);
123749 pList = sqlite3ExprListAppend(pParse, 0,
123756 sqlite3RenameTokenRemap(pParse, pList->a[0].pExpr, &pTab->iPKey);
123758 pList->a[0].fg.sortFlags = pParse->iPkSortOrder;
123759 assert( pParse->pNewTable==pTab );
123761 sqlite3CreateIndex(pParse, 0, 0, 0, pList, pTab->keyConf, 0, 0, 0, 0,
123763 if( pParse->nErr ){
123993 Parse *pParse, /* Parse context */
124000 sqlite3 *db = pParse->db; /* The database connection */
124007 p = pParse->pNewTable;
124025 sqlite3ErrorMsg(pParse, "");
124048 sqlite3ErrorMsg(pParse,
124053 sqlite3ErrorMsg(pParse, "missing datatype for %s.%s",
124078 sqlite3ErrorMsg(pParse,
124083 sqlite3ErrorMsg(pParse, "PRIMARY KEY missing on table %s", p->zName);
124087 convertToWithoutRowidTable(pParse, p);
124095 sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, p->pCheck);
124096 if( pParse->nErr ){
124117 if( sqlite3ResolveSelfReference(pParse, p, NC_GenCol, pX, 0) ){
124124 sqlite3ColumnSetExpr(pParse, p, &p->aCol[ii],
124132 sqlite3ErrorMsg(pParse, "must have at least one non-generated column");
124157 v = sqlite3GetVdbe(pParse);
124179 ** new table is in register pParse->regRoot.
124201 pParse->rc = SQLITE_ERROR;
124202 pParse->nErr++;
124205 iCsr = pParse->nTab++;
124206 regYield = ++pParse->nMem;
124207 regRec = ++pParse->nMem;
124208 regRowid = ++pParse->nMem;
124209 sqlite3MayAbort(pParse);
124210 sqlite3VdbeAddOp3(v, OP_OpenWrite, iCsr, pParse->regRoot, iDb);
124214 if( pParse->nErr ) return;
124215 pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect, SQLITE_AFF_BLOB);
124224 sqlite3Select(pParse, pSelect, &dest);
124225 if( pParse->nErr ) return;
124243 Token *pEnd2 = tabOpts ? &pParse->sLastToken : pEnd;
124244 n = (int)(pEnd2->z - pParse->sNameToken.z);
124247 "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
124255 sqlite3NestedParse(pParse,
124263 pParse->regRoot,
124265 pParse->regRowid
124268 sqlite3ChangeCookie(pParse, iDb);
124278 sqlite3NestedParse(pParse,
124312 pParse->pNewTable = 0;
124318 assert( !pParse->nested );
124333 p->u.tab.addColOffset = 13 + (int)(pCons->z - pParse->sNameToken.z);
124343 Parse *pParse, /* The parsing context */
124359 sqlite3 *db = pParse->db;
124361 if( pParse->nVar>0 ){
124362 sqlite3ErrorMsg(pParse, "parameters are not allowed in views");
124365 sqlite3StartTable(pParse, pName1, pName2, isTemp, 1, 0, noErr);
124366 p = pParse->pNewTable;
124367 if( p==0 || pParse->nErr ) goto create_view_fail;
124381 sqlite3TwoPartName(pParse, pName1, pName2, &pName);
124383 sqlite3FixInit(&sFix, pParse, iDb, "view", pName);
124405 sEnd = pParse->sLastToken;
124419 sqlite3EndTable(pParse, 0, &sEnd, 0, 0);
124424 sqlite3RenameExprlistUnmap(pParse, pCNames);
124436 ** in pParse->zErrMsg.
124438 static SQLITE_NOINLINE int viewGetColumnNames(Parse *pParse, Table *pTable){
124442 sqlite3 *db = pParse->db; /* Database connection for malloc errors */
124455 rc = sqlite3VtabCallConnect(pParse, pTable);
124484 sqlite3ErrorMsg(pParse, "view %s is circularly defined", pTable->zName);
124499 u8 eParseMode = pParse->eParseMode;
124500 int nTab = pParse->nTab;
124501 int nSelect = pParse->nSelect;
124502 pParse->eParseMode = PARSE_MODE_NORMAL;
124503 sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
124509 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE);
124512 pSelTab = sqlite3ResultSetOfSelect(pParse, pSel, SQLITE_AFF_NONE);
124514 pParse->nTab = nTab;
124515 pParse->nSelect = nSelect;
124526 sqlite3ColumnsFromExprList(pParse, pTable->pCheck,
124528 if( pParse->nErr==0
124532 sqlite3SubqueryColumnTypes(pParse, pTable, pSel, SQLITE_AFF_NONE);
124550 pParse->eParseMode = eParseMode;
124559 return nErr + pParse->nErr;
124561 SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
124564 return viewGetColumnNames(pParse, pTable);
124636 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
124637 Vdbe *v = sqlite3GetVdbe(pParse);
124638 int r1 = sqlite3GetTempReg(pParse);
124639 if( iTable<2 ) sqlite3ErrorMsg(pParse, "corrupt schema");
124641 sqlite3MayAbort(pParse);
124652 sqlite3NestedParse(pParse,
124655 pParse->db->aDb[iDb].zDbSName, iTable, r1, r1);
124657 sqlite3ReleaseTempReg(pParse, r1);
124666 static void destroyTable(Parse *pParse, Table *pTab){
124703 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
124704 assert( iDb>=0 && iDb<pParse->db->nDb );
124705 destroyRootPage(pParse, iLargest, iDb);
124716 Parse *pParse, /* The parsing context */
124722 const char *zDbName = pParse->db->aDb[iDb].zDbSName;
124726 if( sqlite3FindTable(pParse->db, zTab, zDbName) ){
124727 sqlite3NestedParse(pParse,
124738 SQLITE_PRIVATE void sqlite3CodeDropTable(Parse *pParse, Table *pTab, int iDb, int isView){
124740 sqlite3 *db = pParse->db;
124744 v = sqlite3GetVdbe(pParse);
124746 sqlite3BeginWriteOperation(pParse, 1, iDb);
124758 pTrigger = sqlite3TriggerList(pParse, pTab);
124762 sqlite3DropTriggerPtr(pParse, pTrigger);
124773 sqlite3NestedParse(pParse,
124787 sqlite3NestedParse(pParse,
124792 destroyTable(pParse, pTab);
124800 sqlite3MayAbort(pParse);
124803 sqlite3ChangeCookie(pParse, iDb);
124846 SQLITE_PRIVATE void sqlite3DropTable(Parse *pParse, SrcList *pName, int isView, int noErr){
124849 sqlite3 *db = pParse->db;
124855 assert( pParse->nErr==0 );
124857 if( sqlite3ReadSchema(pParse) ) goto exit_drop_table;
124860 pTab = sqlite3LocateTableItem(pParse, isView, &pName->a[0]);
124865 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
124866 sqlite3ForceNotReadOnly(pParse);
124876 if( IsVirtual(pTab) && sqlite3ViewGetColumnNames(pParse, pTab) ){
124885 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){
124906 if( sqlite3AuthCheck(pParse, code, pTab->zName, zArg2, zDb) ){
124909 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){
124915 sqlite3ErrorMsg(pParse, "table %s may not be dropped", pTab->zName);
124924 sqlite3ErrorMsg(pParse, "use DROP TABLE to delete table %s", pTab->zName);
124928 sqlite3ErrorMsg(pParse, "use DROP VIEW to delete view %s", pTab->zName);
124936 v = sqlite3GetVdbe(pParse);
124938 sqlite3BeginWriteOperation(pParse, 1, iDb);
124940 sqlite3ClearStatTables(pParse, iDb, "tbl", pTab->zName);
124941 sqlite3FkDropTable(pParse, pName, pTab);
124943 sqlite3CodeDropTable(pParse, pTab, iDb, isView);
124961 ** under construction in the pParse->pNewTable field.
124967 Parse *pParse, /* Parsing context */
124973 sqlite3 *db = pParse->db;
124977 Table *p = pParse->pNewTable;
124989 sqlite3ErrorMsg(pParse, "foreign key on %s"
124996 sqlite3ErrorMsg(pParse,
125019 sqlite3RenameTokenMap(pParse, (void*)z, pTo);
125038 sqlite3ErrorMsg(pParse,
125044 sqlite3RenameTokenRemap(pParse, &pFKey->aCol[i], pFromCol->a[i].zEName);
125053 sqlite3RenameTokenRemap(pParse, z, pToCol->a[i].zEName);
125098 SQLITE_PRIVATE void sqlite3DeferForeignKey(Parse *pParse, int isDeferred){
125102 if( (pTab = pParse->pNewTable)==0 ) return;
125121 static void sqlite3RefillIndex(Parse *pParse, Index *pIndex, int memRootPage){
125123 int iTab = pParse->nTab++; /* Btree cursor used for pTab */
125124 int iIdx = pParse->nTab++; /* Btree cursor used for pIndex */
125133 sqlite3 *db = pParse->db; /* The database connection */
125137 if( sqlite3AuthCheck(pParse, SQLITE_REINDEX, pIndex->zName, 0,
125144 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
125146 v = sqlite3GetVdbe(pParse);
125153 pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
125154 assert( pKey!=0 || pParse->nErr );
125157 iSorter = pParse->nTab++;
125163 sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
125165 regRecord = sqlite3GetTempReg(pParse);
125166 sqlite3MultiWrite(pParse);
125168 sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
125170 sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel);
125185 sqlite3UniqueConstraint(pParse, OE_Abort, pIndex);
125195 sqlite3MayAbort(pParse);
125211 sqlite3ReleaseTempReg(pParse, regRecord);
125258 ** pParse and return non-zero. Otherwise, return zero.
125260 SQLITE_PRIVATE int sqlite3HasExplicitNulls(Parse *pParse, ExprList *pList){
125266 sqlite3ErrorMsg(pParse, "unsupported use of NULLS %s",
125280 ** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable
125281 ** as the table to be indexed. pParse->pNewTable is a table that is
125289 Parse *pParse, /* All information about this parse */
125292 SrcList *pTblName, /* Table to index. Use pParse->pNewTable if 0 */
125308 sqlite3 *db = pParse->db;
125318 assert( db->pParse==pParse );
125319 if( pParse->nErr ){
125326 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
125329 if( sqlite3HasExplicitNulls(pParse, pList) ){
125343 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
125353 pTab = sqlite3SrcListLookup(pParse, pTblName);
125360 sqlite3FixInit(&sFix, pParse, iDb, "index", pName);
125366 pTab = sqlite3LocateTableItem(pParse, 0, &pTblName->a[0]);
125370 sqlite3ErrorMsg(pParse,
125379 pTab = pParse->pNewTable;
125393 sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
125398 sqlite3ErrorMsg(pParse, "views may not be indexed");
125404 sqlite3ErrorMsg(pParse, "virtual tables may not be indexed");
125426 if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName,"index",pTab->zName) ){
125432 sqlite3ErrorMsg(pParse, "there is already a table named %s", zName);
125438 sqlite3ErrorMsg(pParse, "index %s already exists", zName);
125441 sqlite3CodeVerifySchema(pParse, iDb);
125442 sqlite3ForceNotReadOnly(pParse);
125469 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iDb), 0, zDb) ){
125474 if( sqlite3AuthCheck(pParse, i, zName, pTab->zName, zDb) ){
125489 pList = sqlite3ExprListAppend(pParse, 0,
125495 sqlite3ExprListCheckLength(pParse, pList, "index");
125496 if( pParse->nErr ) goto exit_create_index;
125534 sqlite3ResolveSelfReference(pParse, pTab, NC_PartIdx, pPIWhere, 0);
125568 sqlite3ResolveSelfReference(pParse, pTab, NC_IdxExpr, pListItem->pExpr, 0);
125569 if( pParse->nErr ) goto exit_create_index;
125572 if( pTab==pParse->pNewTable ){
125573 sqlite3ErrorMsg(pParse, "expressions prohibited in PRIMARY KEY and "
125616 if( !db->init.busy && !sqlite3LocateCollSeq(pParse, zColl) ){
125648 if( pParse->pNewTable==0 ) estimateIndexWidth(pIndex);
125665 if( pTab==pParse->pNewTable ){
125714 sqlite3ErrorMsg(pParse,
125723 pIndex->pNext = pParse->pNewIndex;
125724 pParse->pNewIndex = pIndex;
125737 assert( pParse->nErr==0 );
125745 sqlite3ErrorMsg(pParse, "invalid rootpage");
125746 pParse->rc = SQLITE_CORRUPT_BKPT;
125776 int iMem = ++pParse->nMem;
125778 v = sqlite3GetVdbe(pParse);
125781 sqlite3BeginWriteOperation(pParse, 1, iDb);
125797 int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n;
125810 sqlite3NestedParse(pParse,
125824 sqlite3RefillIndex(pParse, pIndex, iMem);
125825 sqlite3ChangeCookie(pParse, iDb);
125840 assert( pParse->pNewIndex==0 );
125841 pParse->pNewIndex = pIndex;
125945 SQLITE_PRIVATE void sqlite3DropIndex(Parse *pParse, SrcList *pName, int ifExists){
125948 sqlite3 *db = pParse->db;
125954 assert( pParse->nErr==0 ); /* Never called with prior non-OOM errors */
125956 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
125962 sqlite3ErrorMsg(pParse, "no such index: %S", pName->a);
125964 sqlite3CodeVerifyNamedSchema(pParse, pName->a[0].zDatabase);
125965 sqlite3ForceNotReadOnly(pParse);
125967 pParse->checkSchema = 1;
125971 sqlite3ErrorMsg(pParse, "index associated with UNIQUE "
125982 if( sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
125986 if( sqlite3AuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){
125993 v = sqlite3GetVdbe(pParse);
125995 sqlite3BeginWriteOperation(pParse, 1, iDb);
125996 sqlite3NestedParse(pParse,
126000 sqlite3ClearStatTables(pParse, iDb, "idx", pIndex->zName);
126001 sqlite3ChangeCookie(pParse, iDb);
126002 destroyRootPage(pParse, pIndex->tnum, iDb);
126057 SQLITE_PRIVATE IdList *sqlite3IdListAppend(Parse *pParse, IdList *pList, Token *pToken){
126058 sqlite3 *db = pParse->db;
126076 sqlite3RenameTokenMap(pParse, (void*)pList->a[i].zName, pToken);
126138 ** in pParse.
126141 Parse *pParse, /* Parsing context into which errors are reported */
126158 sqlite3 *db = pParse->db;
126161 sqlite3ErrorMsg(pParse, "too many FROM clause terms, max: %d",
126230 Parse *pParse, /* Parsing context, in which errors are reported */
126238 assert( pParse!=0 );
126239 assert( pParse->db!=0 );
126240 db = pParse->db;
126242 pList = sqlite3DbMallocRawNN(pParse->db, sizeof(SrcList) );
126249 SrcList *pNew = sqlite3SrcListEnlarge(pParse, pList, 1, pList->nSrc);
126274 SQLITE_PRIVATE void sqlite3SrcListAssignCursors(Parse *pParse, SrcList *pList){
126277 assert( pList || pParse->db->mallocFailed );
126281 pItem->iCursor = pParse->nTab++;
126283 sqlite3SrcListAssignCursors(pParse, pItem->pSelect->pSrc);
126331 Parse *pParse, /* Parsing context */
126340 sqlite3 *db = pParse->db;
126342 sqlite3ErrorMsg(pParse, "a JOIN clause is required before %s",
126347 p = sqlite3SrcListAppend(pParse, p, pTable, pDatabase);
126357 sqlite3RenameTokenMap(pParse, pItem->zName, pToken);
126392 SQLITE_PRIVATE void sqlite3SrcListIndexedBy(Parse *pParse, SrcList *p, Token *pIndexedBy){
126406 pItem->u1.zIndexedBy = sqlite3NameFromToken(pParse->db, pIndexedBy);
126418 SQLITE_PRIVATE SrcList *sqlite3SrcListAppendList(Parse *pParse, SrcList *p1, SrcList *p2){
126421 SrcList *pNew = sqlite3SrcListEnlarge(pParse, p1, p2->nSrc, 1);
126423 sqlite3SrcListDelete(pParse->db, p2);
126427 sqlite3DbFree(pParse->db, p2);
126438 SQLITE_PRIVATE void sqlite3SrcListFuncArgs(Parse *pParse, SrcList *p, ExprList *pList){
126447 sqlite3ExprListDelete(pParse->db, pList);
126473 SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(Parse *pParse, SrcList *p){
126474 (void)pParse;
126499 SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){
126504 assert( pParse!=0 );
126505 db = pParse->db;
126507 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
126510 v = sqlite3GetVdbe(pParse);
126535 SQLITE_PRIVATE void sqlite3EndTransaction(Parse *pParse, int eType){
126539 assert( pParse!=0 );
126540 assert( pParse->db!=0 );
126543 if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION,
126547 v = sqlite3GetVdbe(pParse);
126557 SQLITE_PRIVATE void sqlite3Savepoint(Parse *pParse, int op, Token *pName){
126558 char *zName = sqlite3NameFromToken(pParse->db, pName);
126560 Vdbe *v = sqlite3GetVdbe(pParse);
126565 if( !v || sqlite3AuthCheck(pParse, SQLITE_SAVEPOINT, az[op], zName, 0) ){
126566 sqlite3DbFree(pParse->db, zName);
126575 ** the number of errors. Leave any error messages in the pParse structure.
126577 SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *pParse){
126578 sqlite3 *db = pParse->db;
126579 if( db->aDb[1].pBt==0 && !pParse->explain ){
126591 sqlite3ErrorMsg(pParse, "unable to open a temporary database "
126593 pParse->rc = rc;
126624 SQLITE_PRIVATE void sqlite3CodeVerifySchema(Parse *pParse, int iDb){
126625 sqlite3CodeVerifySchemaAtToplevel(sqlite3ParseToplevel(pParse), iDb);
126633 SQLITE_PRIVATE void sqlite3CodeVerifyNamedSchema(Parse *pParse, const char *zDb){
126634 sqlite3 *db = pParse->db;
126639 sqlite3CodeVerifySchema(pParse, i);
126657 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse *pParse, int setStatement, int iDb){
126658 Parse *pToplevel = sqlite3ParseToplevel(pParse);
126671 SQLITE_PRIVATE void sqlite3MultiWrite(Parse *pParse){
126672 Parse *pToplevel = sqlite3ParseToplevel(pParse);
126692 SQLITE_PRIVATE void sqlite3MayAbort(Parse *pParse){
126693 Parse *pToplevel = sqlite3ParseToplevel(pParse);
126703 Parse *pParse, /* Parsing context */
126711 assert( pParse->pVdbe!=0 );
126712 v = sqlite3GetVdbe(pParse);
126713 assert( (errCode&0xff)==SQLITE_CONSTRAINT || pParse->nested );
126715 sqlite3MayAbort(pParse);
126725 Parse *pParse, /* Parsing context */
126734 sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0,
126735 pParse->db->aLimit[SQLITE_LIMIT_LENGTH]);
126750 sqlite3HaltConstraint(pParse,
126761 Parse *pParse, /* Parsing context */
126768 zMsg = sqlite3MPrintf(pParse->db, "%s.%s", pTab->zName,
126772 zMsg = sqlite3MPrintf(pParse->db, "%s.rowid", pTab->zName);
126775 sqlite3HaltConstraint(pParse, rc, onError, zMsg, P4_DYNAMIC,
126803 static void reindexTable(Parse *pParse, Table *pTab, char const *zColl){
126809 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
126810 sqlite3BeginWriteOperation(pParse, 0, iDb);
126811 sqlite3RefillIndex(pParse, pIndex, -1);
126824 static void reindexDatabases(Parse *pParse, char const *zColl){
126827 sqlite3 *db = pParse->db; /* The database connection */
126836 reindexTable(pParse, pTab, zColl);
126856 SQLITE_PRIVATE void sqlite3Reindex(Parse *pParse, Token *pName1, Token *pName2){
126863 sqlite3 *db = pParse->db; /* The database connection */
126867 ** and code in pParse and return NULL. */
126868 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
126873 reindexDatabases(pParse, 0);
126878 zColl = sqlite3NameFromToken(pParse->db, pName1);
126882 reindexDatabases(pParse, zColl);
126888 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pObjName);
126895 reindexTable(pParse, pTab, 0);
126903 sqlite3BeginWriteOperation(pParse, 0, iDb);
126904 sqlite3RefillIndex(pParse, pIndex, -1);
126907 sqlite3ErrorMsg(pParse, "unable to identify the object to be reindexed");
126917 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
126922 if( pParse->nErr ) return 0;
126924 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
126926 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
126933 sqlite3LocateCollSeq(pParse, zColl);
126937 if( pParse->nErr ){
126938 assert( pParse->rc==SQLITE_ERROR_MISSING_COLLSEQ );
126948 pParse->rc = SQLITE_ERROR_RETRY;
126962 Parse *pParse, /* Parsing context */
126969 sqlite3 *db = pParse->db;
126980 pNew->zName = sqlite3NameFromToken(pParse->db, pName);
127013 Parse *pParse, /* Parsing context */
127017 sqlite3 *db = pParse->db;
127032 sqlite3ErrorMsg(pParse, "duplicate WITH table name: %s", zName);
127153 SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){
127156 sqlite3 *db = pParse->db;
127157 CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);
127280 Parse *pParse, /* Parsing context */
127286 sqlite3 *db = pParse->db;
127304 sqlite3ErrorMsg(pParse, "no such collation sequence: %s", zName);
127305 pParse->rc = SQLITE_ERROR_MISSING_COLLSEQ;
127322 ** pParse.
127330 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
127331 sqlite3 *db = pParse->db;
127338 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
127648 SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse *pParse, SrcList *pSrc){
127652 pTab = sqlite3LocateTableItem(pParse, 0, pItem);
127653 if( pItem->pTab ) sqlite3DeleteTable(pParse->db, pItem->pTab);
127658 if( pItem->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pItem) ){
127694 static int vtabIsReadOnly(Parse *pParse, Table *pTab){
127695 if( sqlite3GetVTable(pParse->db, pTab)->pMod->pModule->xUpdate==0 ){
127705 if( pParse->pToplevel!=0
127707 ((pParse->db->flags & SQLITE_TrustedSchema)!=0)
127709 sqlite3ErrorMsg(pParse, "unsafe use of virtual table \"%s\"",
127714 static int tabIsReadOnly(Parse *pParse, Table *pTab){
127717 return vtabIsReadOnly(pParse, pTab);
127720 db = pParse->db;
127722 return sqlite3WritableSchema(db)==0 && pParse->nested==0;
127735 SQLITE_PRIVATE int sqlite3IsReadOnly(Parse *pParse, Table *pTab, Trigger *pTrigger){
127736 if( tabIsReadOnly(pParse, pTab) ){
127737 sqlite3ErrorMsg(pParse, "table %s may not be modified", pTab->zName);
127744 sqlite3ErrorMsg(pParse,"cannot modify %s because it is a view",pTab->zName);
127759 Parse *pParse, /* Parsing context */
127769 sqlite3 *db = pParse->db;
127772 pFrom = sqlite3SrcListAppend(pParse, 0, 0, 0);
127780 pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, pOrderBy,
127783 sqlite3Select(pParse, pSel, &dest);
127798 Parse *pParse, /* The parser context */
127805 sqlite3 *db = pParse->db;
127816 sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on %s", zStmtType);
127817 sqlite3ExprDelete(pParse->db, pWhere);
127818 sqlite3ExprListDelete(pParse->db, pOrderBy);
127840 pLhs = sqlite3PExpr(pParse, TK_ROW, 0, 0);
127842 pParse, 0, sqlite3PExpr(pParse, TK_ROW, 0, 0)
127853 pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ID, zName));
127860 pEList = sqlite3ExprListAppend(pParse, pEList, p);
127862 pLhs = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
127884 pSelect = sqlite3SelectNew(pParse, pEList, pSelectSrc, pWhere, 0 ,0,
127889 pInClause = sqlite3PExpr(pParse, TK_IN, pLhs, 0);
127890 sqlite3PExprAddSelect(pParse, pInClause, pSelect);
127904 Parse *pParse, /* The parser context */
127947 db = pParse->db;
127948 assert( db->pParse==pParse );
127949 if( pParse->nErr ){
127960 pTab = sqlite3SrcListLookup(pParse, pTabList);
127967 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
127973 bComplex = pTrigger || sqlite3FkRequired(pParse, pTab, 0, 0);
127982 sqlite3TreeViewDelete(pParse->pWith, pTabList, pWhere,
127990 pParse, pTabList, pWhere, pOrderBy, pLimit, "DELETE"
127999 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
128003 if( sqlite3IsReadOnly(pParse, pTab, pTrigger) ){
128008 rcauth = sqlite3AuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0,
128019 iTabCur = pTabList->a[0].iCursor = pParse->nTab++;
128021 pParse->nTab++;
128027 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
128032 v = sqlite3GetVdbe(pParse);
128036 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
128037 sqlite3BeginWriteOperation(pParse, bComplex, iDb);
128044 sqlite3MaterializeView(pParse, pTab,
128056 sNC.pParse = pParse;
128066 && !pParse->nested
128067 && !pParse->pTriggerTab
128068 && !pParse->bReturning
128070 memCnt = ++pParse->nMem;
128095 sqlite3TableLock(pParse, iDb, pTab->tnum, 1, pTab->zName);
128118 iRowSet = ++pParse->nMem;
128126 iPk = pParse->nMem+1;
128127 pParse->nMem += nPk;
128128 iEphCur = pParse->nTab++;
128130 sqlite3VdbeSetP4KeyInfo(pParse, pPk);
128141 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, 0, 0,0,wcf,iTabCur+1);
128147 if( eOnePass!=ONEPASS_SINGLE ) sqlite3MultiWrite(pParse);
128166 iKey = ++pParse->nMem;
128185 addrBypass = sqlite3VdbeMakeLabel(pParse);
128189 iKey = ++pParse->nMem;
128192 sqlite3IndexAffinityStr(pParse->db, pPk), nPk);
128213 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, OPFLAG_FORDELETE,
128250 sqlite3VtabMakeWritable(pParse, pTab);
128252 sqlite3MayAbort(pParse);
128255 if( sqlite3IsToplevel(pParse) ){
128256 pParse->isMultiWrite = 0;
128264 int count = (pParse->nested==0); /* True to count changes */
128265 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
128286 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
128287 sqlite3AutoincrementEnd(pParse);
128361 Parse *pParse, /* Parsing context */
128373 Vdbe *v = pParse->pVdbe; /* Vdbe */
128386 iLabel = sqlite3VdbeMakeLabel(pParse);
128396 if( sqlite3FkRequired(pParse, pTab, 0, 0) || pTrigger ){
128404 pParse, pTrigger, 0, 0, TRIGGER_BEFORE|TRIGGER_AFTER, pTab, onconf
128406 mask |= sqlite3FkOldmask(pParse, pTab);
128407 iOld = pParse->nMem+1;
128408 pParse->nMem += (1 + pTab->nCol);
128424 sqlite3CodeRowTrigger(pParse, pTrigger,
128447 sqlite3FkCheck(pParse, pTab, iOld, 0, 0, 0);
128462 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,iIdxNoSeek);
128464 if( pParse->nested==0 || 0==sqlite3_stricmp(pTab->zName, "sqlite_stat1") ){
128480 sqlite3FkActions(pParse, pTab, 0, iOld, 0, 0);
128484 sqlite3CodeRowTrigger(pParse, pTrigger,
128515 Parse *pParse, /* Parsing and code generating context */
128530 v = pParse->pVdbe;
128538 r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 1,
128543 sqlite3ResolvePartIdxLabel(pParse, iPartIdxLabel);
128580 Parse *pParse, /* Parsing context */
128589 Vdbe *v = pParse->pVdbe;
128596 *piPartIdxLabel = sqlite3VdbeMakeLabel(pParse);
128597 pParse->iSelfTab = iDataCur + 1;
128598 sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel,
128600 pParse->iSelfTab = 0;
128608 regBase = sqlite3GetTempRange(pParse, nCol);
128618 sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iDataCur, j, regBase+j);
128632 sqlite3ReleaseTempRange(pParse, regBase, nCol);
128641 SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel(Parse *pParse, int iLabel){
128643 sqlite3VdbeResolveLabel(pParse->pVdbe, iLabel);
131588 ** into pParse. If an OOM error occurs, non-zero is returned and the
131589 ** pParse->db->mallocFailed flag is set.
131592 Parse *pParse, /* Parse context to store any error in */
131606 assert( pParse );
131632 aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int));
131689 if( !pParse->disableTriggers ){
131690 sqlite3ErrorMsg(pParse,
131694 sqlite3DbFree(pParse->db, aiCol);
131729 Parse *pParse, /* Parse context */
131740 Vdbe *v = sqlite3GetVdbe(pParse); /* Vdbe to add code to */
131741 int iCur = pParse->nTab - 1; /* Cursor number to use */
131742 int iOk = sqlite3VdbeMakeLabel(pParse); /* jump here if parent key found */
131746 && !(pParse->db->flags & SQLITE_DeferFKs)
131747 && !pParse->pToplevel
131748 && !pParse->isMultiWrite) ? OE_Abort : OE_Ignore);
131771 int regTemp = sqlite3GetTempReg(pParse);
131792 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
131797 sqlite3ReleaseTempReg(pParse, regTemp);
131800 int regTemp = sqlite3GetTempRange(pParse, nCol);
131803 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
131841 sqlite3IndexAffinityStr(pParse->db,pIdx), nCol);
131844 sqlite3ReleaseTempRange(pParse, regTemp, nCol);
131848 if( !pFKey->isDeferred && !(pParse->db->flags & SQLITE_DeferFKs)
131849 && !pParse->pToplevel
131850 && !pParse->isMultiWrite
131857 sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY,
131861 sqlite3MayAbort(pParse);
131880 Parse *pParse, /* Parsing and code generating context */
131888 sqlite3 *db = pParse->db;
131898 pExpr = sqlite3ExprAddCollateString(pParse, pExpr, zColl);
131956 Parse *pParse, /* Parse context */
131965 sqlite3 *db = pParse->db; /* Database handle */
131971 Vdbe *v = sqlite3GetVdbe(pParse);
131999 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
132004 pEq = sqlite3PExpr(pParse, TK_EQ, pLeft, pRight);
132005 pWhere = sqlite3ExprAnd(pParse, pWhere, pEq);
132027 pLeft = exprTableRegister(pParse, pTab, regData, -1);
132029 pNe = sqlite3PExpr(pParse, TK_NE, pLeft, pRight);
132036 pLeft = exprTableRegister(pParse, pTab, regData, iCol);
132038 pEq = sqlite3PExpr(pParse, TK_IS, pLeft, pRight);
132039 pAll = sqlite3ExprAnd(pParse, pAll, pEq);
132041 pNe = sqlite3PExpr(pParse, TK_NOT, pAll, 0);
132043 pWhere = sqlite3ExprAnd(pParse, pWhere, pNe);
132049 sNameContext.pParse = pParse;
132055 if( pParse->nErr==0 ){
132056 pWInfo = sqlite3WhereBegin(pParse, pSrc, pWhere, 0, 0, 0, 0, 0);
132143 SQLITE_PRIVATE void sqlite3FkDropTable(Parse *pParse, SrcList *pName, Table *pTab){
132144 sqlite3 *db = pParse->db;
132147 Vdbe *v = sqlite3GetVdbe(pParse);
132162 iSkip = sqlite3VdbeMakeLabel(pParse);
132166 pParse->disableTriggers = 1;
132167 sqlite3DeleteFrom(pParse, sqlite3SrcListDup(db, pName, 0), 0, 0, 0);
132168 pParse->disableTriggers = 0;
132183 sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_FOREIGNKEY,
132262 static int isSetNullAction(Parse *pParse, FKey *pFKey){
132263 Parse *pTop = sqlite3ParseToplevel(pParse);
132297 Parse *pParse, /* Parse context */
132304 sqlite3 *db = pParse->db; /* Database handle */
132308 int isIgnoreErrors = pParse->disableTriggers;
132340 ** schema items cannot be located, set an error in pParse and return
132342 if( pParse->disableTriggers ){
132345 pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb);
132347 if( !pTo || sqlite3FkLocateIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){
132358 Vdbe *v = sqlite3GetVdbe(pParse);
132390 rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
132399 sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
132400 pParse->nTab++;
132406 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore);
132408 if( regNew!=0 && !isSetNullAction(pParse, pFKey) ){
132417 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore);
132435 && !pParse->pToplevel && !pParse->isMultiWrite
132443 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){
132451 pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
132457 pItem->iCursor = pParse->nTab++;
132460 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1);
132466 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1);
132485 sqlite3MayAbort(pParse);
132502 Parse *pParse, /* Parse context */
132506 if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){
132514 sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0);
132552 Parse *pParse, /* Parse context */
132559 if( pParse->db->flags&SQLITE_ForeignKeys && IsOrdinaryTable(pTab) ){
132581 if( (pParse->db->flags & SQLITE_FkNoAction)==0
132624 Parse *pParse, /* Parse context */
132629 sqlite3 *db = pParse->db; /* Database handle */
132653 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0;
132676 pEq = sqlite3PExpr(pParse, TK_EQ,
132677 sqlite3PExpr(pParse, TK_DOT,
132682 pWhere = sqlite3ExprAnd(pParse, pWhere, pEq);
132690 pEq = sqlite3PExpr(pParse, TK_IS,
132691 sqlite3PExpr(pParse, TK_DOT,
132694 sqlite3PExpr(pParse, TK_DOT,
132698 pWhen = sqlite3ExprAnd(pParse, pWhen, pEq);
132704 pNew = sqlite3PExpr(pParse, TK_DOT,
132725 pList = sqlite3ExprListAppend(pParse, pList, pNew);
132726 sqlite3ExprListSetName(pParse, pList, &tFromCol, 0);
132743 pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
132749 pSelect = sqlite3SelectNew(pParse,
132750 sqlite3ExprListAppend(pParse, 0, pRaise),
132775 pWhen = sqlite3PExpr(pParse, TK_NOT, pWhen, 0);
132822 Parse *pParse, /* Parse context */
132833 if( pParse->db->flags&SQLITE_ForeignKeys ){
132837 Trigger *pAct = fkActionTrigger(pParse, pTab, pFKey, pChanges);
132839 sqlite3CodeRowTriggerDirect(pParse, pAct, pTab, regOld, OE_Abort, 0);
132920 Parse *pParse, /* Generate code into this VDBE */
132928 assert( pParse->pVdbe!=0 );
132929 v = pParse->pVdbe;
132931 if( !pParse->db->noSharedCache ){
132932 sqlite3TableLock(pParse, iDb, pTab->tnum,
132943 sqlite3VdbeSetP4KeyInfo(pParse, pPk);
133176 Parse *pParse, /* Parsing context */
133193 sqlite3TableAffinity(pParse->pVdbe, pTab, iRegStore);
133195 pOp = sqlite3VdbeGetLastOp(pParse->pVdbe);
133243 pParse->iSelfTab = -iRegStore;
133262 sqlite3ExprCodeGeneratedColumn(pParse, pTab, pCol, x);
133268 sqlite3ErrorMsg(pParse, "generated column loop on \"%s\"", pRedo->zCnName);
133270 pParse->iSelfTab = 0;
133300 Parse *pParse, /* Parsing context */
133305 assert( pParse->db->aDb[iDb].pSchema!=0 );
133307 && (pParse->db->mDbFlags & DBFLAG_Vacuum)==0
133309 Parse *pToplevel = sqlite3ParseToplevel(pParse);
133311 Table *pSeqTab = pParse->db->aDb[iDb].pSchema->pSeqTab;
133321 pParse->nErr++;
133322 pParse->rc = SQLITE_CORRUPT_SEQUENCE;
133329 pInfo = sqlite3DbMallocRawNN(pParse->db, sizeof(*pInfo));
133331 testcase( pParse->earlyCleanup );
133332 if( pParse->db->mallocFailed ) return 0;
133350 SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){
133352 sqlite3 *db = pParse->db; /* The database connection */
133355 Vdbe *v = pParse->pVdbe; /* VDBE under construction */
133359 assert( pParse->pTriggerTab==0 );
133360 assert( sqlite3IsToplevel(pParse) );
133363 for(p = pParse->pAinc; p; p = p->pNext){
133383 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
133399 if( pParse->nTab==0 ) pParse->nTab = 1;
133411 static void autoIncStep(Parse *pParse, int memId, int regRowid){
133413 sqlite3VdbeAddOp2(pParse->pVdbe, OP_MemMax, memId, regRowid);
133424 static SQLITE_NOINLINE void autoIncrementEnd(Parse *pParse){
133426 Vdbe *v = pParse->pVdbe;
133427 sqlite3 *db = pParse->db;
133430 for(p = pParse->pAinc; p; p = p->pNext){
133444 iRec = sqlite3GetTempReg(pParse);
133448 sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
133458 sqlite3ReleaseTempReg(pParse, iRec);
133461 SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){
133462 if( pParse->pAinc ) autoIncrementEnd(pParse);
133478 SQLITE_PRIVATE void sqlite3MultiValuesEnd(Parse *pParse, Select *pVal){
133481 sqlite3VdbeEndCoroutine(pParse->pVdbe, pItem->regReturn);
133482 sqlite3VdbeJumpHere(pParse->pVdbe, pItem->addrFillSub - 1);
133490 static int exprListIsConstant(Parse *pParse, ExprList *pRow){
133493 if( 0==sqlite3ExprIsConstant(pParse, pRow->a[ii].pExpr) ) return 0;
133502 static int exprListIsNoAffinity(Parse *pParse, ExprList *pRow){
133504 if( exprListIsConstant(pParse,pRow)==0 ) return 0;
133566 SQLITE_PRIVATE Select *sqlite3MultiValues(Parse *pParse, Select *pLeft, ExprList *pRow){
133568 if( pParse->bHasWith /* condition (a) above */
133569 || pParse->db->init.busy /* condition (b) above */
133570 || exprListIsConstant(pParse,pRow)==0 /* condition (c) above */
133572 exprListIsNoAffinity(pParse,pLeft->pEList)==0) /* condition (d) above */
133579 sqlite3MultiValuesEnd(pParse, pLeft);
133585 pSelect = sqlite3SelectNew(pParse, pRow, 0, 0, 0, 0, 0, f, 0);
133599 Vdbe *v = sqlite3GetVdbe(pParse);
133600 Select *pRet = sqlite3SelectNew(pParse, 0, 0, 0, 0, 0, 0, 0, 0);
133604 if( (pParse->db->mDbFlags & DBFLAG_SchemaKnownOk)==0 ){
133605 sqlite3ReadSchema(pParse);
133622 p->regReturn = ++pParse->nMem;
133633 dest.iSdst = pParse->nMem + 3;
133635 pParse->nMem += 2 + dest.nSdst;
133638 sqlite3Select(pParse, pLeft, &dest);
133640 assert( pParse->nErr || dest.iSdst>0 );
133649 if( pParse->nErr==0 ){
133652 sqlite3SelectWrongNumTermsError(pParse, p->pSelect);
133654 sqlite3ExprCodeExprList(pParse, pRow, p->regResult, 0, 0);
133655 sqlite3VdbeAddOp1(pParse->pVdbe, OP_Yield, p->regReturn);
133658 sqlite3ExprListDelete(pParse->db, pRow);
133666 Parse *pParse, /* Parser context */
133771 Parse *pParse, /* Parser context */
133816 db = pParse->db;
133817 assert( db->pParse==pParse );
133818 if( pParse->nErr ){
133838 pTab = sqlite3SrcListLookup(pParse, pTabList);
133844 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0,
133854 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_INSERT, 0, &tmask);
133870 sqlite3TreeViewInsert(pParse->pWith, pTabList, pColumn, pSelect, pList,
133878 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
133884 if( sqlite3IsReadOnly(pParse, pTab, pTrigger) ){
133890 v = sqlite3GetVdbe(pParse);
133892 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
133893 sqlite3BeginWriteOperation(pParse, pSelect || pTrigger, iDb);
133908 && xferOptimization(pParse, pTab, pSelect, onError, iDb)
133919 regAutoinc = autoIncBegin(pParse, iDb, pTab);
133924 regRowid = regIns = pParse->nMem+1;
133925 pParse->nMem += pTab->nCol + 1;
133928 pParse->nMem++;
133968 sqlite3ErrorMsg(pParse,
133982 sqlite3ErrorMsg(pParse, "table %S has no column named %s",
133984 pParse->checkSchema = 1;
134009 ExplainQueryPlan((pParse, 0, "SCAN %S", pItem));
134017 int regYield = ++pParse->nMem;
134023 rc = sqlite3Select(pParse, pSelect, &dest);
134025 assert( db->pParse==pParse );
134026 if( rc || pParse->nErr ) goto insert_cleanup;
134043 if( pTrigger || readsTable(pParse, iDb, pTab) ){
134062 srcTab = pParse->nTab++;
134063 regRec = sqlite3GetTempReg(pParse);
134064 regTempRowid = sqlite3GetTempReg(pParse);
134072 sqlite3ReleaseTempReg(pParse, regRec);
134073 sqlite3ReleaseTempReg(pParse, regTempRowid);
134081 sNC.pParse = pParse;
134126 sqlite3ErrorMsg(pParse,
134133 sqlite3ErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId);
134140 && !pParse->nested
134141 && !pParse->pTriggerTab
134142 && !pParse->bReturning
134144 regRowCount = ++pParse->nMem;
134151 nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, -1, 0,
134159 aRegIdx[i] = ++pParse->nMem;
134160 pParse->nMem += pIdx->nColumn;
134162 aRegIdx[i] = ++pParse->nMem; /* Register to store the table record */
134168 sqlite3ErrorMsg(pParse, "UPSERT not implemented for virtual table \"%s\"",
134173 sqlite3ErrorMsg(pParse, "cannot UPSERT a view");
134176 if( sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget) ){
134187 if( sqlite3UpsertAnalyzeTarget(pParse, pTabList, pNx, pUpsert) ){
134219 sqlite3VdbeReleaseRegisters(pParse, regData, pTab->nCol, 0, 0);
134271 sqlite3ExprCodeFactorable(pParse,
134283 sqlite3ExprCodeFactorable(pParse,
134291 sqlite3ExprCodeFactorable(pParse,
134307 int y = sqlite3ExprCodeTarget(pParse, pX, iRegStore);
134318 endOfLoop = sqlite3VdbeMakeLabel(pParse);
134320 int regCols = sqlite3GetTempRange(pParse, pTab->nCol+1);
134337 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regCols);
134346 assert( pTab->nNVCol>0 || pParse->nErr>0 );
134357 sqlite3ComputeGeneratedColumns(pParse, regCols+1, pTab);
134371 sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_BEFORE,
134374 sqlite3ReleaseTempRange(pParse, regCols, pTab->nCol+1);
134394 sqlite3ExprCode(pParse, pList->a[ipkColumn].pExpr, regRowid);
134418 autoIncStep(pParse, regAutoinc, regRowid);
134426 sqlite3ComputeGeneratedColumns(pParse, regRowid+1, pTab);
134436 sqlite3VtabMakeWritable(pParse, pTab);
134439 sqlite3MayAbort(pParse);
134445 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
134449 sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0);
134461 sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
134466 }else if( pParse->bReturning ){
134482 sqlite3CodeRowTrigger(pParse, pTrigger, TK_INSERT, 0, TRIGGER_AFTER,
134515 if( pParse->nested==0 && pParse->pTriggerTab==0 ){
134516 sqlite3AutoincrementEnd(pParse);
134764 ** Or if overrideError==OE_Default, then the pParse->onError parameter
134765 ** is used. Or if pParse->onError==OE_Default then the onError value
134769 Parse *pParse, /* The parser context */
134810 db = pParse->db;
134811 v = pParse->pVdbe;
134886 sqlite3ExprCodeCopy(pParse,
134892 sqlite3MayAbort(pParse);
134928 sqlite3ComputeGeneratedColumns(pParse, regNewData+1, pTab);
134939 pParse->iSelfTab = -(regNewData+1);
134956 allOk = sqlite3VdbeMakeLabel(pParse);
134960 sqlite3ExprIfTrue(pParse, pCopy, allOk, SQLITE_JUMPIFNULL);
134967 assert( zName!=0 || pParse->db->mallocFailed );
134969 sqlite3HaltConstraint(pParse, SQLITE_CONSTRAINT_CHECK,
134975 pParse->iSelfTab = 0;
135094 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0);
135095 regTrigCnt = pTrigger!=0 || sqlite3FkRequired(pParse, pTab, 0, 0);
135098 regTrigCnt = sqlite3FkRequired(pParse, pTab, 0, 0);
135103 regTrigCnt = ++pParse->nMem;
135106 lblRecheckOk = sqlite3VdbeMakeLabel(pParse);
135115 int addrRowidOk = sqlite3VdbeMakeLabel(pParse);
135184 sqlite3RowidConstraint(pParse, onError, pTab);
135211 sqlite3MultiWrite(pParse);
135212 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
135227 sqlite3MultiWrite(pParse);
135228 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,-1);
135236 sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, 0, iDataCur);
135279 addrUniqueOk = sqlite3VdbeMakeLabel(pParse);
135291 pParse->iSelfTab = -(regNewData+1);
135292 sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, addrUniqueOk,
135294 pParse->iSelfTab = 0;
135305 pParse->iSelfTab = -(regNewData+1);
135306 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i);
135307 pParse->iSelfTab = 0;
135327 sqlite3VdbeReleaseRegisters(pParse, regIdx, pIdx->nColumn, 0, 0);
135375 0==sqlite3TriggersExist(pParse, pTab, TK_DELETE, 0, 0))
135391 regR = pIdx==pPk ? regIdx : sqlite3GetTempRange(pParse, nPkField);
135428 char *p4 = (char*)sqlite3LocateCollSeq(pParse, pPk->azColl[i]);
135457 sqlite3UniqueConstraint(pParse, onError, pIdx);
135462 sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, pIdx, iIdxCur+ix);
135480 sqlite3MultiWrite(pParse);
135486 sqlite3GenerateRowDelete(pParse, pTab, pTrigger, iDataCur, iIdxCur,
135503 lblRecheckOk = sqlite3VdbeMakeLabel(pParse);
135536 sqlite3UniqueConstraint(pParse, OE_Abort, pIdx);
135545 if( regR!=regIdx ) sqlite3ReleaseTempRange(pParse, regR, nPkField);
135577 sqlite3RowidConstraint(pParse, OE_Abort, pTab);
135628 Parse *pParse, /* Parse context */
135633 Vdbe *v = pParse->pVdbe;
135634 int r = sqlite3GetTempReg(pParse);
135636 assert( 0==(pParse->db->mDbFlags & DBFLAG_Vacuum) || CORRUPT_DB );
135640 sqlite3ReleaseTempReg(pParse, r);
135656 Parse *pParse, /* The parser context */
135676 v = pParse->pVdbe;
135694 codeWithoutRowidPreupdate(pParse, pTab, iIdxCur+i, aRegIdx[i]);
135703 if( pParse->nested ){
135716 if( !pParse->nested ){
135744 Parse *pParse, /* Parsing context */
135770 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
135771 v = pParse->pVdbe;
135773 if( iBase<0 ) iBase = pParse->nTab;
135777 sqlite3OpenTable(pParse, iDataCur, iDb, pTab, op);
135778 }else if( pParse->db->noSharedCache==0 ){
135779 sqlite3TableLock(pParse, iDb, pTab->tnum, op==OP_OpenWrite, pTab->zName);
135791 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
135796 if( iBase>pParse->nTab ) pParse->nTab = iBase;
135886 Parse *pParse, /* Parser context */
135892 sqlite3 *db = pParse->db;
135909 if( pParse->pWith || pSelect->pWith ){
135966 pSrc = sqlite3LocateTableItem(pParse, 0, pItem);
136111 v = sqlite3GetVdbe(pParse);
136112 sqlite3CodeVerifySchema(pParse, iDbSrc);
136113 iSrc = pParse->nTab++;
136114 iDest = pParse->nTab++;
136115 regAutoinc = autoIncBegin(pParse, iDbDest, pDest);
136116 regData = sqlite3GetTempReg(pParse);
136118 regRowid = sqlite3GetTempReg(pParse);
136119 sqlite3OpenTable(pParse, iDest, iDbDest, pDest, OP_OpenWrite);
136149 sqlite3OpenTable(pParse, iSrc, iDbSrc, pSrc, OP_OpenRead);
136157 sqlite3RowidConstraint(pParse, onError, pDest);
136160 autoIncStep(pParse, regAutoinc, regRowid);
136193 sqlite3TableLock(pParse, iDbDest, pDest->tnum, 1, pDest->zName);
136194 sqlite3TableLock(pParse, iDbSrc, pSrc->tnum, 0, pSrc->zName);
136203 sqlite3VdbeSetP4KeyInfo(pParse, pSrcIdx);
136206 sqlite3VdbeSetP4KeyInfo(pParse, pDestIdx);
136243 codeWithoutRowidPreupdate(pParse, pDest, iDest, regData);
136254 sqlite3ReleaseTempReg(pParse, regRowid);
136255 sqlite3ReleaseTempReg(pParse, regData);
136257 sqlite3AutoincrementEnd(pParse);
138883 static int invalidateTempStorage(Parse *pParse){
138884 sqlite3 *db = pParse->db;
138889 sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "
138907 static int changeTempStorage(Parse *pParse, const char *zStorageType){
138909 sqlite3 *db = pParse->db;
138911 if( invalidateTempStorage( pParse ) != SQLITE_OK ){
139134 Parse *pParse,
139147 sqlite3 *db = pParse->db; /* The database connection */
139149 Vdbe *v = sqlite3GetVdbe(pParse); /* Prepared statement */
139154 pParse->nMem = 2;
139158 iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
139165 if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
139179 if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
139213 sqlite3ErrorMsg(pParse, "%s", aFcntl[0]);
139216 pParse->nErr++;
139217 pParse->rc = rc;
139231 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
139277 pParse->nMem += 2;
139286 sqlite3BeginWriteOperation(pParse, 0, iDb);
139374 sqlite3CodeVerifySchema(pParse, iDb);
139375 iReg = ++pParse->nMem;
139567 sqlite3BeginWriteOperation(pParse, 0, iDb);
139683 pParse->nErr++;
139684 pParse->rc = rc;
139704 changeTempStorage(pParse, zRight);
139729 sqlite3ErrorMsg(pParse, "not a writable directory");
139738 invalidateTempStorage(pParse);
139776 sqlite3ErrorMsg(pParse, "not a writable directory");
139823 sqlite3ErrorMsg(pParse, "failed to set lock proxy file");
139845 sqlite3ErrorMsg(pParse,
139924 sqlite3CodeVerifyNamedSchema(pParse, zDb);
139925 pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb);
139931 pParse->nMem = 7;
139932 sqlite3ViewGetColumnNames(pParse, pTab);
139988 pParse->nMem = 6;
139989 sqlite3CodeVerifyNamedSchema(pParse, zDb);
140017 sqlite3ErrorMsg(db->pParse, "out of memory");
140018 db->pParse->rc = SQLITE_NOMEM_BKPT;
140056 pParse->nMem = 5;
140057 sqlite3CodeVerifySchema(pParse, iDb);
140087 pTab = sqlite3LocateTable(pParse, LOCATE_NOERR, zRight, zDb);
140099 pParse->nMem = 6;
140103 pParse->nMem = 3;
140106 sqlite3CodeVerifySchema(pParse, iIdxDb);
140107 assert( pParse->nMem<=pPragma->nPragCName );
140118 sqlite3VdbeAddOp2(v, OP_ResultRow, 1, pParse->nMem);
140131 pParse->nMem = 5;
140132 sqlite3CodeVerifySchema(pParse, iTabDb);
140148 pParse->nMem = 3;
140163 pParse->nMem = 2;
140177 pParse->nMem = 6;
140195 pParse->nMem = 1;
140225 pParse->nMem = 8;
140226 sqlite3CodeVerifySchema(pParse, iTabDb);
140266 regResult = pParse->nMem+1;
140267 pParse->nMem += 4;
140268 regRow = ++pParse->nMem;
140272 pTab = sqlite3LocateTable(pParse, 0, zRight, zDb);
140281 sqlite3CodeVerifySchema(pParse, iDb);
140282 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
140283 sqlite3TouchRegister(pParse, pTab->nCol+regRow);
140284 sqlite3OpenTable(pParse, 0, iDb, pTab, OP_OpenRead);
140291 sqlite3TableLock(pParse, iDb, pParent->tnum, 0, pParent->zName);
140292 x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, 0);
140295 sqlite3OpenTable(pParse, i, iDb, pParent, OP_OpenRead);
140298 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
140305 assert( pParse->nErr>0 || pFK==0 );
140307 if( pParse->nTab<i ) pParse->nTab = i;
140315 x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, &aiCols);
140318 addrOk = sqlite3VdbeMakeLabel(pParse);
140324 sqlite3TouchRegister(pParse, regRow + pFK->nCol);
140425 pParse->nMem = 6;
140435 pObjTab = sqlite3LocateTable(pParse, 0, zRight,
140451 sqlite3CodeVerifySchema(pParse, i);
140452 pParse->okConstFactor = 0; /* tag-20230327-1 */
140487 sqlite3TouchRegister(pParse, 8+cnt);
140488 sqlite3ClearTempRegCache(pParse);
140551 r2 = sqlite3GetTempRange(pParse, pPk->nKeyCol);
140554 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenRead, 0,
140563 assert( pParse->nMem>=8+j );
140564 assert( sqlite3NoTempsInRange(pParse,1,7+j) );
140607 sqlite3ExprCodeLoadIndexColumn(pParse, pPk, iDataCur, j, r2+j);
140663 labelError = sqlite3VdbeMakeLabel(pParse);
140664 labelOk = sqlite3VdbeMakeLabel(pParse);
140747 int addrCkFault = sqlite3VdbeMakeLabel(pParse);
140748 int addrCkOk = sqlite3VdbeMakeLabel(pParse);
140751 pParse->iSelfTab = iDataCur + 1;
140753 sqlite3ExprIfFalse(pParse, pCheck->a[k].pExpr, addrCkFault, 0);
140755 sqlite3ExprIfTrue(pParse, pCheck->a[0].pExpr, addrCkOk,
140758 pParse->iSelfTab = 0;
140772 int ckUniq = sqlite3VdbeMakeLabel(pParse);
140774 r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3,
140812 if( label6==0 ) label6 = sqlite3VdbeMakeLabel(pParse);
140830 int uniqOk = sqlite3VdbeMakeLabel(pParse);
140849 sqlite3ResolvePartIdxLabel(pParse, jmp3);
140856 sqlite3ReleaseTempRange(pParse, r2, pPk->nKeyCol);
140875 sqlite3ViewGetColumnNames(pParse, pTab);
140959 if( sqlite3ReadSchema(pParse) ) goto pragma_out;
140963 returnSingleText(v, encnames[ENC(pParse->db)].zName);
140980 sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
141074 pParse->nMem = 1;
141102 pParse->nMem = 3;
141241 iTabCur = pParse->nTab++;
141244 sqlite3CodeVerifySchema(pParse, iDb);
141286 sqlite3BeginWriteOperation(pParse, 0, iDb);
141293 sqlite3OpenTable(pParse, iTabCur, iDb, pTab, OP_OpenRead);
141309 int r1 = sqlite3GetTempReg(pParse);
141443 pParse->nMem = 2;
142279 SQLITE_PRIVATE int sqlite3ReadSchema(Parse *pParse){
142281 sqlite3 *db = pParse->db;
142284 rc = sqlite3Init(db, &pParse->zErrMsg);
142286 pParse->rc = rc;
142287 pParse->nErr++;
142298 ** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies
142299 ** make no changes to pParse->rc.
142301 static void schemaIsValid(Parse *pParse){
142302 sqlite3 *db = pParse->db;
142307 assert( pParse->checkSchema );
142321 pParse->rc = SQLITE_NOMEM;
142333 if( DbHasProperty(db, iDb, DB_SchemaLoaded) ) pParse->rc = SQLITE_SCHEMA;
142379 ** Free all memory allocations in the pParse object
142381 SQLITE_PRIVATE void sqlite3ParseObjectReset(Parse *pParse){
142382 sqlite3 *db = pParse->db;
142384 assert( db->pParse==pParse );
142385 assert( pParse->nested==0 );
142387 if( pParse->aTableLock ) sqlite3DbNNFreeNN(db, pParse->aTableLock);
142389 while( pParse->pCleanup ){
142390 ParseCleanup *pCleanup = pParse->pCleanup;
142391 pParse->pCleanup = pCleanup->pNext;
142395 if( pParse->aLabel ) sqlite3DbNNFreeNN(db, pParse->aLabel);
142396 if( pParse->pConstExpr ){
142397 sqlite3ExprListDelete(db, pParse->pConstExpr);
142399 assert( db->lookaside.bDisable >= pParse->disableLookaside );
142400 db->lookaside.bDisable -= pParse->disableLookaside;
142402 assert( pParse->db->pParse==pParse );
142403 db->pParse = pParse->pOuterParse;
142419 ** pParse->earlyCleanup flag is set in that case. Calling code show verify
142424 ** testcase( pParse->earlyCleanup );
142432 ** pObj = sqlite3ParserAddCleanup(pParse, destructor, pObj);
142435 Parse *pParse, /* Destroy when this Parser finishes */
142442 sqlite3OomFault(pParse->db);
142444 pCleanup = sqlite3DbMallocRaw(pParse->db, sizeof(*pCleanup));
142447 pCleanup->pNext = pParse->pCleanup;
142448 pParse->pCleanup = pCleanup;
142452 xCleanup(pParse->db, pPtr);
142455 pParse->earlyCleanup = 1;
142470 SQLITE_PRIVATE void sqlite3ParseObjectInit(Parse *pParse, sqlite3 *db){
142471 memset(PARSE_HDR(pParse), 0, PARSE_HDR_SZ);
142472 memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
142473 assert( db->pParse!=pParse );
142474 pParse->pOuterParse = db->pParse;
142475 db->pParse = pParse;
142476 pParse->db = db;
142477 if( db->mallocFailed ) sqlite3ErrorMsg(pParse, "out of memory");
142507 sParse.pOuterParse = db->pParse;
142508 db->pParse = &sParse;
143018 Parse *pParse, /* Parsing context */
143030 pAllocated = pNew = sqlite3DbMallocRawNN(pParse->db, sizeof(*pNew) );
143032 assert( pParse->db->mallocFailed );
143036 pEList = sqlite3ExprListAppend(pParse, 0,
143037 sqlite3Expr(pParse->db,TK_ASTERISK,0));
143044 pNew->selId = ++pParse->nSelect;
143048 if( pSrc==0 ) pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*pSrc));
143062 if( pParse->db->mallocFailed ) {
143063 clearSelect(pParse->db, pNew, pNew!=&standin);
143066 assert( pNew->pSrc!=0 || pParse->nErr>0 );
143105 ** a join type, but put an error in the pParse structure.
143153 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
143200 sqlite3ErrorMsg(pParse, "unknown join type: "
143385 static int sqlite3ProcessJoin(Parse *pParse, Select *p){
143407 sqlite3ErrorMsg(pParse, "a NATURAL join may not have "
143417 pUsing = sqlite3IdListAppend(pParse, pUsing, 0);
143421 pUsing->a[pUsing->nId-1].zName = sqlite3DbStrDup(pParse->db, zName);
143430 if( pParse->nErr ) return 1;
143442 sqlite3 *db = pParse->db;
143459 sqlite3ErrorMsg(pParse, "cannot join using column %s - column "
143486 sqlite3ErrorMsg(pParse, "ambiguous reference to %s in USING()",
143490 pFuncArgs = sqlite3ExprListAppend(pParse, pFuncArgs, pE1);
143495 pFuncArgs = sqlite3ExprListAppend(pParse, pFuncArgs, pE1);
143496 pE1 = sqlite3ExprFunction(pParse, pFuncArgs, &tkCoalesce, 0);
143501 pEq = sqlite3PExpr(pParse, TK_EQ, pE1, pE2);
143509 p->pWhere = sqlite3ExprAnd(pParse, p->pWhere, pEq);
143518 p->pWhere = sqlite3ExprAnd(pParse, p->pWhere, pRight->u3.pOn);
143527 ** An instance of this object holds information (beyond pParse and pSelect)
143545 Parse *pParse, /* Statement under construction */
143549 sqlite3ExprCodeExprList(pParse, pSelect->pEList, pInfo->regResult,
143553 sqlite3ExprCodeExprList(pParse, pInfo->pExtra, pInfo->regExtraResult, 0, 0);
143554 sqlite3ExprListDelete(pParse->db, pInfo->pExtra);
143566 Parse *pParse,
143573 Vdbe *v = pParse->pVdbe;
143574 int regOut = ++pParse->nMem;
143576 innerLoopLoadRow(pParse, pSelect, pSort->pDeferredRowLoad);
143587 Parse *pParse, /* Parser context */
143595 Vdbe *v = pParse->pVdbe; /* Stmt under construction */
143631 regBase = pParse->nMem + 1;
143632 pParse->nMem += nBase;
143636 pSort->labelDone = sqlite3VdbeMakeLabel(pParse);
143637 sqlite3ExprCodeExprList(pParse, pSort->pOrderBy, regBase, regOrigData,
143643 sqlite3ExprCodeMove(pParse, regData, regBase+nExpr+bSeq, nData);
143653 regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase);
143654 regPrevKey = pParse->nMem+1;
143655 pParse->nMem += pSort->nOBSat;
143665 if( pParse->db->mallocFailed ) return;
143671 pOp->p4.pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pSort->pOrderBy,nOBSat,
143676 pSort->labelBkOut = sqlite3VdbeMakeLabel(pParse);
143677 pSort->regReturn = ++pParse->nMem;
143685 sqlite3ExprCodeMove(pParse, regBase, regPrevKey, pSort->nOBSat);
143714 regRecord = makeSorterRecord(pParse, pSort, pSelect, regBase, nBase);
143790 Parse *pParse, /* Parsing and code generating context */
143799 Vdbe *v = pParse->pVdbe;
143808 iRet = regPrev = pParse->nMem+1;
143809 pParse->nMem += nResultCol;
143813 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pEList->a[i].pExpr);
143824 assert( sqlite3VdbeCurrentAddr(v)==iJump || pParse->db->mallocFailed );
143835 int r1 = sqlite3GetTempReg(pParse);
143841 sqlite3ReleaseTempReg(pParse, r1);
143874 Parse *pParse, /* Parsing and code generating context */
143879 if( pParse->nErr==0
143882 Vdbe *v = pParse->pVdbe;
143926 Parse *pParse, /* Leave any error here */
143962 Expr *pNew = sqlite3PExpr(pParse, TK_COLUMN, 0, 0);
143968 pExtra = sqlite3ExprListAppend(pParse, pExtra, pNew);
143996 Parse *pParse, /* The parser context */
144005 Vdbe *v = pParse->pVdbe;
144039 pParse->nMem += nPrefixReg;
144041 pDest->iSdst = pParse->nMem+1;
144042 pParse->nMem += nResultCol;
144043 }else if( pDest->iSdst+nResultCol > pParse->nMem ){
144049 pParse->nMem += nResultCol;
144088 selectExprDefer(pParse, pSort, p->pEList, &pExtra);
144089 if( pExtra && pParse->db->mallocFailed==0 ){
144098 pParse->nMem += pExtra->nExpr;
144141 innerLoopLoadRow(pParse, p, &sRowLoadInfo);
144153 iTab = codeDistinct(pParse, eType, iTab, iContinue, p->pEList, regResult);
144154 fixDistinctOpenEph(pParse, eType, iTab, pDistinct->addrTnct);
144167 r1 = sqlite3GetTempReg(pParse);
144170 sqlite3ReleaseTempReg(pParse, r1);
144190 int r1 = sqlite3GetTempRange(pParse, nPrefixReg+1);
144222 pushOntoSorter(pParse, pSort, p, r1+nPrefixReg, regOrig, 1, nPrefixReg);
144224 int r2 = sqlite3GetTempReg(pParse);
144228 sqlite3ReleaseTempReg(pParse, r2);
144230 sqlite3ReleaseTempRange(pParse, r1, nPrefixReg+1);
144237 pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
144240 int r1 = sqlite3GetTempReg(pParse);
144270 pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
144272 int r1 = sqlite3GetTempReg(pParse);
144277 sqlite3ReleaseTempReg(pParse, r1);
144299 pParse, pSort, p, regResult, regOrig, nResultCol, nPrefixReg);
144314 pushOntoSorter(pParse, pSort, p, regResult, regOrig, nResultCol,
144340 r1 = sqlite3GetTempReg(pParse);
144341 r2 = sqlite3GetTempRange(pParse, nKey+2);
144365 sqlite3ReleaseTempReg(pParse, r1);
144366 sqlite3ReleaseTempRange(pParse, r2, nKey+2);
144464 Parse *pParse, /* Parsing context */
144472 sqlite3 *db = pParse->db;
144480 pInfo->aColl[i-iStart] = sqlite3ExprNNCollSeq(pParse, pItem->pExpr);
144512 static void explainTempTable(Parse *pParse, const char *zUsage){
144513 ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s", zUsage));
144539 Parse *pParse, /* Parsing context */
144545 Vdbe *v = pParse->pVdbe; /* The prepared statement */
144547 int addrContinue = sqlite3VdbeMakeLabel(pParse);/* Jump here for next cycle */
144569 ExplainQueryPlan2(addrExplain, (pParse, 0,
144573 ExplainQueryPlan2(addrExplain, (pParse, 0,
144592 int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
144593 sqlite3OpenTable(pParse, pSort->aDefer[i].iCsr, iDb, pTab, OP_OpenRead);
144606 regRowid = sqlite3GetTempReg(pParse);
144608 regRow = sqlite3GetTempReg(pParse);
144611 regRow = sqlite3GetTempRange(pParse, nColumn);
144615 int regSortOut = ++pParse->nMem;
144616 iSortTab = pParse->nTab++;
144646 int regKey = sqlite3GetTempRange(pParse, nRefKey);
144671 sqlite3ReleaseTempRange(pParse, regKey, nRefKey);
144677 sqlite3ExprCode(pParse, aOutEx[i].pExpr, regRow+i);
144716 int r1 = sqlite3GetTempReg(pParse);
144739 sqlite3ReleaseTempRange(pParse, regRow, nColumn);
144741 sqlite3ReleaseTempReg(pParse, regRow);
144743 sqlite3ReleaseTempReg(pParse, regRowid);
144863 sNC.pParse = pNC->pParse;
144880 if( pNC->pParse && pTab->pSchema ){
144881 int iDb = sqlite3SchemaToIndex(pNC->pParse->db, pTab->pSchema);
144882 zOrigDb = pNC->pParse->db->aDb[iDb].zDbSName;
144909 sNC.pParse = pNC->pParse;
144932 Parse *pParse, /* Parser context */
144937 Vdbe *v = pParse->pVdbe;
144941 sNC.pParse = pParse;
144999 Parse *pParse, /* Parser context */
145002 Vdbe *v = pParse->pVdbe;
145007 sqlite3 *db = pParse->db;
145011 if( pParse->colNamesSet ) return;
145014 TREETRACE(0x80,pParse,pSelect,("generating column names\n"));
145019 pParse->colNamesSet = 1;
145059 generateColumnTypes(pParse, pTabList, pEList);
145085 Parse *pParse, /* Parsing context */
145090 sqlite3 *db = pParse->db; /* Database connection */
145114 for(i=0, pCol=aCol; i<nCol && !pParse->nErr; i++, pCol++){
145164 sqlite3ProgressCheck(pParse);
145180 if( pParse->nErr ){
145187 return pParse->rc;
145204 Parse *pParse, /* Parsing contexts */
145209 sqlite3 *db = pParse->db;
145219 assert( pTab->nCol==pSelect->pEList->nExpr || pParse->nErr>0 );
145283 pColl = sqlite3ExprCollSeq(pParse, p);
145296 SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect, char aff){
145298 sqlite3 *db = pParse->db;
145304 sqlite3SelectPrep(pParse, pSelect, 0);
145306 if( pParse->nErr ) return 0;
145315 sqlite3ColumnsFromExprList(pParse, pSelect->pEList, &pTab->nCol, &pTab->aCol);
145316 sqlite3SubqueryColumnTypes(pParse, pTab, pSelect, aff);
145327 ** If an error occurs, return NULL and leave a message in pParse.
145329 SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse *pParse){
145330 if( pParse->pVdbe ){
145331 return pParse->pVdbe;
145333 if( pParse->pToplevel==0
145334 && OptimizationEnabled(pParse->db,SQLITE_FactorOutConst)
145336 pParse->okConstFactor = 1;
145338 return sqlite3VdbeCreate(pParse);
145365 static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
145383 p->iLimit = iLimit = ++pParse->nMem;
145384 v = sqlite3GetVdbe(pParse);
145396 sqlite3ExprCode(pParse, pLimit->pLeft, iLimit);
145402 p->iOffset = iOffset = ++pParse->nMem;
145403 pParse->nMem++; /* Allocate an extra register for limit+offset */
145404 sqlite3ExprCode(pParse, pLimit->pRight, iOffset);
145422 static CollSeq *multiSelectCollSeq(Parse *pParse, Select *p, int iCol){
145425 pRet = multiSelectCollSeq(pParse, p->pPrior, iCol);
145434 pRet = sqlite3ExprCollSeq(pParse, p->pEList->a[iCol].pExpr);
145448 static KeyInfo *multiSelectOrderByKeyInfo(Parse *pParse, Select *p, int nExtra){
145451 sqlite3 *db = pParse->db;
145461 pColl = sqlite3ExprCollSeq(pParse, pTerm);
145463 pColl = multiSelectCollSeq(pParse, p, pItem->u.x.iOrderByCol-1);
145466 sqlite3ExprAddCollateString(pParse, pTerm, pColl->zName);
145515 Parse *pParse, /* Parsing context */
145521 Vdbe *v = pParse->pVdbe; /* The prepared statement under construction */
145540 sqlite3ErrorMsg(pParse, "cannot use window functions in recursive queries");
145546 if( sqlite3AuthCheck(pParse, SQLITE_RECURSIVE, 0, 0, 0) ) return;
145549 addrBreak = sqlite3VdbeMakeLabel(pParse);
145551 computeLimitRegisters(pParse, p, addrBreak);
145570 iQueue = pParse->nTab++;
145573 iDistinct = pParse->nTab++;
145580 regCurrent = ++pParse->nMem;
145583 KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1);
145608 sqlite3ErrorMsg(pParse, "recursive aggregate queries not supported");
145618 ExplainQueryPlan((pParse, 1, "SETUP"));
145619 rc = sqlite3Select(pParse, pSetup, &destQueue);
145636 addrCont = sqlite3VdbeMakeLabel(pParse);
145638 selectInnerLoop(pParse, p, iCurrent,
145650 ExplainQueryPlan((pParse, 1, "RECURSIVE STEP"));
145651 sqlite3Select(pParse, p, &destQueue);
145660 sqlite3ExprListDelete(pParse->db, p->pOrderBy);
145669 Parse *pParse, /* Parsing context */
145691 Parse *pParse, /* Parsing context */
145711 ExplainQueryPlan((pParse, 0, "SCAN %d CONSTANT ROW%s", nRow,
145714 selectInnerLoop(pParse, p, -1, 0, 0, pDest, 1, 1);
145764 Parse *pParse, /* Parsing context */
145781 db = pParse->db;
145787 v = sqlite3GetVdbe(pParse);
145801 rc = multiSelectValues(pParse, p, &dest);
145814 generateWithRecursiveQuery(pParse, p, &dest);
145821 return multiSelectOrderBy(pParse, p, pDest);
145826 ExplainQueryPlan((pParse, 1, "COMPOUND QUERY"));
145827 ExplainQueryPlan((pParse, 1, "LEFT-MOST SUBQUERY"));
145841 TREETRACE(0x200, pParse, p, ("multiSelect UNION ALL left...\n"));
145842 rc = sqlite3Select(pParse, pPrior, &dest);
145858 ExplainQueryPlan((pParse, 1, "UNION ALL"));
145859 TREETRACE(0x200, pParse, p, ("multiSelect UNION ALL right...\n"));
145860 rc = sqlite3Select(pParse, p, &dest);
145898 unionTab = pParse->nTab++;
145912 TREETRACE(0x200, pParse, p, ("multiSelect EXCEPT/UNION left...\n"));
145913 rc = sqlite3Select(pParse, pPrior, &uniondest);
145930 ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
145932 TREETRACE(0x200, pParse, p, ("multiSelect EXCEPT/UNION right...\n"));
145933 rc = sqlite3Select(pParse, p, &uniondest);
145954 iBreak = sqlite3VdbeMakeLabel(pParse);
145955 iCont = sqlite3VdbeMakeLabel(pParse);
145956 computeLimitRegisters(pParse, p, iBreak);
145959 selectInnerLoop(pParse, p, unionTab,
145980 tab1 = pParse->nTab++;
145981 tab2 = pParse->nTab++;
145993 TREETRACE(0x400, pParse, p, ("multiSelect INTERSECT left...\n"));
145994 rc = sqlite3Select(pParse, pPrior, &intersectdest);
146008 ExplainQueryPlan((pParse, 1, "%s USING TEMP B-TREE",
146010 TREETRACE(0x400, pParse, p, ("multiSelect INTERSECT right...\n"));
146011 rc = sqlite3Select(pParse, p, &intersectdest);
146026 iBreak = sqlite3VdbeMakeLabel(pParse);
146027 iCont = sqlite3VdbeMakeLabel(pParse);
146028 computeLimitRegisters(pParse, p, iBreak);
146030 r1 = sqlite3GetTempReg(pParse);
146034 sqlite3ReleaseTempReg(pParse, r1);
146035 selectInnerLoop(pParse, p, tab1,
146048 ExplainQueryPlanPop(pParse);
146052 if( pParse->nErr ) goto multi_select_end;
146079 *apColl = multiSelectCollSeq(pParse, p, i);
146107 sqlite3ParserAddCleanup(pParse, sqlite3SelectDeleteGeneric, pDelete);
146117 SQLITE_PRIVATE void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p){
146119 sqlite3ErrorMsg(pParse, "all VALUES must have the same number of terms");
146121 sqlite3ErrorMsg(pParse, "SELECTs to the left and right of %s"
146148 Parse *pParse, /* Parsing context */
146157 Vdbe *v = pParse->pVdbe;
146162 iContinue = sqlite3VdbeMakeLabel(pParse);
146176 if( pParse->db->mallocFailed ) return 0;
146188 int r1 = sqlite3GetTempReg(pParse);
146189 int r2 = sqlite3GetTempReg(pParse);
146194 sqlite3ReleaseTempReg(pParse, r2);
146195 sqlite3ReleaseTempReg(pParse, r1);
146205 r1 = sqlite3GetTempReg(pParse);
146210 sqlite3ReleaseTempReg(pParse, r1);
146221 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSDParm, pIn->nSdst);
146232 pDest->iSdst = sqlite3GetTempRange(pParse, pIn->nSdst);
146235 sqlite3ExprCodeMove(pParse, pIn->iSdst, pDest->iSdst, pIn->nSdst);
146356 Parse *pParse, /* Parsing context */
146399 db = pParse->db;
146400 v = pParse->pVdbe;
146402 labelEnd = sqlite3VdbeMakeLabel(pParse);
146403 labelCmpr = sqlite3VdbeMakeLabel(pParse);
146431 p->pOrderBy = pOrderBy = sqlite3ExprListAppend(pParse, pOrderBy, pNew);
146454 pKeyMerge = multiSelectOrderByKeyInfo(pParse, p, 1);
146468 regPrev = pParse->nMem+1;
146469 pParse->nMem += nExpr+1;
146475 pKeyDup->aColl[i] = multiSelectCollSeq(pParse, p, i);
146504 pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0);
146505 sqlite3ResolveOrderGroupBy(pParse, p, p->pOrderBy, "ORDER");
146506 sqlite3ResolveOrderGroupBy(pParse, pPrior, pPrior->pOrderBy, "ORDER");
146509 computeLimitRegisters(pParse, p, labelEnd);
146511 regLimitA = ++pParse->nMem;
146512 regLimitB = ++pParse->nMem;
146522 regAddrA = ++pParse->nMem;
146523 regAddrB = ++pParse->nMem;
146524 regOutA = ++pParse->nMem;
146525 regOutB = ++pParse->nMem;
146529 ExplainQueryPlan((pParse, 1, "MERGE (%s)", sqlite3SelectOpName(p->op)));
146538 ExplainQueryPlan((pParse, 1, "LEFT"));
146539 sqlite3Select(pParse, pPrior, &destA);
146553 ExplainQueryPlan((pParse, 1, "RIGHT"));
146554 sqlite3Select(pParse, p, &destB);
146563 addrOutA = generateOutputSubroutine(pParse,
146572 addrOutB = generateOutputSubroutine(pParse,
146658 sqlite3ParserAddCleanup(pParse, sqlite3SelectDeleteGeneric, pSplit->pPrior);
146667 ExplainQueryPlanPop(pParse);
146668 return pParse->nErr!=0;
146709 Parse *pParse; /* The parsing context */
146765 sqlite3VectorErrorMsg(pSubst->pParse, pCopy);
146767 sqlite3 *db = pSubst->pParse->db;
146803 CollSeq *pNat = sqlite3ExprCollSeq(pSubst->pParse, pExpr);
146804 CollSeq *pColl = sqlite3ExprCollSeq(pSubst->pParse,
146808 pExpr = sqlite3ExprAddCollateString(pSubst->pParse, pExpr,
146922 Parse *pParse, /* Parse context */
146934 aCsrMap[pItem->iCursor+1] = pParse->nTab++;
146938 srclistRenumberCursors(pParse, aCsrMap, p->pSrc, -1);
146989 Parse *pParse, /* Parse context */
146995 srclistRenumberCursors(pParse, aCsrMap, p->pSrc, iExcept);
147219 Parse *pParse, /* Parsing context */
147224 const char *zSavedAuthContext = pParse->zAuthContext;
147236 sqlite3 *db = pParse->db;
147370 if( pParse->nSelect>500 ) return 0;
147372 aCsrMap = sqlite3DbMallocZero(db, ((i64)pParse->nTab+1)*sizeof(int));
147373 if( aCsrMap ) aCsrMap[0] = pParse->nTab;
147378 TREETRACE(0x4,pParse,p,("flatten %u.%p from term %d\n",
147382 pParse->zAuthContext = pSubitem->zName;
147383 TESTONLY(i =) sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0);
147385 pParse->zAuthContext = zSavedAuthContext;
147449 pNew->selId = ++pParse->nSelect;
147451 renumberCursors(pParse, pNew, iFrom, aCsrMap);
147457 TREETRACE(0x4,pParse,p,("compound-subquery flattener"
147478 Parse *pToplevel = sqlite3ParseToplevel(pParse);
147530 pSrc = sqlite3SrcListEnlarge(pParse, pSrc, nSubSrc-1,iFrom+1);
147588 pParent->pWhere = sqlite3PExpr(pParse, TK_AND, pWhere, pParent->pWhere);
147595 x.pParse = pParse;
147629 sqlite3AggInfoPersistWalkerInit(&w, pParse);
147635 TREETRACE(0x4,pParse,p,("After flattening:\n"));
147650 Parse *pParse; /* Parsing context */
147651 u8 *pOomFault; /* Pointer to pParse->db->mallocFailed */
147676 assert( sqlite3ExprIsConstant(pConst->pParse, pValue) );
147680 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pConst->pParse,pExpr)) ){
147700 pConst->apExpr = sqlite3DbReallocOrFree(pConst->pParse->db, pConst->apExpr,
147734 if( pRight->op==TK_COLUMN && sqlite3ExprIsConstant(pConst->pParse, pLeft) ){
147737 if( pLeft->op==TK_COLUMN && sqlite3ExprIsConstant(pConst->pParse, pRight) ){
147778 pExpr->pLeft = sqlite3ExprDup(pConst->pParse->db, pConst->apExpr[i*2+1], 0);
147779 if( pConst->pParse->db->mallocFailed ) return WRC_Prune;
147873 Parse *pParse, /* The parsing context */
147879 x.pParse = pParse;
147880 x.pOomFault = &pParse->db->mallocFailed;
147900 w.pParse = pParse;
147907 sqlite3DbFree(x.pParse->db, x.apExpr);
147934 static int pushDownWindowCheck(Parse *pParse, Select *pSubq, Expr *pExpr){
147938 return sqlite3ExprIsConstantOrGroupBy(pParse, pExpr, pSubq->pWin->pPartition);
148052 Parse *pParse, /* Parse context (for malloc() and error reporting) */
148093 CollSeq *pColl = sqlite3ExprCollSeq(pParse, pList->a[ii].pExpr);
148123 nChng += pushDownWhereTerms(pParse, pSubq, pWhere->pRight, pSrcList, iSrc);
148175 pNew = sqlite3ExprDup(pParse->db, pWhere, 0);
148177 x.pParse = pParse;
148185 if( pSubq->pWin && 0==pushDownWindowCheck(pParse, pSubq, pNew) ){
148187 sqlite3ExprDelete(pParse->db, pNew);
148193 pSubq->pHaving = sqlite3ExprAnd(pParse, pSubq->pHaving, pNew);
148195 pSubq->pWhere = sqlite3ExprAnd(pParse, pSubq->pWhere, pNew);
148383 ** SQLITE_ERROR and leave an error in pParse. Otherwise, populate
148386 SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, SrcItem *pFrom){
148398 sqlite3ErrorMsg(pParse, "no such index: %s", zIndexedBy, 0);
148399 pParse->checkSchema = 1;
148435 Parse *pParse;
148458 pParse = pWalker->pParse;
148459 db = pParse->db;
148463 pNewSrc = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&dummy,pNew,0);
148467 p->pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ASTERISK, 0));
148490 ** arguments. If it does, leave an error message in pParse and return
148493 static int cannotBeFunction(Parse *pParse, SrcItem *pFrom){
148495 sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName);
148551 SQLITE_PRIVATE With *sqlite3WithPush(Parse *pParse, With *pWith, u8 bFree){
148554 pWith = (With*)sqlite3ParserAddCleanup(pParse, sqlite3WithDeleteGeneric,
148558 if( pParse->nErr==0 ){
148559 assert( pParse->pWith!=pWith );
148560 pWith->pOuter = pParse->pWith;
148561 pParse->pWith = pWith;
148570 ** pParse->pWith linked list). And if currently processing a CTE
148582 Parse *pParse, /* The parsing context */
148590 if( pParse->pWith==0 ){
148594 if( pParse->nErr ){
148595 /* Prior errors might have left pParse->pWith in a goofy state, so
148612 pCte = searchWith(pParse->pWith, pFrom, &pWith);
148614 sqlite3 *db = pParse->db;
148621 With *pSavedWith; /* Initial value of pParse->pWith */
148626 ** recursive reference to CTE pCte. Leave an error in pParse and return
148630 sqlite3ErrorMsg(pParse, pCte->zCteErr, pCte->zName);
148633 if( cannotBeFunction(pParse, pFrom) ) return 2;
148642 || sqlite3ParserAddCleanup(pParse,sqlite3DbFree,pCteUse)==0
148660 sqlite3ErrorMsg(pParse, "no such index: \"%s\"", pFrom->u1.zIndexedBy);
148684 sqlite3ErrorMsg(pParse,
148690 if( iRecTab<0 ) iRecTab = pParse->nTab++;
148699 pSavedWith = pParse->pWith;
148700 pParse->pWith = pWith;
148712 pParse->pWith = pSavedWith;
148717 pParse->pWith = pSavedWith;
148721 pParse->pWith = pWith;
148727 sqlite3ErrorMsg(pParse, "table %s has %d values for %d columns",
148730 pParse->pWith = pSavedWith;
148736 sqlite3ColumnsFromExprList(pParse, pEList, &pTab->nCol, &pTab->aCol);
148746 pParse->pWith = pSavedWith;
148763 Parse *pParse = pWalker->pParse;
148764 if( OK_IF_ALWAYS_TRUE(pParse->pWith) && p->pPrior==0 ){
148767 assert( pParse->pWith==pWith || pParse->nErr );
148768 pParse->pWith = pWith->pOuter;
148781 SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, SrcItem *pFrom){
148786 pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table));
148790 pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
148792 pTab->zName = sqlite3MPrintf(pParse->db, "%!S", pFrom);
148795 sqlite3ColumnsFromExprList(pParse, pSel->pEList,&pTab->nCol,&pTab->aCol);
148806 return pParse->nErr ? SQLITE_ERROR : SQLITE_OK;
148860 Parse *pParse = pWalker->pParse;
148865 sqlite3 *db = pParse->db;
148880 p->selId = ++pParse->nSelect;
148884 if( pParse->pWith && (p->selFlags & SF_View) ){
148893 sqlite3WithPush(pParse, p->pWith, 0);
148898 sqlite3SrcListAssignCursors(pParse, pTabList);
148916 if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort;
148919 }else if( (rc = resolveFromTermToCte(pParse, pWalker, pFrom))!=0 ){
148927 pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
148930 sqlite3ErrorMsg(pParse, "too many references to \"%s\": max 65535",
148936 if( !IsVirtual(pTab) && cannotBeFunction(pParse, pFrom) ){
148943 if( sqlite3ViewGetColumnNames(pParse, pTab) ) return WRC_Abort;
148949 sqlite3ErrorMsg(pParse, "access to view \"%s\" prohibited",
148960 sqlite3ErrorMsg(pParse, "unsafe use of virtual table \"%s\"",
148976 if( pFrom->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pFrom) ){
148983 assert( db->mallocFailed==0 || pParse->nErr!=0 );
148984 if( pParse->nErr || sqlite3ProcessJoin(pParse, p) ){
149015 int flags = pParse->db->flags;
149029 pNew = sqlite3ExprListAppend(pParse, pNew, a[k].pExpr);
149091 pNew = sqlite3ExprListAppend(pParse, pNew, pRight);
149168 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
149170 sqlite3RenameTokenRemap(pParse, pLeft, pE->pLeft);
149174 pExpr = sqlite3PExpr(pParse, TK_DOT, pLeft, pExpr);
149180 pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
149215 sqlite3ErrorMsg(pParse, "no such table: %s", zTName);
149217 sqlite3ErrorMsg(pParse, "no tables specified");
149227 sqlite3ErrorMsg(pParse, "too many columns in result set");
149236 TREETRACE(0x8,pParse,p,("After result-set wildcard expansion:\n"));
149262 ** If anything goes wrong, an error message is written into pParse.
149263 ** The calling function can detect the problem by looking at pParse->nErr
149264 ** and/or pParse->db->mallocFailed.
149266 static void sqlite3SelectExpand(Parse *pParse, Select *pSelect){
149269 w.pParse = pParse;
149270 if( OK_IF_ALWAYS_TRUE(pParse->hasCompound) ){
149297 Parse *pParse;
149304 pParse = pWalker->pParse;
149314 sqlite3SubqueryColumnTypes(pParse, pTab, pSel, SQLITE_AFF_NONE);
149329 static void sqlite3SelectAddTypeInfo(Parse *pParse, Select *pSelect){
149335 w.pParse = pParse;
149354 Parse *pParse, /* The parser context */
149358 assert( p!=0 || pParse->db->mallocFailed );
149359 assert( pParse->db->pParse==pParse );
149360 if( pParse->db->mallocFailed ) return;
149362 sqlite3SelectExpand(pParse, p);
149363 if( pParse->nErr ) return;
149364 sqlite3ResolveSelectNames(pParse, p, pOuterNC);
149365 if( pParse->nErr ) return;
149366 sqlite3SelectAddTypeInfo(pParse, p);
149449 Parse *pParse, /* Parsing context */
149471 TREETRACE(0x20, pParse, pSelect,
149474 for(pIEpr=pParse->pIdxEpr; pIEpr; pIEpr=pIEpr->pIENext){
149483 UNUSED_PARAMETER(pParse);
149542 static void assignAggregateRegisters(Parse *pParse, AggInfo *pAggInfo){
149545 pAggInfo->iFirstReg = pParse->nMem + 1;
149546 pParse->nMem += pAggInfo->nColumn + pAggInfo->nFunc;
149557 static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
149558 Vdbe *v = pParse->pVdbe;
149563 assert( pParse->db->pParse==pParse );
149564 assert( pParse->db->mallocFailed==0 || pParse->nErr!=0 );
149566 if( pParse->nErr ) return;
149574 sqlite3ErrorMsg(pParse, "DISTINCT aggregates must have exactly one "
149578 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0);
149581 ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s(DISTINCT)",
149605 pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pOBList, 0, nExtra);
149606 if( !pFunc->bOBUnique && pParse->nErr==0 ){
149612 ExplainQueryPlan((pParse, 0, "USE TEMP B-TREE FOR %s(ORDER BY)",
149622 static void finalizeAggFunctions(Parse *pParse, AggInfo *pAggInfo){
149623 Vdbe *v = pParse->pVdbe;
149643 regAgg = sqlite3GetTempRange(pParse, nArg);
149659 int regSubtype = sqlite3GetTempReg(pParse);
149665 sqlite3ReleaseTempReg(pParse, regSubtype);
149672 sqlite3ReleaseTempRange(pParse, regAgg, nArg);
149697 Parse *pParse,
149702 Vdbe *v = pParse->pVdbe;
149710 if( pParse->nErr ) return;
149732 if( regHit==0 ) regHit = ++pParse->nMem;
149742 addrNext = sqlite3VdbeMakeLabel(pParse);
149743 sqlite3ExprIfFalse(pParse, pFilter, addrNext, SQLITE_JUMPIFNULL);
149770 regAgg = sqlite3GetTempRange(pParse, regAggSz);
149772 sqlite3ExprCodeExprList(pParse, pOBList, regAgg, 0, SQLITE_ECEL_DUP);
149780 sqlite3ExprCodeExprList(pParse, pList, regDistinct, 0, SQLITE_ECEL_DUP);
149792 regAgg = sqlite3GetTempRange(pParse, nArg);
149794 sqlite3ExprCodeExprList(pParse, pList, regAgg, 0, SQLITE_ECEL_DUP);
149801 addrNext = sqlite3VdbeMakeLabel(pParse);
149803 pF->iDistinct = codeDistinct(pParse, eDistinctType,
149812 sqlite3ReleaseTempRange(pParse, regAgg, regAggSz);
149821 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
149824 pColl = pParse->db->pDfltColl;
149826 if( regHit==0 && pAggInfo->nAccumulator ) regHit = ++pParse->nMem;
149833 sqlite3ReleaseTempRange(pParse, regAgg, nArg);
149846 sqlite3ExprCode(pParse, pC->pCExpr, AggInfoColumnReg(pAggInfo,i));
149861 Parse *pParse, /* Parse context */
149865 if( pParse->explain==2 ){
149867 sqlite3VdbeExplain(pParse, 0, "SCAN %s%s%s",
149899 if( sqlite3ExprIsConstantOrGroupBy(pWalker->pParse, pExpr, pS->pGroupBy)
149903 sqlite3 *db = pWalker->pParse->db;
149908 pNew = sqlite3ExprAnd(pWalker->pParse, pWhere, pNew);
149933 static void havingToWhere(Parse *pParse, Select *p){
149936 sWalker.pParse = pParse;
149942 TREETRACE(0x100,pParse,p,("Move HAVING terms into WHERE:\n"));
150019 static int countOfViewOptimization(Parse *pParse, Select *p){
150053 db = pParse->db;
150059 p->pSrc = sqlite3DbMallocZero(pParse->db, sizeof(*p->pSrc));
150068 sqlite3ParserAddCleanup(pParse, sqlite3ExprListDeleteGeneric, pSub->pEList);
150070 pSub->pEList = sqlite3ExprListAppend(pParse, 0, pTerm);
150071 pTerm = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
150072 sqlite3PExprAddSelect(pParse, pTerm, pSub);
150076 pExpr = sqlite3PExpr(pParse, TK_PLUS, pTerm, pExpr);
150085 TREETRACE(0x200,pParse,p,("After count-of-view optimization:\n"));
150144 Parse *pParse, /* Parsing context */
150156 if( OptimizationDisabled(pParse->db, SQLITE_Coroutines) ) return 0; /* (4) */
150185 ** pParse->zErrMsg.
150191 Parse *pParse, /* The parser context */
150213 db = pParse->db;
150214 assert( pParse==db->pParse );
150215 v = sqlite3GetVdbe(pParse);
150216 if( p==0 || pParse->nErr ){
150220 if( sqlite3AuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1;
150222 TREETRACE(0x1,pParse,p, ("begin processing:\n", pParse->addrExplain));
150243 TREETRACE(0x800,pParse,p, ("dropping superfluous ORDER BY:\n"));
150248 sqlite3ParserAddCleanup(pParse, sqlite3ExprListDeleteGeneric,
150250 testcase( pParse->earlyCleanup );
150256 sqlite3SelectPrep(pParse, p, 0);
150257 if( pParse->nErr ){
150264 TREETRACE(0x10,pParse,p, ("after name resolution:\n"));
150281 sqlite3ErrorMsg(pParse,
150296 sqlite3GenerateColumnNames(pParse, p);
150300 if( sqlite3WindowRewrite(pParse, p) ){
150301 assert( pParse->nErr );
150306 TREETRACE(0x40,pParse,p, ("after window rewrite:\n"));
150348 TREETRACE(0x1000,pParse,p,
150352 TREETRACE(0x1000,pParse,p,
150363 TREETRACE(0x1000,pParse,p,
150367 TREETRACE(0x1000,pParse,p,
150387 sqlite3ErrorMsg(pParse, "expected %d columns for '%s' but got %d",
150439 TREETRACE(0x800,pParse,p,
150441 sqlite3ParserAddCleanup(pParse, sqlite3ExprListDeleteGeneric,
150473 if( flattenSubquery(pParse, p, i, isAgg) ){
150474 if( pParse->nErr ) goto select_end;
150491 rc = multiSelect(pParse, p, pDest);
150493 TREETRACE(0x400,pParse,p,("end compound-select processing\n"));
150494 if( (sqlite3TreeTrace & 0x400)!=0 && ExplainQueryPlanParent(pParse)==0 ){
150498 if( p->pNext==0 ) ExplainQueryPlanPop(pParse);
150511 && propagateConstants(pParse, p)
150515 TREETRACE(0x2000,pParse,p,("After constant propagation:\n"));
150520 TREETRACE(0x2000,pParse,p,("Constant propagation not helpful\n"));
150524 && countOfViewOptimization(pParse, p)
150560 sqlite3AuthCheck(pParse, SQLITE_READ, pItem->zName, "", pItem->zDatabase);
150579 pParse->nHeight += sqlite3SelectExprHeight(p);
150587 && pushDownWhereTerms(pParse, pSub, p->pWhere, pTabList, i)
150591 TREETRACE(0x4000,pParse,p,
150598 TREETRACE(0x4000,pParse,p,("WHERE-lcause push-down not possible\n"));
150609 TREETRACE(0x4000,pParse,p,
150617 zSavedAuthContext = pParse->zAuthContext;
150618 pParse->zAuthContext = pItem->zName;
150622 if( fromClauseTermCanBeCoroutine(pParse, pTabList, i, p->selFlags) ){
150628 pItem->regReturn = ++pParse->nMem;
150633 ExplainQueryPlan((pParse, 1, "CO-ROUTINE %!S", pItem));
150634 sqlite3Select(pParse, pSub, &dest);
150640 sqlite3ClearTempRegCache(pParse);
150671 pItem->regReturn = ++pParse->nMem;
150686 ExplainQueryPlan2(addrExplain, (pParse, 1, "MATERIALIZE %!S", pItem));
150687 sqlite3Select(pParse, pSub, &dest);
150694 sqlite3ClearTempRegCache(pParse);
150704 pParse->nHeight -= sqlite3SelectExprHeight(p);
150705 pParse->zAuthContext = zSavedAuthContext;
150719 TREETRACE(0x8000,pParse,p,("After all FROM-clause analysis:\n"));
150756 TREETRACE(0x20000,pParse,p,("Transform DISTINCT into GROUP BY:\n"));
150773 pParse, sSort.pOrderBy, 0, pEList->nExpr);
150774 sSort.iECursor = pParse->nTab++;
150804 iEnd = sqlite3VdbeMakeLabel(pParse);
150808 if( p->pLimit ) computeLimitRegisters(pParse, p, iEnd);
150817 sDistinct.tabTnct = pParse->nTab++;
150820 (char*)sqlite3KeyInfoFromExprList(pParse, p->pEList,0,0),
150835 sqlite3WindowCodeInit(pParse, p);
150842 TREETRACE(0x2,pParse,p,("WhereBegin\n"));
150843 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, sSort.pOrderBy,
150859 TREETRACE(0x2,pParse,p,("WhereBegin returns\n"));
150872 int addrGosub = sqlite3VdbeMakeLabel(pParse);
150873 int iCont = sqlite3VdbeMakeLabel(pParse);
150874 int iBreak = sqlite3VdbeMakeLabel(pParse);
150875 int regGosub = ++pParse->nMem;
150877 sqlite3WindowCodeStep(pParse, p, pWInfo, regGosub, addrGosub);
150883 selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest, iCont, iBreak);
150892 selectInnerLoop(pParse, p, -1, &sSort, &sDistinct, pDest,
150898 TREETRACE(0x2,pParse,p,("WhereEnd\n"));
150963 addrEnd = sqlite3VdbeMakeLabel(pParse);
150971 sqlite3ParserAddCleanup(pParse, agginfoFree, pAggInfo);
150972 testcase( pParse->earlyCleanup );
150982 sNC.pParse = pParse;
150995 havingToWhere(pParse, p);
151010 TREETRACE(0x20,pParse,p,("After aggregate analysis %p:\n", pAggInfo));
151047 pDistinct = sqlite3ExprListAppend(pParse, pDistinct, pExpr);
151056 pAggInfo->sortingIdx = pParse->nTab++;
151057 pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pGroupBy,
151065 iUseFlag = ++pParse->nMem;
151066 iAbortFlag = ++pParse->nMem;
151067 regOutputRow = ++pParse->nMem;
151068 addrOutputRow = sqlite3VdbeMakeLabel(pParse);
151069 regReset = ++pParse->nMem;
151070 addrReset = sqlite3VdbeMakeLabel(pParse);
151071 iAMem = pParse->nMem + 1;
151072 pParse->nMem += pGroupBy->nExpr;
151073 iBMem = pParse->nMem + 1;
151074 pParse->nMem += pGroupBy->nExpr;
151085 TREETRACE(0x2,pParse,p,("WhereBegin\n"));
151086 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, pDistinct,
151094 if( pParse->pIdxEpr ){
151095 optimizeAggregateUseOfIndexedExpr(pParse, p, pAggInfo, &sNC);
151097 assignAggregateRegisters(pParse, pAggInfo);
151099 TREETRACE(0x2,pParse,p,("WhereBegin returns\n"));
151120 ExplainQueryPlan2(addrExp, (pParse, 0, "USE TEMP B-TREE FOR %s",
151135 regBase = sqlite3GetTempRange(pParse, nCol);
151136 sqlite3ExprCodeExprList(pParse, pGroupBy, regBase, 0, 0);
151142 sqlite3ExprCode(pParse, pCol->pCExpr, j + regBase);
151147 regRecord = sqlite3GetTempReg(pParse);
151152 sqlite3ReleaseTempReg(pParse, regRecord);
151153 sqlite3ReleaseTempRange(pParse, regBase, nCol);
151154 TREETRACE(0x2,pParse,p,("WhereEnd\n"));
151156 pAggInfo->sortingIdxPTab = sortPTab = pParse->nTab++;
151157 sortOut = sqlite3GetTempReg(pParse);
151172 if( pParse->pIdxEpr ){
151176 TREETRACE(0x20, pParse, p,
151213 sqlite3ExprCode(pParse, pGroupBy->a[j].pExpr, iBMem+j);
151230 sqlite3ExprCodeMove(pParse, iBMem, iAMem, pGroupBy->nExpr);
151242 updateAccumulator(pParse, iUseFlag, pAggInfo, eDist);
151252 TREETRACE(0x2,pParse,p,("WhereEnd\n"));
151284 finalizeAggFunctions(pParse, pAggInfo);
151285 sqlite3ExprIfFalse(pParse, pHaving, addrOutputRow+1, SQLITE_JUMPIFNULL);
151286 selectInnerLoop(pParse, p, -1, &sSort,
151295 resetAccumulator(pParse, pAggInfo);
151302 fixDistinctOpenEph(pParse, eDist, pF->iDistinct, pF->iDistAddr);
151321 const int iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
151322 const int iCsr = pParse->nTab++; /* Cursor to scan b-tree */
151328 sqlite3CodeVerifySchema(pParse, iDb);
151329 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
151354 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest);
151362 assignAggregateRegisters(pParse, pAggInfo);
151365 explainSimpleCount(pParse, pTab, pBest);
151391 regAcc = ++pParse->nMem;
151399 assignAggregateRegisters(pParse, pAggInfo);
151406 resetAccumulator(pParse, pAggInfo);
151416 TREETRACE(0x2,pParse,p,("WhereBegin\n"));
151417 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMaxOrderBy,
151422 TREETRACE(0x2,pParse,p,("WhereBegin returns\n"));
151424 updateAccumulator(pParse, regAcc, pAggInfo, eDist);
151428 fixDistinctOpenEph(pParse, eDist, pF->iDistinct, pF->iDistAddr);
151436 TREETRACE(0x2,pParse,p,("WhereEnd\n"));
151438 finalizeAggFunctions(pParse, pAggInfo);
151442 sqlite3ExprIfFalse(pParse, pHaving, addrEnd, SQLITE_JUMPIFNULL);
151443 selectInnerLoop(pParse, p, -1, 0, 0,
151451 explainTempTable(pParse, "DISTINCT");
151459 generateSortTail(pParse, p, &sSort, pEList->nExpr, pDest);
151468 rc = (pParse->nErr>0);
151475 assert( db->mallocFailed==0 || pParse->nErr!=0 );
151481 TREETRACE(0x20,pParse,p,("Finished with AggInfo\n"));
151501 TREETRACE(0x1,pParse,p,("end processing\n"));
151502 if( (sqlite3TreeTrace & 0x40000)!=0 && ExplainQueryPlanParent(pParse)==0 ){
151506 ExplainQueryPlanPop(pParse);
151762 SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *pParse, Table *pTab){
151767 assert( pParse->disableTriggers==0 );
151768 pTmpSchema = pParse->db->aDb[1].pSchema;
151782 assert( pParse->db->pVtabCtx==0 );
151784 assert( pParse->bReturning );
151785 assert( &(pParse->u1.pReturning->retTrig) == pTrig );
151811 ** in pParse->pNewTrigger. After the trigger actions have been parsed, the
151816 Parse *pParse, /* The parse context of the CREATE TRIGGER statement */
151830 sqlite3 *db = pParse->db; /* The database connection */
151842 sqlite3ErrorMsg(pParse, "temporary trigger may not have qualified name");
151849 iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
151876 pTab = sqlite3SrcListLookup(pParse, pTableName);
151885 sqlite3FixInit(&sFix, pParse, iDb, "trigger", pName);
151889 pTab = sqlite3SrcListLookup(pParse, pTableName);
151895 sqlite3ErrorMsg(pParse, "cannot create triggers on virtual tables");
151899 sqlite3ErrorMsg(pParse, "cannot create triggers on shadow tables");
151910 if( sqlite3CheckObjectName(pParse, zName, "trigger", pTab->zName) ){
151917 sqlite3ErrorMsg(pParse, "trigger %T already exists", pName);
151920 sqlite3CodeVerifySchema(pParse, iDb);
151921 VVA_ONLY( pParse->ifNotExists = 1; )
151929 sqlite3ErrorMsg(pParse, "cannot create trigger on system table");
151937 sqlite3ErrorMsg(pParse, "cannot create %s trigger on view: %S",
151942 sqlite3ErrorMsg(pParse, "cannot create INSTEAD OF"
151954 if( sqlite3AuthCheck(pParse, code, zName, pTab->zName, zDbTrig) ){
151957 if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(iTabDb),0,zDb)){
151983 sqlite3RenameTokenRemap(pParse, pTrigger->table, pTableName->a[0].zName);
151991 assert( pParse->pNewTrigger==0 );
151992 pParse->pNewTrigger = pTrigger;
151999 if( !pParse->pNewTrigger ){
152002 assert( pParse->pNewTrigger==pTrigger );
152028 Parse *pParse, /* Parser context */
152032 Trigger *pTrig = pParse->pNewTrigger; /* Trigger being finished */
152034 sqlite3 *db = pParse->db; /* The database */
152039 pParse->pNewTrigger = 0;
152040 if( NEVER(pParse->nErr) || !pTrig ) goto triggerfinish_cleanup;
152042 iDb = sqlite3SchemaToIndex(pParse->db, pTrig->pSchema);
152049 sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken);
152059 pParse->pNewTrigger = pTrig;
152080 sqlite3ErrorMsg(pParse,
152089 v = sqlite3GetVdbe(pParse);
152091 sqlite3BeginWriteOperation(pParse, 0, iDb);
152094 sqlite3NestedParse(pParse,
152100 sqlite3ChangeCookie(pParse, iDb);
152124 assert( IN_RENAME_OBJECT || !pParse->pNewTrigger );
152171 Parse *pParse, /* Parser context */
152177 sqlite3 *db = pParse->db;
152180 if( pParse->nErr ) return 0;
152190 sqlite3RenameTokenMap(pParse, pTriggerStep->zTarget, pName);
152204 Parse *pParse, /* Parser */
152213 sqlite3 *db = pParse->db;
152218 pTriggerStep = triggerStepAllocate(pParse, TK_INSERT, pTableName,zStart,zEnd);
152230 sqlite3HasExplicitNulls(pParse, pUpsert->pUpsertTarget);
152249 Parse *pParse, /* Parser */
152258 sqlite3 *db = pParse->db;
152261 pTriggerStep = triggerStepAllocate(pParse, TK_UPDATE, pTableName,zStart,zEnd);
152289 Parse *pParse, /* Parser */
152295 sqlite3 *db = pParse->db;
152298 pTriggerStep = triggerStepAllocate(pParse, TK_DELETE, pTableName,zStart,zEnd);
152333 SQLITE_PRIVATE void sqlite3DropTrigger(Parse *pParse, SrcList *pName, int noErr){
152338 sqlite3 *db = pParse->db;
152341 if( SQLITE_OK!=sqlite3ReadSchema(pParse) ){
152358 sqlite3ErrorMsg(pParse, "no such trigger: %S", pName->a);
152360 sqlite3CodeVerifyNamedSchema(pParse, zDb);
152362 pParse->checkSchema = 1;
152365 sqlite3DropTriggerPtr(pParse, pTrigger);
152383 SQLITE_PRIVATE void sqlite3DropTriggerPtr(Parse *pParse, Trigger *pTrigger){
152386 sqlite3 *db = pParse->db;
152389 iDb = sqlite3SchemaToIndex(pParse->db, pTrigger->pSchema);
152399 if( sqlite3AuthCheck(pParse, code, pTrigger->zName, pTable->zName, zDb) ||
152400 sqlite3AuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){
152408 if( (v = sqlite3GetVdbe(pParse))!=0 ){
152409 sqlite3NestedParse(pParse,
152413 sqlite3ChangeCookie(pParse, iDb);
152480 Parse *pParse, /* Parse context */
152490 pList = sqlite3TriggerList(pParse, pTab);
152495 if( (pParse->db->flags & SQLITE_EnableTrigger)==0
152515 assert( sqlite3IsToplevel(pParse) );
152519 sqlite3ErrorMsg(pParse,
152529 && sqlite3IsToplevel(pParse) ){
152543 Parse *pParse, /* Parse context */
152550 if( (pTab->pTrigger==0 && !tempTriggersExist(pParse->db))
152551 || pParse->disableTriggers
152556 return triggersReallyExist(pParse,pTab,op,pChanges,pMask);
152570 Parse *pParse, /* The parsing context */
152573 sqlite3 *db = pParse->db;
152576 pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
152590 pSubquery = sqlite3SelectNew(pParse,0,pDup,0,0,0,0,SF_NestedFrom,0);
152593 pDup = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&as,pSubquery,0);
152595 pSrc = sqlite3SrcListAppendList(pParse, pSrc, pDup);
152609 Parse *pParse, /* Parsing context */
152618 sqlite3ErrorMsg(pParse, "RETURNING may not use \"TABLE.*\" wildcards");
152629 Parse *pParse, /* Parsing context */
152634 sqlite3 *db = pParse->db;
152640 if( isAsteriskTerm(pParse, pOldExpr) ){
152646 pNew = sqlite3ExprListAppend(pParse, pNew, pNewExpr);
152655 pNew = sqlite3ExprListAppend(pParse, pNew, pNewExpr);
152738 Parse *pParse, /* Parse context */
152743 Vdbe *v = pParse->pVdbe;
152744 sqlite3 *db = pParse->db;
152751 if( !pParse->bReturning ){
152756 assert( db->pParse==pParse );
152757 pReturning = pParse->u1.pReturning;
152770 sqlite3SelectPrep(pParse, &sSelect, 0);
152771 if( pParse->nErr==0 ){
152773 sqlite3GenerateColumnNames(pParse, &sSelect);
152776 pNew = sqlite3ExpandReturning(pParse, pReturning->pReturnEL, pTab);
152777 if( pParse->nErr==0 ){
152782 pReturning->iRetCur = pParse->nTab++;
152784 sNC.pParse = pParse;
152787 pParse->eTriggerOp = pTrigger->op;
152788 pParse->pTriggerTab = pTab;
152794 int reg = pParse->nMem+1;
152796 pParse->nMem += nCol+2;
152801 sqlite3ExprCodeFactorable(pParse, pCol, reg+i);
152812 pParse->eTriggerOp = 0;
152813 pParse->pTriggerTab = 0;
152823 Parse *pParse, /* The parser context */
152828 Vdbe *v = pParse->pVdbe;
152829 sqlite3 *db = pParse->db;
152831 assert( pParse->pTriggerTab && pParse->pToplevel );
152848 pParse->eOrconf = (orconf==OE_Default)?pStep->orconf:(u8)orconf;
152849 assert( pParse->okConstFactor==0 );
152861 sqlite3Update(pParse,
152862 sqlite3TriggerStepSrc(pParse, pStep),
152865 pParse->eOrconf, 0, 0, 0
152871 sqlite3Insert(pParse,
152872 sqlite3TriggerStepSrc(pParse, pStep),
152875 pParse->eOrconf,
152882 sqlite3DeleteFrom(pParse,
152883 sqlite3TriggerStepSrc(pParse, pStep),
152893 sqlite3Select(pParse, pSelect, &sDest);
152943 Parse *pParse, /* Current parse context */
152948 Parse *pTop = sqlite3ParseToplevel(pParse);
152949 sqlite3 *db = pParse->db; /* Database handle */
152980 sNC.pParse = &sSubParse;
152985 sSubParse.nQueryLoop = pParse->nQueryLoop;
152986 sSubParse.prepFlags = pParse->prepFlags;
153029 transferParseError(pParse, &sSubParse);
153031 if( pParse->nErr==0 ){
153042 transferParseError(pParse, &sSubParse);
153057 Parse *pParse, /* Current parse context */
153062 Parse *pRoot = sqlite3ParseToplevel(pParse);
153078 pPrg = codeRowTrigger(pParse, pTrigger, pTab, orconf);
153079 pParse->db->errByteOffset = -1;
153092 Parse *pParse, /* Parse context */
153099 Vdbe *v = sqlite3GetVdbe(pParse); /* Main VM */
153101 pPrg = getRowTrigger(pParse, p, pTab, orconf);
153102 assert( pPrg || pParse->nErr );
153107 int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
153109 sqlite3VdbeAddOp4(v, OP_Program, reg, ignoreJump, ++pParse->nMem,
153164 Parse *pParse, /* Parse context */
153188 || p->pSchema==pParse->db->aDb[1].pSchema );
153200 sqlite3CodeRowTriggerDirect(pParse, p, pTab, reg, orconf, ignoreJump);
153201 }else if( sqlite3IsToplevel(pParse) ){
153202 codeReturningTrigger(pParse, p, pTab, reg);
153234 Parse *pParse, /* Parse context */
153259 pPrg = getRowTrigger(pParse, p, pTab, orconf);
153293 Parse *pParse, /* The parsing context */
153416 static Expr *exprRowColumn(Parse *pParse, int iCol){
153417 Expr *pRet = sqlite3PExpr(pParse, TK_ROW, 0, 0);
153461 Parse *pParse, /* Parse context */
153477 sqlite3 *db = pParse->db;
153485 sqlite3ErrorMsg(pParse, "ORDER BY without LIMIT on UPDATE");
153507 Expr *pNew = exprRowColumn(pParse, pPk->aiColumn[i]);
153510 pGrp = sqlite3ExprListAppend(pParse, pGrp, sqlite3ExprDup(db, pNew, 0));
153513 pList = sqlite3ExprListAppend(pParse, pList, pNew);
153518 pList = sqlite3ExprListAppend(pParse, pList, exprRowColumn(pParse, i));
153523 pList = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0));
153526 pGrp = sqlite3ExprListAppend(pParse, 0, sqlite3PExpr(pParse,TK_ROW,0,0));
153530 assert( pChanges!=0 || pParse->db->mallocFailed );
153533 pList = sqlite3ExprListAppend(pParse, pList,
153538 pSelect = sqlite3SelectNew(pParse, pList,
153545 sqlite3Select(pParse, pSelect, &dest);
153559 Parse *pParse, /* The parser context */
153626 db = pParse->db;
153627 assert( db->pParse==pParse );
153628 if( pParse->nErr ){
153635 pTab = sqlite3SrcListLookup(pParse, pTabList);
153637 iDb = sqlite3SchemaToIndex(pParse->db, pTab->pSchema);
153643 pTrigger = sqlite3TriggersExist(pParse, pTab, TK_UPDATE, pChanges, &tmask);
153659 sqlite3TreeViewUpdate(pParse->pWith, pTabList, pChanges, pWhere,
153674 pParse, pTabList, pWhere, pOrderBy, pLimit, "UPDATE"
153681 if( sqlite3ViewGetColumnNames(pParse, pTab) ){
153684 if( sqlite3IsReadOnly(pParse, pTab, pTrigger) ){
153693 iBaseCur = iDataCur = pParse->nTab++;
153699 iDataCur = pParse->nTab;
153701 pParse->nTab++;
153707 pParse->nTab = iBaseCur;
153724 sNC.pParse = pParse;
153730 v = sqlite3GetVdbe(pParse);
153762 sqlite3ErrorMsg(pParse,
153779 sqlite3ErrorMsg(pParse, "no such column: %s", pChanges->a[i].zEName);
153780 pParse->checkSchema = 1;
153787 rc = sqlite3AuthCheck(pParse, SQLITE_UPDATE, pTab->zName,
153839 hasFK = sqlite3FkRequired(pParse, pTab, aXRef, chngKey);
153851 reg = ++pParse->nMem;
153852 pParse->nMem += pIdx->nColumn;
153857 reg = ++pParse->nMem;
153858 pParse->nMem += pIdx->nColumn;
153869 aRegIdx[nAllIdx] = ++pParse->nMem; /* Register storing the table record */
153876 if( pParse->nested==0 ) sqlite3VdbeCountChanges(v);
153877 sqlite3BeginWriteOperation(pParse, pTrigger || hasFK, iDb);
153886 assert( aRegIdx[nAllIdx]==pParse->nMem );
153888 regOldRowid = regNewRowid = ++pParse->nMem;
153890 regOld = pParse->nMem + 1;
153891 pParse->nMem += pTab->nCol;
153894 regNewRowid = ++pParse->nMem;
153896 regNew = pParse->nMem + 1;
153897 pParse->nMem += pTab->nCol;
153902 sqlite3AuthContextPush(pParse, &sContext, pTab->zName);
153910 sqlite3MaterializeView(pParse, pTab,
153928 updateVirtualTable(pParse, pTabList, pTab, pChanges, pRowidExpr, aXRef,
153935 labelContinue = labelBreak = sqlite3VdbeMakeLabel(pParse);
153940 && !pParse->pTriggerTab
153941 && !pParse->nested
153942 && !pParse->bReturning
153945 regRowCount = ++pParse->nMem;
153951 iEph = pParse->nTab++;
153956 iPk = pParse->nMem+1;
153957 pParse->nMem += nPk;
153958 pParse->nMem += nChangeFrom;
153959 regKey = ++pParse->nMem;
153962 iEph = pParse->nTab++;
153966 KeyInfo *pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pPk);
153974 pParse, iEph, pPk, pChanges, pTabList, pWhere, pOrderBy, pLimit
153984 sqlite3MultiWrite(pParse);
153997 sqlite3ExprIfFalse(pParse, pWhere, labelBreak, SQLITE_JUMPIFNULL);
154012 if( !pParse->nested
154021 pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere,0,0,0,flags,iIdxCur);
154037 sqlite3MultiWrite(pParse);
154054 aRegIdx[nAllIdx] = ++pParse->nMem;
154101 sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, iBaseCur,
154121 labelContinue = sqlite3VdbeMakeLabel(pParse);
154127 labelContinue = sqlite3VdbeMakeLabel(pParse);
154153 labelContinue = sqlite3VdbeMakeLabel(pParse);
154169 sqlite3ExprCode(pParse, pRowidExpr, regNewRowid);
154179 u32 oldmask = (hasFK ? sqlite3FkOldmask(pParse, pTab) : 0);
154180 oldmask |= sqlite3TriggerColmask(pParse,
154218 pParse, pTrigger, pChanges, 1, TRIGGER_BEFORE, pTab, onError
154233 sqlite3ExprCode(pParse, pChanges->a[j].pExpr, k);
154254 sqlite3ComputeGeneratedColumns(pParse, regNew, pTab);
154263 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
154301 sqlite3ComputeGeneratedColumns(pParse, regNew, pTab);
154310 sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
154328 sqlite3FkCheck(pParse, pTab, regOldRowid, 0, aXRef, chngKey);
154332 sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur, aRegIdx, -1);
154362 if( !pParse->nested ){
154372 sqlite3FkCheck(pParse, pTab, 0, regNewRowid, aXRef, chngKey);
154377 pParse, pTab, iDataCur, iIdxCur, regNewRowid, aRegIdx,
154386 sqlite3FkActions(pParse, pTab, pChanges, regOldRowid, aXRef, chngKey);
154397 sqlite3CodeRowTrigger(pParse, pTrigger, TK_UPDATE, pChanges,
154419 if( pParse->nested==0 && pParse->pTriggerTab==0 && pUpsert==0 ){
154420 sqlite3AutoincrementEnd(pParse);
154476 Parse *pParse, /* The parsing context */
154485 Vdbe *v = pParse->pVdbe; /* Virtual machine under construction */
154488 sqlite3 *db = pParse->db; /* Database connection */
154504 ephemTab = pParse->nTab++;
154506 regArg = pParse->nMem + 1;
154507 pParse->nMem += nArg;
154516 pRow = sqlite3PExpr(pParse, TK_ROW, 0, 0);
154527 pRow = exprRowColumn(pParse, iPk);
154530 pList = sqlite3ExprListAppend(pParse, 0, pRow);
154534 pList = sqlite3ExprListAppend(pParse, pList,
154538 Expr *pRowExpr = exprRowColumn(pParse, i);
154540 pList = sqlite3ExprListAppend(pParse, pList, pRowExpr);
154544 updateFromSelect(pParse, ephemTab, pPk, pList, pSrc, pWhere, 0, 0);
154548 regRec = ++pParse->nMem;
154549 regRowid = ++pParse->nMem;
154553 pParse, pSrc, pWhere, 0, 0, 0, WHERE_ONEPASS_DESIRED, 0
154561 sqlite3ExprCode(pParse, pChanges->a[aXRef[i]].pExpr, regArg+2+i);
154570 sqlite3ExprCode(pParse, pRowid, regArg+1);
154598 sqlite3MultiWrite(pParse);
154626 sqlite3VtabMakeWritable(pParse, pTab);
154629 sqlite3MayAbort(pParse);
154735 Parse *pParse, /* The parsing context */
154760 sNC.pParse = pParse;
154802 if( sqlite3ExprCompare(pParse, pUpsert->pUpsertTargetWhere,
154858 sqlite3ErrorMsg(pParse, "%sON CONFLICT clause does not match any "
154912 Parse *pParse, /* The parsing and code-generating context */
154918 Vdbe *v = pParse->pVdbe;
154919 sqlite3 *db = pParse->db;
154932 int regRowid = sqlite3GetTempReg(pParse);
154936 sqlite3ReleaseTempReg(pParse, regRowid);
154940 int iPk = pParse->nMem+1;
154941 pParse->nMem += nPk;
154955 sqlite3MayAbort(pParse);
154968 sqlite3Update(pParse, pSrc, sqlite3ExprListDup(db,pUpsert->pUpsertSet,0),
155081 SQLITE_PRIVATE void sqlite3Vacuum(Parse *pParse, Token *pNm, Expr *pInto){
155082 Vdbe *v = sqlite3GetVdbe(pParse);
155085 if( pParse->nErr ) goto build_vacuum_end;
155090 iDb = sqlite3TwoPartName(pParse, pNm, pNm, &pNm);
155098 iDb = sqlite3FindDb(pParse->db, pNm);
155104 if( pInto && sqlite3ResolveSelfReference(pParse,0,0,pInto,0)==0 ){
155105 iIntoReg = ++pParse->nMem;
155106 sqlite3ExprCode(pParse, pInto, iIntoReg);
155112 sqlite3ExprDelete(pParse->db, pInto);
155751 static void addModuleArgument(Parse *pParse, Table *pTable, char *zArg){
155754 sqlite3 *db = pParse->db;
155759 sqlite3ErrorMsg(pParse, "too many columns on %s", pTable->zName);
155778 Parse *pParse, /* Parsing context */
155787 sqlite3StartTable(pParse, pName1, pName2, 0, 0, 1, ifNotExists);
155788 pTable = pParse->pNewTable;
155793 db = pParse->db;
155796 addModuleArgument(pParse, pTable, sqlite3NameFromToken(db, pModuleName));
155797 addModuleArgument(pParse, pTable, 0);
155798 addModuleArgument(pParse, pTable, sqlite3DbStrDup(db, pTable->zName));
155799 assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0)
155800 || (pParse->sNameToken.z==pName1->z && pName2->z==0)
155802 pParse->sNameToken.n = (int)(
155803 &pModuleName->z[pModuleName->n] - pParse->sNameToken.z
155815 sqlite3AuthCheck(pParse, SQLITE_CREATE_VTABLE, pTable->zName,
155816 pTable->u.vtab.azArg[0], pParse->db->aDb[iDb].zDbSName);
155823 ** in pParse->zArg[] and appends it to the list of arguments on the
155824 ** virtual table currently under construction in pParse->pTable.
155826 static void addArgumentToVtab(Parse *pParse){
155827 if( pParse->sArg.z && pParse->pNewTable ){
155828 const char *z = (const char*)pParse->sArg.z;
155829 int n = pParse->sArg.n;
155830 sqlite3 *db = pParse->db;
155831 addModuleArgument(pParse, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));
155839 SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
155840 Table *pTab = pParse->pNewTable; /* The table being constructed */
155841 sqlite3 *db = pParse->db; /* The database connection */
155845 addArgumentToVtab(pParse);
155846 pParse->sArg.z = 0;
155862 sqlite3MayAbort(pParse);
155866 pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n;
155868 zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
155874 ** The VM register number pParse->regRowid holds the rowid of an
155879 sqlite3NestedParse(pParse,
155887 pParse->regRowid
155889 v = sqlite3GetVdbe(pParse);
155890 sqlite3ChangeCookie(pParse, iDb);
155897 iReg = ++pParse->nMem;
155914 pParse->pNewTable = 0;
155922 SQLITE_PRIVATE void sqlite3VtabArgInit(Parse *pParse){
155923 addArgumentToVtab(pParse);
155924 pParse->sArg.z = 0;
155925 pParse->sArg.n = 0;
155932 SQLITE_PRIVATE void sqlite3VtabArgExtend(Parse *pParse, Token *p){
155933 Token *pArg = &pParse->sArg;
156084 ** and an error left in pParse.
156088 SQLITE_PRIVATE int sqlite3VtabCallConnect(Parse *pParse, Table *pTab){
156089 sqlite3 *db = pParse->db;
156106 sqlite3ErrorMsg(pParse, "no such module: %s", zModule);
156112 sqlite3ErrorMsg(pParse, "%s", zErr);
156113 pParse->rc = rc;
156606 ** Make sure virtual table pTab is contained in the pParse->apVirtualLock[]
156611 SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
156612 Parse *pToplevel = sqlite3ParseToplevel(pParse);
156635 ** and an error message was left in pParse.
156645 SQLITE_PRIVATE int sqlite3VtabEponymousTableInit(Parse *pParse, Module *pMod){
156650 sqlite3 *db = pParse->db;
156667 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
156668 addModuleArgument(pParse, pTab, 0);
156669 addModuleArgument(pParse, pTab, sqlite3DbStrDup(db, pTab->zName));
156672 sqlite3ErrorMsg(pParse, "%s", zErr);
157253 Parse *pParse; /* Parsing and code generating context */
157264 int savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */
157311 Parse *pParse, /* Parse context */
157317 const Parse *pParse, /* Parse context */
157336 Parse *pParse, /* Parsing context */
157533 Parse *pParse, /* Parse context */
157540 if( sqlite3ParseToplevel(pParse)->explain==2 || IS_STMT_SCANSTATUS(pParse->db) )
157544 Vdbe *v = pParse->pVdbe; /* VM being constructed */
157545 sqlite3 *db = pParse->db; /* Database handle */
157632 pParse->addrExplain, 0, zMsg,P4_DYNAMIC);
157648 const Parse *pParse, /* Parse context */
157654 Vdbe *v = pParse->pVdbe; /* VM being constructed */
157655 sqlite3 *db = pParse->db; /* Database handle */
157683 pParse->addrExplain, 0, zMsg,P4_DYNAMIC);
157821 static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){
157822 Vdbe *v = pParse->pVdbe;
157824 assert( pParse->db->mallocFailed );
157905 Parse *pParse, /* The parsing context */
157910 sqlite3 *db = pParse->db;
157935 pRhs = sqlite3ExprListAppend(pParse, pRhs, pOrigRhs->a[iField].pExpr);
157939 pLhs = sqlite3ExprListAppend(pParse,pLhs,pOrigLhs->a[iField].pExpr);
158001 Parse *pParse, /* The parsing context */
158009 Vdbe *v = pParse->pVdbe;
158015 iReg = sqlite3ExprCodeTarget(pParse, pX->pRight, iTarget);
158053 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, 0, &iTab);
158057 sqlite3 *db = pParse->db;
158058 pX = removeUnindexableInClauseTerms(pParse, iEq, pLoop, pX);
158060 aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*nEq);
158061 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap,&iTab);
158067 aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*MAX(nEq,n));
158068 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap, &iTab);
158084 pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse);
158136 sqlite3DbFree(pParse->db, aiMap);
158204 Parse *pParse, /* Parsing context */
158212 Vdbe *v = pParse->pVdbe; /* The vm under construction */
158231 regBase = pParse->nMem + 1;
158233 pParse->nMem += nReg;
158235 zAff = sqlite3DbStrDup(pParse->db,sqlite3IndexAffinityStr(pParse->db,pIdx));
158236 assert( zAff!=0 || pParse->db->mallocFailed );
158270 r1 = codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, regBase+j);
158273 sqlite3ReleaseTempReg(pParse, regBase);
158293 if( pParse->nErr==0 ){
158294 assert( pParse->db->mallocFailed==0 );
158337 || pTerm->pWC->pWInfo->pParse->db->mallocFailed );
158400 if( 0==sqlite3IsLikeFunction(pWalker->pParse->db, pExpr, &d1, d2) ){
158432 reg = ++pWalker->pParse->nMem; /* Register for column value */
158433 reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg);
158443 reg = ++pWalker->pParse->nMem; /* Register for column value */
158444 reg = sqlite3ExprCodeTarget(pWalker->pParse, pExpr, reg);
158463 Parse *pParse = pWInfo->pParse;
158464 sqlite3 *db = pParse->db;
158465 Vdbe *v = pParse->pVdbe;
158482 sWalker.pParse = pParse;
158547 pExpr = sqlite3ExprAnd(pParse, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0));
158551 if( pParse->nErr==0 ) sqlite3WalkExpr(&sWalker, pExpr);
158593 Parse *pParse = pWInfo->pParse; /* Parse context */
158594 Vdbe *v = pParse->pVdbe; /* Vdbe to generate code within */
158602 && DbMaskAllZero(sqlite3ParseToplevel(pParse)->writeMask)
158606 u32 *ai = (u32*)sqlite3DbMallocZero(pParse->db, sizeof(u32)*(pTab->nCol+1));
158631 static void codeExprOrVector(Parse *pParse, Expr *p, int iReg, int nReg){
158636 Vdbe *v = pParse->pVdbe;
158639 iSelect = sqlite3CodeSubselect(pParse, p);
158650 sqlite3ExprCode(pParse, pList->a[i].pExpr, iReg+i);
158654 assert( nReg==1 || pParse->nErr );
158655 sqlite3ExprCode(pParse, p, iReg);
158703 Parse *pParse, /* Parsing context */
158725 regRowid = sqlite3GetTempReg(pParse);
158726 regRowid = codeEqualityTerm(pParse, pTerm, pLevel, 0, 0, regRowid);
158727 sqlite3VdbeAddOp2(pParse->pVdbe, OP_MustBeInt, regRowid, addrNxt);
158728 VdbeCoverage(pParse->pVdbe);
158729 sqlite3VdbeAddOp4Int(pParse->pVdbe, OP_Filter, pLevel->regFilter,
158731 VdbeCoverage(pParse->pVdbe);
158739 r1 = codeAllEqualityTerms(pParse,pLevel,0,0,&zStartAff);
158740 codeApplyAffinity(pParse, r1, nEq, zStartAff);
158741 sqlite3DbFree(pParse->db, zStartAff);
158742 sqlite3VdbeAddOp4Int(pParse->pVdbe, OP_Filter, pLevel->regFilter,
158744 VdbeCoverage(pParse->pVdbe);
158777 Parse *pParse, /* Parsing context */
158802 db = pParse->db;
158837 addrBrk = pLevel->addrBrk = pLevel->addrNxt = sqlite3VdbeMakeLabel(pParse);
158838 addrCont = pLevel->addrCont = sqlite3VdbeMakeLabel(pParse);
158848 pLevel->iLeftJoin = ++pParse->nMem;
158880 iReg = sqlite3GetTempRange(pParse, nConstraint+2);
158888 int iTab = pParse->nTab++;
158889 int iCache = ++pParse->nMem;
158890 sqlite3CodeRhsOfIN(pParse, pTerm->pExpr, iTab);
158893 codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, iTarget);
158898 codeExprOrVector(pParse, pRight, iTarget, 1);
158959 pCompare = sqlite3PExpr(pParse, TK_EQ, 0, 0);
158976 pParse, pCompare, pLevel->addrCont, SQLITE_JUMPIFNULL
158990 ** sqlite3ReleaseTempRange(pParse, iReg, nConstraint+2);
159008 iReleaseReg = ++pParse->nMem;
159009 iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, 0, bRev, iReleaseReg);
159010 if( iRowidReg!=iReleaseReg ) sqlite3ReleaseTempReg(pParse, iReleaseReg);
159018 filterPullDown(pParse, pWInfo, iLevel, addrNxt, notReady);
159068 r1 = rTemp = sqlite3GetTempReg(pParse);
159069 codeExprOrVector(pParse, pX->pRight, r1, 1);
159080 r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &rTemp);
159090 sqlite3ReleaseTempReg(pParse, rTemp);
159103 memEndValue = ++pParse->nMem;
159104 codeExprOrVector(pParse, pX->pRight, memEndValue, 1);
159122 iRowidReg = ++pParse->nMem;
159222 pLevel->iLikeRepCntr = (u32)++pParse->nMem;
159259 pLevel->regBignull = regBignull = ++pParse->nMem;
159263 pLevel->addrBignull = sqlite3VdbeMakeLabel(pParse);
159287 regBase = codeAllEqualityTerms(pParse,pLevel,bRev,nExtraReg,&zStartAff);
159306 codeExprOrVector(pParse, pRight, regBase+nEq, nBtm);
159335 codeApplyAffinity(pParse, regBase, nConstraint - bSeekPastNull, zStartAff);
159349 filterPullDown(pParse, pWInfo, iLevel, addrNxt, notReady);
159408 codeExprOrVector(pParse, pRight, regBase+nEq, nTop);
159418 codeApplyAffinity(pParse, regBase+nEq, nTop, zEndAff);
159420 assert( pParse->db->mallocFailed );
159490 iRowidReg = sqlite3GetTempRange(pParse, pPk->nKeyCol);
159586 int iCovCur = pParse->nTab++; /* Cursor used for index scans (if any) */
159588 int regReturn = ++pParse->nMem; /* Register used with OP_Gosub */
159591 int iLoopBody = sqlite3VdbeMakeLabel(pParse);/* Start of loop body */
159642 regRowset = ++pParse->nMem;
159646 regRowset = pParse->nTab++;
159648 sqlite3VdbeSetP4KeyInfo(pParse, pPk);
159650 regRowid = ++pParse->nMem;
159696 pAndExpr = sqlite3ExprAnd(pParse, pAndExpr, pExpr);
159704 pAndExpr = sqlite3PExpr(pParse, TK_AND|0x10000, 0, pAndExpr);
159712 ExplainQueryPlan((pParse, 1, "MULTI-INDEX OR"));
159733 ExplainQueryPlan((pParse, 1, "INDEX %d", ii+1));
159735 pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0, 0,
159737 assert( pSubWInfo || pParse->nErr );
159741 pParse, pOrTab, &pSubWInfo->a[0], 0
159764 r = sqlite3GetTempRange(pParse, nPk);
159793 sqlite3ReleaseTempRange(pParse, r, nPk);
159840 ExplainQueryPlanPop(pParse);
159845 ExplainQueryPlanPop(pParse);
159987 sqlite3ExprIfFalse(pParse, pE, addrCont, SQLITE_JUMPIFNULL);
160036 sqlite3ExprIfFalse(pParse, &sEAlt, addrCont, SQLITE_JUMPIFNULL);
160057 r = sqlite3GetTempRange(pParse, 2);
160064 r = sqlite3GetTempRange(pParse, nPk+1);
160078 sqlite3ReleaseTempRange(pParse, r, nPk+1);
160103 assert( pParse->withinRJSubrtn < 255 );
160104 pParse->withinRJSubrtn++;
160122 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
160150 Parse *pParse = pWInfo->pParse;
160151 Vdbe *v = pParse->pVdbe;
160162 ExplainQueryPlan((pParse, 1, "RIGHT-JOIN %s", pTabItem->pTab->zName));
160194 pSubWhere = sqlite3ExprAnd(pParse, pSubWhere,
160195 sqlite3ExprDup(pParse->db, pTerm->pExpr, 0));
160202 assert( pParse->withinRJSubrtn < 100 );
160203 pParse->withinRJSubrtn++;
160204 pSubWInfo = sqlite3WhereBegin(pParse, &sFrom, pSubWhere, 0, 0, 0,
160208 int r = ++pParse->nMem;
160220 pParse->nMem += nPk - 1;
160234 sqlite3ExprDelete(pParse->db, pSubWhere);
160235 ExplainQueryPlanPop(pParse);
160236 assert( pParse->withinRJSubrtn>0 );
160237 pParse->withinRJSubrtn--;
160307 sqlite3 *db = pWC->pWInfo->pParse->db;
160352 static u16 exprCommute(Parse *pParse, Expr *pExpr){
160355 || sqlite3BinaryCompareCollSeq(pParse, pExpr->pLeft, pExpr->pRight) !=
160356 sqlite3BinaryCompareCollSeq(pParse, pExpr->pRight, pExpr->pLeft)
160414 Parse *pParse, /* Parsing and code generating context */
160426 sqlite3 *db = pParse->db; /* Database connection */
160444 Vdbe *pReprepare = pParse->pReprepare;
160450 sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
160537 Vdbe *v = pParse->pVdbe;
160547 int r1 = sqlite3GetTempReg(pParse);
160548 sqlite3ExprCodeTarget(pParse, pRight, r1);
160550 sqlite3ReleaseTempReg(pParse, r1);
160783 db = pWC->pWInfo->pParse->db;
160886 Parse *pParse = pWInfo->pParse; /* Parser context */
160887 sqlite3 *db = pParse->db; /* Database connection */
161078 && sqlite3ExprCompare(pParse, pOrTerm->pExpr->pLeft, pLeft, -1)
161115 pList = sqlite3ExprListAppend(pWInfo->pParse, pList, pDup);
161120 pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0);
161154 static int termIsEquivalence(Parse *pParse, Expr *pExpr){
161157 if( !OptimizationEnabled(pParse->db, SQLITE_Transitive) ) return 0;
161167 pColl = sqlite3ExprCompareCollSeq(pParse, pExpr);
161169 return sqlite3ExprCollSeqMatch(pParse, pExpr->pLeft, pExpr->pRight);
161315 Parse *pParse = pWInfo->pParse; /* Parsing context */
161316 sqlite3 *db = pParse->db; /* Database connection */
161334 if( sqlite3ExprCheckIN(pParse, pExpr) ) return;
161369 sqlite3ErrorMsg(pParse, "ON clause references tables to its right");
161380 sqlite3ErrorMsg(pParse, "ON clause references tables to its right");
161433 if( termIsEquivalence(pParse, pDup) ){
161441 pNew->wtFlags |= exprCommute(pParse, pDup);
161490 pNewExpr = sqlite3PExpr(pParse, ops[i],
161529 pNewExpr = sqlite3PExpr(pParse, TK_GT,
161566 && isLikeOrGlob(pParse, pExpr, &pStr1, &isComplete, &noCase)
161588 if( noCase && !pParse->db->mallocFailed ){
161616 pNewExpr1 = sqlite3PExpr(pParse, TK_GE,
161617 sqlite3ExprAddCollateString(pParse,pNewExpr1,zCollSeqName),
161623 pNewExpr2 = sqlite3PExpr(pParse, TK_LT,
161624 sqlite3ExprAddCollateString(pParse,pNewExpr2,zCollSeqName),
161660 Expr *pLeft = sqlite3ExprForVectorField(pParse, pExpr->pLeft, i, nLeft);
161661 Expr *pRight = sqlite3ExprForVectorField(pParse, pExpr->pRight, i, nLeft);
161663 pNew = sqlite3PExpr(pParse, pExpr->op, pLeft, pRight);
161724 pNewExpr = sqlite3PExpr(pParse, TK_MATCH,
161809 Parse *pParse = pWC->pWInfo->pParse;
161810 sqlite3 *db = pParse->db;
161819 pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal);
161824 pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal);
161930 sqlite3 *db = pWC->pWInfo->pParse->db;
162070 Parse *pParse, /* Parsing context */
162089 sqlite3ErrorMsg(pParse, "too many arguments on %s() - max %d",
162093 pColRef = sqlite3ExprAlloc(pParse->db, TK_COLUMN, 0, 0);
162100 pRhs = sqlite3PExpr(pParse, TK_UPLUS,
162101 sqlite3ExprDup(pParse->db, pArgs->a[j].pExpr, 0), 0);
162102 pTerm = sqlite3PExpr(pParse, TK_EQ, pColRef, pRhs);
162151 Parse *pParse; /* The parsing context */
162377 pBlock = sqlite3DbMallocRawNN(pWInfo->pParse->db, nByte+sizeof(*pBlock));
162432 Parse *pParse,
162452 CollSeq *pRet = sqlite3ExprCompareCollSeq(pParse, pX);
162509 Parse *pParse = pWC->pWInfo->pParse;
162513 zCollName = indexInAffinityOk(pParse, pTerm, pScan->idxaff);
162521 pColl = sqlite3ExprCompareCollSeq(pParse, pX);
162696 Parse *pParse, /* Parse context */
162712 CollSeq *pColl = sqlite3ExprNNCollSeq(pParse, pList->a[i].pExpr);
162749 Parse *pParse, /* Parsing context */
162795 if( findIndexCol(pParse, pDistinct, iBase, pIdx, i)<0 ) break;
162829 Parse *pParse, /* Parsing context */
162835 Vdbe *v = pParse->pVdbe;
162838 if( pParse->db->mallocFailed ) return;
162843 if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
162854 if( pParse->db->flags & SQLITE_VdbeAddopTrace ){
163008 Parse *pParse,
163013 if( IS_STMT_SCANSTATUS(pParse->db) && pParse->explain!=2 ){
163018 sqlite3_str *pStr = sqlite3_str_new(pParse->db);
163032 sqlite3OomFault(pParse->db);
163035 pParse, 0, "%s)%s", zText, (bPartial ? " WHERE <expr>" : "")
163051 Parse *pParse, /* The parsing context */
163087 v = pParse->pVdbe;
163108 pPartial = sqlite3ExprAnd(pParse, pPartial,
163109 sqlite3ExprDup(pParse->db, pExpr, 0));
163126 if( whereLoopResize(pParse->db, pLoop, nKeyCol+1) ){
163134 assert( nKeyCol>0 || pParse->db->mallocFailed );
163163 pIdx = sqlite3AllocateIndexObject(pParse->db, nKeyCol+1, 0, &zNotUsed);
163183 pColl = sqlite3ExprCompareCollSeq(pParse, pX);
163184 assert( pColl!=0 || pParse->nErr>0 ); /* TH3 collate01.800 */
163223 explainAutomaticIndex(pParse, pIdx, pPartial!=0, &addrExp);
163225 pLevel->iIdxCur = pParse->nTab++;
163227 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
163229 if( OptimizationEnabled(pParse->db, SQLITE_BloomFilter) && useBloomFilter ){
163230 sqlite3WhereExplainBloomFilter(pParse, pWC->pWInfo, pLevel);
163231 pLevel->regFilter = ++pParse->nMem;
163248 iContinue = sqlite3VdbeMakeLabel(pParse);
163249 sqlite3ExprIfFalse(pParse, pPartial, iContinue, SQLITE_JUMPIFNULL);
163252 regRecord = sqlite3GetTempReg(pParse);
163254 pParse, pIdx, pLevel->iTabCur, regRecord, 0, 0, 0, 0
163266 testcase( pParse->db->mallocFailed );
163268 translateColumnToCopy(pParse, addrTop, pLevel->iTabCur,
163277 sqlite3ReleaseTempReg(pParse, regRecord);
163284 sqlite3ExprDelete(pParse->db, pPartial);
163319 Parse *pParse = pWInfo->pParse; /* Parsing context */
163320 Vdbe *v = pParse->pVdbe; /* VDBE under construction */
163326 saved_pIdxEpr = pParse->pIdxEpr;
163327 saved_pIdxPartExpr = pParse->pIdxPartExpr;
163328 pParse->pIdxEpr = 0;
163329 pParse->pIdxPartExpr = 0;
163343 sqlite3WhereExplainBloomFilter(pParse, pWInfo, pLevel);
163344 addrCont = sqlite3VdbeMakeLabel(pParse);
163346 pLevel->regFilter = ++pParse->nMem;
163377 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL);
163381 int r1 = sqlite3GetTempReg(pParse);
163384 sqlite3ReleaseTempReg(pParse, r1);
163388 int r1 = sqlite3GetTempRange(pParse, n);
163392 sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iCur, jj, r1+jj);
163395 sqlite3ReleaseTempRange(pParse, r1, n);
163402 if( OptimizationDisabled(pParse->db, SQLITE_BloomPulldown) ) break;
163423 pParse->pIdxEpr = saved_pIdxEpr;
163424 pParse->pIdxPartExpr = saved_pIdxPartExpr;
163443 Parse *pParse = pWInfo->pParse;
163546 pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo)
163551 sqlite3ErrorMsg(pParse, "out of memory");
163562 pHidden->pParse = pParse;
163636 assert( pHidden->pParse!=0 );
163637 assert( pHidden->pParse->db==db );
163651 ** If an error occurs, pParse is populated with an error message and an
163661 static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
163662 sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab;
163666 pParse->db->nSchemaLock++;
163668 pParse->db->nSchemaLock--;
163673 sqlite3OomFault(pParse->db);
163675 sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc));
163677 sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg);
163681 sqlite3VtabUsesAllSchemas(pParse);
163704 Parse *pParse, /* Database connection */
163721 UNUSED_PARAMETER( pParse );
163817 if( pParse->db->mallocFailed==0 ){
163824 || pParse->db->mallocFailed
163834 || pParse->db->mallocFailed );
163843 || pParse->db->mallocFailed || CORRUPT_DB );
163848 || pParse->db->mallocFailed || CORRUPT_DB );
163966 Parse *pParse, /* Parsing & code generating context */
163974 sqlite3 *db = pParse->db;
163985 pColl = sqlite3LocateCollSeq(pParse, p->azColl[nEq]);
163987 rc = sqlite3Stat4ValueFromExpr(pParse, pLower->pExpr->pRight, aff, &p1);
163991 rc = sqlite3Stat4ValueFromExpr(pParse, pUpper->pExpr->pRight, aff, &p2);
164078 Parse *pParse, /* Parsing & code generating context */
164093 && OptimizationEnabled(pParse->db, SQLITE_Stat4)
164136 whereKeyStats(pParse, p, pRec, 0, a);
164154 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nBtm, nEq, &n);
164159 iLwrIdx = whereKeyStats(pParse, p, pRec, 0, a);
164171 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, nTop, nEq, &n);
164176 iUprIdx = whereKeyStats(pParse, p, pRec, 1, a);
164205 rc = whereRangeSkipScanEst(pParse, pLower, pUpper, pLoop, &bDone);
164210 UNUSED_PARAMETER(pParse);
164214 assert( pUpper==0 || (pUpper->wtFlags & TERM_VNULL)==0 || pParse->nErr>0 );
164257 ** in the pParse structure.
164260 Parse *pParse, /* Parsing & code generating context */
164291 rc = sqlite3Stat4ProbeSetValue(pParse, p, &pRec, pExpr, 1, nEq-1, &bOk);
164297 whereKeyStats(pParse, p, pRec, 0, a);
164321 ** in the pParse structure.
164324 Parse *pParse, /* Parsing & code generating context */
164340 rc = whereEqualScanEst(pParse, pBuilder, pList->a[i].pExpr, &nEst);
164804 sqlite3 *db = pWInfo->pParse->db;
164961 sqlite3ProgressCheck(pWC->pWInfo->pParse);
165029 Parse *pParse, /* Parsing context */
165073 pColl = sqlite3BinaryCompareCollSeq(pParse, pLhs, pRhs);
165109 Parse *pParse = pWInfo->pParse; /* Parsing context */
165110 sqlite3 *db = pParse->db; /* Database connection malloc context */
165129 assert( db->mallocFailed==0 || pParse->nErr>0 );
165130 if( pParse->nErr ){
165131 return pParse->rc;
165302 pParse, pSrc->iCursor, pProbe, saved_nEq, pTerm
165344 whereRangeScanEst(pParse, pBuilder, pBtm, pTop, pNew);
165369 rc = whereEqualScanEst(pParse, pBuilder, pExpr->pRight, &nOut);
165371 rc = whereInScanEst(pParse, pBuilder, pExpr->x.pList, &nOut);
165465 sqlite3ProgressCheck(pParse);
165577 Parse *pParse;
165580 pParse = pWC->pWInfo->pParse;
165585 if( pParse->db->flags & SQLITE_EnableQPSG ) pParse = 0;
165591 && sqlite3ExprImpliesExpr(pParse, pExpr, pWhere, iTab)
165785 Parse *pParse, /* Parse context */
165796 wherePartIdxExpr(pParse, pIdx, pPart->pRight, pMask, iIdxCur, pItem);
165807 if( !sqlite3IsBinary(sqlite3ExprCompareCollSeq(pParse, pPart)) ) return;
165812 sqlite3 *db = pParse->db;
165821 p->pIENext = pParse->pIdxPartExpr;
165823 pParse->pIdxPartExpr = p;
165825 void *pArg = (void*)&pParse->pIdxPartExpr;
165826 sqlite3ParserAddCleanup(pParse, whereIndexedExprCleanup, pArg);
165937 && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0
166054 pWInfo->pParse, pProbe, pProbe->pPartIdxWhere, &m, 0, 0
166099 && OptimizationEnabled(pWInfo->pParse->db, SQLITE_CoverIdxScan)
166232 Parse *pParse = pBuilder->pWInfo->pParse;
166267 rc = vtabBestIndex(pParse, pSrc->pTab, pIdxInfo);
166296 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
166364 sqlite3ErrorMsg(pParse,"%s.xBestIndex malfunction",pSrc->pTab->zName);
166422 pC = sqlite3ExprCompareCollSeq(pHidden->pParse, pX);
166468 pH->pParse->db, pTerm->pExpr->pRight, ENC(pH->pParse->db),
166502 SQLITE_PRIVATE void sqlite3VtabUsesAllSchemas(Parse *pParse){
166503 int nDb = pParse->db->nDb;
166506 sqlite3CodeVerifySchema(pParse, i);
166508 if( DbMaskNonZero(pParse->writeMask) ){
166510 sqlite3BeginWriteOperation(pParse, 0, i);
166547 Parse *pParse; /* The parsing context */
166560 pParse = pWInfo->pParse;
166572 if( whereLoopResize(pParse->db, pNew, nConstraint) ){
166573 freeIndexInfo(pParse->db, p);
166661 freeIndexInfo(pParse->db, p);
166806 sqlite3 *db = pWInfo->pParse->db;
166925 sqlite3 *db = pWInfo->pParse->db; /* Database connection */
167011 Parse *pParse = pWInfo->pParse;
167012 CollSeq *pColl1 = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[i].pExpr);
167013 CollSeq *pColl2 = sqlite3ExprCompareCollSeq(pParse, pTerm->pExpr);
167143 pColl = sqlite3ExprNNCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr);
167344 Parse *pParse; /* Parsing context */
167362 pParse = pWInfo->pParse;
167370 nRowEst, pParse->nQueryLoop));
167386 pSpace = sqlite3StackAllocRawNN(pParse->db, nSpace);
167413 aFrom[0].nRow = MIN(pParse->nQueryLoop, 48); assert( 48==sqlite3LogEst(28) );
167636 sqlite3ErrorMsg(pParse, "no query solution");
167637 sqlite3StackFreeNN(pParse->db, pSpace);
167721 sqlite3StackFreeNN(pParse->db, pSpace);
168003 assert( OptimizationEnabled(pWInfo->pParse->db, SQLITE_OmitNoopJoin) );
168087 assert( OptimizationEnabled(pWInfo->pParse->db, SQLITE_BloomFilter) );
168140 db = pWalker->pParse->db;
168158 static int sqlite3ExprCanReturnSubtype(Parse *pParse, Expr *pExpr){
168161 w.pParse = pParse;
168179 Parse *pParse, /* Add IndexedExpr entries to pParse->pIdxEpr */
168200 if( pExpr->op==TK_FUNCTION && sqlite3ExprCanReturnSubtype(pParse,pExpr) ){
168206 p = sqlite3DbMallocRaw(pParse->db, sizeof(IndexedExpr));
168208 p->pIENext = pParse->pIdxEpr;
168211 sqlite3DebugPrintf("New pParse->pIdxEpr term {%d,%d}\n", iIdxCur, i);
168215 p->pExpr = sqlite3ExprDup(pParse->db, pExpr, 0);
168220 if( sqlite3IndexAffinityStr(pParse->db, pIdx) ){
168226 pParse->pIdxEpr = p;
168228 void *pArg = (void*)&pParse->pIdxEpr;
168229 sqlite3ParserAddCleanup(pParse, whereIndexedExprCleanup, pArg);
168345 Parse *pParse, /* The parser context */
168358 Vdbe *v = pParse->pVdbe; /* The virtual database engine */
168379 db = pParse->db;
168395 sqlite3ErrorMsg(pParse, "at most %d tables in a join", BMS);
168423 pWInfo->pParse = pParse;
168432 pWInfo->iBreak = pWInfo->iContinue = sqlite3VdbeMakeLabel(pParse);
168435 pWInfo->savedNQueryLoop = pParse->nQueryLoop;
168473 ExplainQueryPlan((pParse, 0, "SCAN CONSTANT ROW"));
168493 sqlite3WhereTabFuncArgs(pParse, &pTabList->a[ii], &pWInfo->sWC);
168512 if( pParse->nErr ) goto whereBeginError;
168552 sqlite3ExprIfFalse(pParse, pX, pWInfo->iBreak, SQLITE_JUMPIFNULL);
168563 }else if( isDistinctRedundant(pParse, pTabList, &pWInfo->sWC, pResultSet) ){
168646 if( pParse->nErr ){
168714 pWInfo->pParse->nQueryLoop += pWInfo->nRowOut;
168789 sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op);
168820 sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName);
168849 iIndexCur = pParse->nTab++;
168851 whereAddIndexedExpr(pParse, pIx, iIndexCur, pTabItem);
168855 pParse, pIx, pIx->pPartIdxWhere, 0, iIndexCur, pTabItem
168865 sqlite3VdbeSetP4KeyInfo(pParse, pIx);
168893 if( iDb>=0 ) sqlite3CodeVerifySchema(pParse, iDb);
168898 pRJ->iMatch = pParse->nTab++;
168899 pRJ->regBloom = ++pParse->nMem;
168901 pRJ->regReturn = ++pParse->nMem;
168907 pInfo = sqlite3KeyInfoAlloc(pParse->db, 1, 0);
168916 sqlite3VdbeSetP4KeyInfo(pParse, pPk);
168937 if( pParse->nErr ) goto whereBeginError;
168954 constructAutomaticIndex(pParse, &pWInfo->sWC, notReady, pLevel);
168962 pParse, pTabList, pLevel, wctrlFlags
168965 notReady = sqlite3WhereCodeOneLoopStart(pParse,v,pWInfo,ii,pLevel,notReady);
168980 pParse->nQueryLoop = pWInfo->savedNQueryLoop;
169016 Parse *pParse = pWInfo->pParse;
169017 Vdbe *v = pParse->pVdbe;
169022 sqlite3 *db = pParse->db;
169056 int r1 = pParse->nMem+1;
169061 pParse->nMem += n+1;
169094 || pParse->db->mallocFailed );
169175 sqlite3VdbeSetP4KeyInfo(pParse, pIx);
169214 testcase( pParse->db->mallocFailed );
169216 translateColumnToCopy(pParse, pLevel->addrBody, pLevel->iTabCur,
169246 IndexedExpr *p = pParse->pIdxEpr;
169251 sqlite3DebugPrintf("Disable pParse->pIdxEpr term {%d,%d}\n",
169311 sqlite3ErrorMsg(pParse, "internal query planner error");
169312 pParse->rc = SQLITE_INTERNAL;
169340 pParse->nQueryLoop = pWInfo->savedNQueryLoop;
169342 pParse->withinRJSubrtn -= nRJ;
169978 static Window *windowFind(Parse *pParse, Window *pList, const char *zName){
169984 sqlite3ErrorMsg(pParse, "no such window: %s", zName);
170000 ** in pParse.
170007 Parse *pParse,
170013 Window *p = windowFind(pParse, pList, pWin->zName);
170015 pWin->pPartition = sqlite3ExprListDup(pParse->db, p->pPartition, 0);
170016 pWin->pOrderBy = sqlite3ExprListDup(pParse->db, p->pOrderBy, 0);
170017 pWin->pStart = sqlite3ExprDup(pParse->db, p->pStart, 0);
170018 pWin->pEnd = sqlite3ExprDup(pParse->db, p->pEnd, 0);
170024 sqlite3WindowChain(pParse, pWin, pList);
170030 sqlite3ErrorMsg(pParse,
170035 sqlite3 *db = pParse->db;
170037 sqlite3ErrorMsg(pParse,
170097 Parse *pParse = pWalker->pParse;
170139 if( pParse->db->mallocFailed ) return WRC_Abort;
170150 Expr *pDup = sqlite3ExprDup(pParse->db, pExpr, 0);
170152 p->pSub = sqlite3ExprListAppend(pParse, p->pSub, pDup);
170158 sqlite3ExprDelete(pParse->db, pExpr);
170168 if( pParse->db->mallocFailed ) return WRC_Abort;
170206 Parse *pParse,
170225 sWalker.pParse = pParse;
170240 Parse *pParse, /* Parsing context */
170249 sqlite3 *db = pParse->db;
170265 pList = sqlite3ExprListAppend(pParse, pList, pDup);
170292 sqlite3ErrorMsg(pWalker->pParse,
170305 SQLITE_PRIVATE int sqlite3WindowRewrite(Parse *pParse, Select *p){
170312 Vdbe *v = sqlite3GetVdbe(pParse);
170313 sqlite3 *db = pParse->db;
170333 sqlite3AggInfoPersistWalkerInit(&w, pParse);
170351 pSort = exprListAppendList(pParse, 0, pMWin->pPartition, 1);
170352 pSort = exprListAppendList(pParse, pSort, pMWin->pOrderBy, 1);
170366 pMWin->iEphCsr = pParse->nTab++;
170367 pParse->nTab += 3;
170369 selectWindowRewriteEList(pParse, pMWin, pSrc, p->pEList, pTab, &pSublist);
170370 selectWindowRewriteEList(pParse, pMWin, pSrc, p->pOrderBy, pTab, &pSublist);
170376 pSublist = exprListAppendList(pParse, pSublist, pMWin->pPartition, 0);
170377 pSublist = exprListAppendList(pParse, pSublist, pMWin->pOrderBy, 0);
170389 selectWindowRewriteEList(pParse, pMWin, pSrc, pArgs, pTab, &pSublist);
170394 pSublist = exprListAppendList(pParse, pSublist, pArgs, 0);
170398 pSublist = sqlite3ExprListAppend(pParse, pSublist, pFilter);
170400 pWin->regAccum = ++pParse->nMem;
170401 pWin->regResult = ++pParse->nMem;
170412 pSublist = sqlite3ExprListAppend(pParse, 0,
170418 pParse, pSublist, pSrc, pWhere, pGroupBy, pHaving, pSort, 0, 0
170420 TREETRACE(0x40,pParse,pSub,
170423 p->pSrc = sqlite3SrcListAppend(pParse, 0, 0, 0);
170431 sqlite3SrcListAssignCursors(pParse, p->pSrc);
170433 pTab2 = sqlite3ResultSetOfSelect(pParse, pSub, SQLITE_AFF_NONE);
170437 ** pParse->nErr will be set, so if SQLITE_NOMEM is set, we will get
170459 sqlite3ParserAddCleanup(pParse, sqlite3DbFree, pTab);
170462 assert( rc==SQLITE_OK || pParse->nErr!=0 );
170513 static Expr *sqlite3WindowOffsetExpr(Parse *pParse, Expr *pExpr){
170515 if( IN_RENAME_OBJECT ) sqlite3RenameExprUnmap(pParse, pExpr);
170516 sqlite3ExprDelete(pParse->db, pExpr);
170517 pExpr = sqlite3ExprAlloc(pParse->db, TK_NULL, 0, 0);
170526 Parse *pParse, /* Parsing context */
170568 sqlite3ErrorMsg(pParse, "unsupported frame specification");
170572 pWin = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
170577 if( eExclude==0 && OptimizationDisabled(pParse->db, SQLITE_WindowFunc) ){
170582 pWin->pEnd = sqlite3WindowOffsetExpr(pParse, pEnd);
170583 pWin->pStart = sqlite3WindowOffsetExpr(pParse, pStart);
170587 sqlite3ExprDelete(pParse->db, pEnd);
170588 sqlite3ExprDelete(pParse->db, pStart);
170598 Parse *pParse,
170608 pWin->zBase = sqlite3DbStrNDup(pParse->db, pBase->z, pBase->n);
170611 sqlite3ExprListDelete(pParse->db, pPartition);
170612 sqlite3ExprListDelete(pParse->db, pOrderBy);
170622 ** leaves an error in pParse.
170624 SQLITE_PRIVATE void sqlite3WindowChain(Parse *pParse, Window *pWin, Window *pList){
170626 sqlite3 *db = pParse->db;
170627 Window *pExist = windowFind(pParse, pList, pWin->zBase);
170639 sqlite3ErrorMsg(pParse,
170658 SQLITE_PRIVATE void sqlite3WindowAttach(Parse *pParse, Expr *p, Window *pWin){
170667 sqlite3ErrorMsg(pParse,
170672 sqlite3WindowDelete(pParse->db, pWin);
170705 const Parse *pParse,
170716 if( sqlite3ExprCompare(pParse, p1->pStart, p2->pStart, -1) ) return 1;
170717 if( sqlite3ExprCompare(pParse, p1->pEnd, p2->pEnd, -1) ) return 1;
170725 if( (res = sqlite3ExprCompare(pParse, p1->pFilter, p2->pFilter, -1)) ){
170738 SQLITE_PRIVATE void sqlite3WindowCodeInit(Parse *pParse, Select *pSelect){
170742 Vdbe *v = sqlite3GetVdbe(pParse);
170753 pMWin->regPart = pParse->nMem+1;
170754 pParse->nMem += nExpr;
170758 pMWin->regOne = ++pParse->nMem;
170762 pMWin->regStartRowid = ++pParse->nMem;
170763 pMWin->regEndRowid = ++pParse->nMem;
170764 pMWin->csrApp = pParse->nTab++;
170785 pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pList, 0, 0);
170786 pWin->csrApp = pParse->nTab++;
170787 pWin->regApp = pParse->nMem+1;
170788 pParse->nMem += 3;
170800 pWin->regApp = pParse->nMem+1;
170801 pWin->csrApp = pParse->nTab++;
170802 pParse->nMem += 2;
170806 pWin->csrApp = pParse->nTab++;
170825 static void windowCheckValue(Parse *pParse, int reg, int eCond){
170834 Vdbe *v = sqlite3GetVdbe(pParse);
170835 int regZero = sqlite3GetTempReg(pParse);
170839 int regString = sqlite3GetTempReg(pParse);
170862 sqlite3MayAbort(pParse);
170865 sqlite3ReleaseTempReg(pParse, regZero);
170946 Parse *pParse; /* Parse context */
170972 Vdbe *v = sqlite3GetVdbe(p->pParse);
171008 Parse *pParse = p->pParse;
171009 Vdbe *v = sqlite3GetVdbe(pParse);
171021 assert( pWin==pMWin || sqlite3WindowCompare(pParse,pWin,pMWin,0)!=1 );
171063 regTmp = sqlite3GetTempReg(pParse);
171067 sqlite3ReleaseTempReg(pParse, regTmp);
171076 regArg = sqlite3GetTempRange(pParse, nArg);
171077 sqlite3ExprCodeExprList(pParse, pWin->pOwner->x.pList, regArg, 0, 0);
171090 pColl = sqlite3ExprNNCollSeq(pParse, pWin->pOwner->x.pList->a[0].pExpr);
171098 sqlite3ReleaseTempRange(pParse, regArg, nArg);
171119 Parse *pParse = p->pParse;
171121 Vdbe *v = sqlite3GetVdbe(pParse);
171159 Parse *pParse = p->pParse;
171180 lblNext = sqlite3VdbeMakeLabel(pParse);
171181 lblBrk = sqlite3VdbeMakeLabel(pParse);
171183 regCRowid = sqlite3GetTempReg(pParse);
171184 regRowid = sqlite3GetTempReg(pParse);
171186 regCPeer = sqlite3GetTempRange(pParse, nPeer);
171187 regPeer = sqlite3GetTempRange(pParse, nPeer);
171213 pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pMWin->pOrderBy, 0, 0);
171239 sqlite3ReleaseTempReg(pParse, regRowid);
171240 sqlite3ReleaseTempReg(pParse, regCRowid);
171242 sqlite3ReleaseTempRange(pParse, regPeer, nPeer);
171243 sqlite3ReleaseTempRange(pParse, regCPeer, nPeer);
171270 Parse *pParse = p->pParse;
171280 int lbl = sqlite3VdbeMakeLabel(pParse);
171281 int tmpReg = sqlite3GetTempReg(pParse);
171286 windowCheckValue(pParse, tmpReg, 2);
171297 sqlite3ReleaseTempReg(pParse, tmpReg);
171302 int lbl = sqlite3VdbeMakeLabel(pParse);
171303 int tmpReg = sqlite3GetTempReg(pParse);
171317 int tmpReg2 = sqlite3GetTempReg(pParse);
171320 sqlite3ReleaseTempReg(pParse, tmpReg2);
171327 sqlite3ReleaseTempReg(pParse, tmpReg);
171340 static int windowInitAccum(Parse *pParse, Window *pMWin){
171341 Vdbe *v = sqlite3GetVdbe(pParse);
171363 regArg = pParse->nMem+1;
171364 pParse->nMem += nArg;
171399 Parse *pParse,
171405 Vdbe *v = sqlite3GetVdbe(pParse);
171408 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pOrderBy, 0, 0);
171452 Parse *pParse = p->pParse;
171453 Vdbe *v = sqlite3GetVdbe(pParse);
171455 int reg1 = sqlite3GetTempReg(pParse); /* Reg. for csr1.peerVal+regVal */
171456 int reg2 = sqlite3GetTempReg(pParse); /* Reg. for csr2.peerVal */
171457 int regString = ++pParse->nMem; /* Reg. for constant value '' */
171460 int addrDone = sqlite3VdbeMakeLabel(pParse); /* Address past OP_Ge */
171554 pColl = sqlite3ExprNNCollSeq(pParse, pOrderBy->a[0].pExpr);
171564 sqlite3ReleaseTempReg(pParse, reg1);
171565 sqlite3ReleaseTempReg(pParse, reg2);
171583 Parse *pParse = p->pParse;
171590 int lblDone = sqlite3VdbeMakeLabel(pParse);
171639 int regRowid1 = sqlite3GetTempReg(pParse);
171640 int regRowid2 = sqlite3GetTempReg(pParse);
171651 sqlite3ReleaseTempReg(pParse, regRowid1);
171652 sqlite3ReleaseTempReg(pParse, regRowid2);
171706 int regTmp = (nReg ? sqlite3GetTempRange(pParse, nReg) : 0);
171708 windowIfNewPeer(pParse, pMWin->pOrderBy, regTmp, reg, addrContinue);
171709 sqlite3ReleaseTempRange(pParse, regTmp, nReg);
171780 static int windowExprGtZero(Parse *pParse, Expr *pExpr){
171782 sqlite3 *db = pParse->db;
172128 Parse *pParse, /* Parse context */
172136 Vdbe *v = sqlite3GetVdbe(pParse);
172166 lblWhereEnd = sqlite3VdbeMakeLabel(pParse);
172170 s.pParse = pParse;
172189 && windowExprGtZero(pParse, pMWin->pStart)
172198 && windowExprGtZero(pParse, pMWin->pEnd)
172215 regNew = pParse->nMem+1;
172216 pParse->nMem += nInput;
172217 regRecord = ++pParse->nMem;
172218 s.regRowid = ++pParse->nMem;
172224 regStart = ++pParse->nMem;
172227 regEnd = ++pParse->nMem;
172237 regPeer = pParse->nMem+1; pParse->nMem += nPeer;
172238 s.start.reg = pParse->nMem+1; pParse->nMem += nPeer;
172239 s.current.reg = pParse->nMem+1; pParse->nMem += nPeer;
172240 s.end.reg = pParse->nMem+1; pParse->nMem += nPeer;
172261 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pPart, 0, 0);
172263 regFlushPart = ++pParse->nMem;
172280 s.regArg = windowInitAccum(pParse, pMWin);
172283 sqlite3ExprCode(pParse, pMWin->pStart, regStart);
172284 windowCheckValue(pParse, regStart, 0 + (pMWin->eFrmType==TK_RANGE?3:0));
172287 sqlite3ExprCode(pParse, pMWin->pEnd, regEnd);
172288 windowCheckValue(pParse, regEnd, 1 + (pMWin->eFrmType==TK_RANGE?3:0));
172326 windowIfNewPeer(pParse, pOrderBy, regNewPeer, regPeer, lblWhereEnd);
172332 int lbl = sqlite3VdbeMakeLabel(pParse);
172359 lbl = sqlite3VdbeMakeLabel(pParse);
172532 static void disableLookaside(Parse *pParse){
172533 sqlite3 *db = pParse->db;
172534 pParse->disableLookaside++;
172545 Parse *pParse,
172550 sqlite3ErrorMsg(pParse, "syntax error near \"ORDER BY\"");
172552 sqlite3ErrorMsg(pParse, "syntax error near \"LIMIT\"");
172554 sqlite3ExprListDelete(pParse->db, pOrderBy);
172555 sqlite3ExprDelete(pParse->db, pLimit);
172565 static void parserDoubleLinkSelect(Parse *pParse, Select *p){
172578 sqlite3ErrorMsg(pParse,"%s clause should come after %s not before",
172585 && (mxSelect = pParse->db->aLimit[SQLITE_LIMIT_COMPOUND_SELECT])>0
172588 sqlite3ErrorMsg(pParse, "too many terms in compound SELECT");
172596 static Select *attachWithToSelect(Parse *pParse, Select *pSelect, With *pWith){
172599 parserDoubleLinkSelect(pParse, pSelect);
172601 sqlite3WithDelete(pParse->db, pWith);
172616 static Expr *tokenExpr(Parse *pParse, int op, Token t){
172617 Expr *p = sqlite3DbMallocRawNN(pParse->db, sizeof(Expr)+t.n+1);
172635 p->w.iOfst = (int)(t.z - pParse->zTail);
172643 return (Expr*)sqlite3RenameTokenMap(pParse, (void*)p, &t);
172652 static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
172653 sqlite3 *db = pParse->db;
172667 Parse *pParse,
172673 ExprList *p = sqlite3ExprListAppend(pParse, pPrior, 0);
172675 && pParse->db->init.busy==0
172677 sqlite3ErrorMsg(pParse, "syntax error after column name \"%.*s\"",
172680 sqlite3ExprListSetName(pParse, p, pIdToken, 1);
172977 #define sqlite3ParserCTX_SDECL Parse *pParse;
172978 #define sqlite3ParserCTX_PDECL ,Parse *pParse
172979 #define sqlite3ParserCTX_PARAM ,pParse
172980 #define sqlite3ParserCTX_FETCH Parse *pParse=yypParser->pParse;
172981 #define sqlite3ParserCTX_STORE yypParser->pParse=pParse;
174858 sqlite3SelectDelete(pParse->db, (yypminor->yy555));
174873 sqlite3ExprDelete(pParse->db, (yypminor->yy454));
174890 sqlite3ExprListDelete(pParse->db, (yypminor->yy14));
174899 sqlite3SrcListDelete(pParse->db, (yypminor->yy203));
174904 sqlite3WithDelete(pParse->db, (yypminor->yy59));
174910 sqlite3WindowListDelete(pParse->db, (yypminor->yy211));
174916 sqlite3IdListDelete(pParse->db, (yypminor->yy132));
174925 sqlite3WindowDelete(pParse->db, (yypminor->yy211));
174931 sqlite3DeleteTriggerStep(pParse->db, (yypminor->yy427));
174936 sqlite3IdListDelete(pParse->db, (yypminor->yy286).b);
174943 sqlite3ExprDelete(pParse->db, (yypminor->yy509).pExpr);
175179 sqlite3OomFault(pParse->db);
176110 { if( pParse->pReprepare==0 ) pParse->explain = 1; }
176113 { if( pParse->pReprepare==0 ) pParse->explain = 2; }
176116 { sqlite3FinishCoding(pParse); }
176119 {sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy144);}
176132 {sqlite3EndTransaction(pParse,yymsp[-1].major);}
176136 sqlite3Savepoint(pParse, SAVEPOINT_BEGIN, &yymsp[0].minor.yy0);
176141 sqlite3Savepoint(pParse, SAVEPOINT_RELEASE, &yymsp[0].minor.yy0);
176146 sqlite3Savepoint(pParse, SAVEPOINT_ROLLBACK, &yymsp[0].minor.yy0);
176151 sqlite3StartTable(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,yymsp[-4].minor.yy144,0,0,yymsp[-2].minor.yy144);
176155 {disableLookaside(pParse);}
176171 {yymsp[0].minor.yy144 = pParse->db->init.busy==0;}
176175 sqlite3EndTable(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,yymsp[0].minor.yy391,0);
176180 sqlite3EndTable(pParse,0,0,0,yymsp[0].minor.yy555);
176181 sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555);
176197 sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
176207 sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
176213 {sqlite3AddColumn(pParse,yymsp[-1].minor.yy0,yymsp[0].minor.yy0);}
176247 {pParse->constraintName = yymsp[0].minor.yy0;}
176250 {sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,yymsp[-1].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
176253 {sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy454,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
176256 {sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy454,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);}
176260 Expr *p = sqlite3PExpr(pParse, TK_UMINUS, yymsp[0].minor.yy454, 0);
176261 sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,&yymsp[-1].minor.yy0.z[yymsp[-1].minor.yy0.n]);
176266 Expr *p = tokenExpr(pParse, TK_STRING, yymsp[0].minor.yy0);
176271 sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n);
176275 {sqlite3AddNotNull(pParse, yymsp[0].minor.yy144);}
176278 {sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy144,yymsp[0].minor.yy144,yymsp[-2].minor.yy144);}
176281 {sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy144,0,0,0,0,
176285 {sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy454,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy0.z);}
176288 {sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy0,yymsp[-1].minor.yy14,yymsp[0].minor.yy144);}
176291 {sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy144);}
176294 {sqlite3AddCollateType(pParse, &yymsp[0].minor.yy0);}
176297 {sqlite3AddGenerated(pParse,yymsp[-1].minor.yy454,0);}
176300 {sqlite3AddGenerated(pParse,yymsp[-2].minor.yy454,&yymsp[0].minor.yy0);}
176357 {pParse->constraintName.n = 0;}
176360 {sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy14,yymsp[0].minor.yy144,yymsp[-2].minor.yy144,0);}
176363 {sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy14,yymsp[0].minor.yy144,0,0,0,0,
176367 {sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy454,yymsp[-3].minor.yy0.z,yymsp[-1].minor.yy0.z);}
176371 sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy14, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[-1].minor.yy144);
176372 sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy144);
176391 sqlite3DropTable(pParse, yymsp[0].minor.yy203, 0, yymsp[-1].minor.yy144);
176396 sqlite3CreateView(pParse, &yymsp[-8].minor.yy0, &yymsp[-4].minor.yy0, &yymsp[-3].minor.yy0, yymsp[-2].minor.yy14, yymsp[0].minor.yy555, yymsp[-7].minor.yy144, yymsp[-5].minor.yy144);
176401 sqlite3DropTable(pParse, yymsp[0].minor.yy203, 1, yymsp[-1].minor.yy144);
176407 sqlite3Select(pParse, yymsp[0].minor.yy555, &dest);
176408 sqlite3SelectDelete(pParse->db, yymsp[0].minor.yy555);
176412 {yymsp[-2].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);}
176415 {yymsp[-3].minor.yy555 = attachWithToSelect(pParse,yymsp[0].minor.yy555,yymsp[-1].minor.yy59);}
176421 parserDoubleLinkSelect(pParse, p);
176433 parserDoubleLinkSelect(pParse, pRhs);
176434 pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0);
176435 pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0);
176442 if( yymsp[-1].minor.yy144!=TK_ALL ) pParse->hasCompound = 1;
176444 sqlite3SelectDelete(pParse->db, pLhs);
176458 yymsp[-8].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-6].minor.yy14,yymsp[-5].minor.yy203,yymsp[-4].minor.yy454,yymsp[-3].minor.yy14,yymsp[-2].minor.yy454,yymsp[-1].minor.yy14,yymsp[-7].minor.yy144,yymsp[0].minor.yy454);
176463 yymsp[-9].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-7].minor.yy14,yymsp[-6].minor.yy203,yymsp[-5].minor.yy454,yymsp[-4].minor.yy14,yymsp[-3].minor.yy454,yymsp[-1].minor.yy14,yymsp[-8].minor.yy144,yymsp[0].minor.yy454);
176467 sqlite3WindowListDelete(pParse->db, yymsp[-2].minor.yy211);
176473 yymsp[-3].minor.yy555 = sqlite3SelectNew(pParse,yymsp[-1].minor.yy14,0,0,0,0,0,SF_Values,0);
176478 sqlite3MultiValuesEnd(pParse, yymsp[0].minor.yy555);
176484 yymsp[-4].minor.yy555 = sqlite3MultiValues(pParse, yymsp[-4].minor.yy555, yymsp[-1].minor.yy14);
176503 yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[-2].minor.yy454);
176504 if( yymsp[0].minor.yy0.n>0 ) sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[0].minor.yy0, 1);
176505 sqlite3ExprListSetSpan(pParse,yymsp[-4].minor.yy14,yymsp[-3].minor.yy168,yymsp[-1].minor.yy168);
176510 Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0);
176511 sqlite3ExprSetErrorOffset(p, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
176512 yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-2].minor.yy14, p);
176518 pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0);
176519 sqlite3ExprSetErrorOffset(pRight, (int)(yymsp[0].minor.yy0.z - pParse->zTail));
176520 pLeft = tokenExpr(pParse, TK_ID, yymsp[-2].minor.yy0);
176521 pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight);
176522 yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, pDot);
176538 sqlite3SrcListShiftJoinType(pParse,yymsp[-1].minor.yy203);
176548 yymsp[-4].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-4].minor.yy203,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
176553 yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,0,&yymsp[0].minor.yy269);
176554 sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-1].minor.yy0);
176559 yymsp[-7].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-7].minor.yy203,&yymsp[-6].minor.yy0,&yymsp[-5].minor.yy0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
176560 sqlite3SrcListFuncArgs(pParse, yymsp[-7].minor.yy203, yymsp[-3].minor.yy14);
176565 yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,yymsp[-3].minor.yy555,&yymsp[0].minor.yy269);
176573 yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,0,&yymsp[0].minor.yy269);
176592 sqlite3SrcListDelete(pParse->db, yymsp[-3].minor.yy203);
176595 sqlite3SrcListShiftJoinType(pParse,yymsp[-3].minor.yy203);
176596 pSubquery = sqlite3SelectNew(pParse,0,yymsp[-3].minor.yy203,0,0,0,0,SF_NestedFrom,0);
176597 yymsp[-5].minor.yy203 = sqlite3SrcListAppendFromTerm(pParse,yymsp[-5].minor.yy203,0,0,&yymsp[-1].minor.yy0,pSubquery,&yymsp[0].minor.yy269);
176607 yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0);
176608 if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
176614 yylhsminor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0);
176615 if( IN_RENAME_OBJECT && yylhsminor.yy203 ) sqlite3RenameTokenMap(pParse, yylhsminor.yy203->a[0].zName, &yymsp[0].minor.yy0);
176620 {yymsp[0].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[0].minor.yy0,0); /*A-overwrites-X*/}
176623 {yymsp[-2].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); /*A-overwrites-X*/}
176627 yymsp[-4].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,&yymsp[-2].minor.yy0); /*A-overwrites-X*/
176628 if( yymsp[-4].minor.yy203 ) yymsp[-4].minor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
176633 yymsp[-2].minor.yy203 = sqlite3SrcListAppend(pParse,0,&yymsp[-2].minor.yy0,0); /*A-overwrites-X*/
176634 if( yymsp[-2].minor.yy203 ) yymsp[-2].minor.yy203->a[0].zAlias = sqlite3NameFromToken(pParse->db, &yymsp[0].minor.yy0);
176641 {yymsp[-1].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); /*X-overwrites-A*/}
176644 {yymsp[-2].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0,0); /*X-overwrites-A*/}
176647 {yymsp[-3].minor.yy144 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);/*X-overwrites-A*/}
176670 yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14,yymsp[-2].minor.yy454);
176676 yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[-2].minor.yy454); /*A-overwrites-Y*/
176713 {yymsp[-1].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,0);}
176716 {yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
176719 {yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_LIMIT,yymsp[0].minor.yy454,yymsp[-2].minor.yy454);}
176723 sqlite3SrcListIndexedBy(pParse, yymsp[-2].minor.yy203, &yymsp[-1].minor.yy0);
176724 sqlite3DeleteFrom(pParse,yymsp[-2].minor.yy203,yymsp[0].minor.yy454,0,0);
176728 {sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-1].minor.yy454 = 0;}
176731 {sqlite3AddReturning(pParse,yymsp[0].minor.yy14); yymsp[-3].minor.yy454 = yymsp[-2].minor.yy454;}
176735 sqlite3SrcListIndexedBy(pParse, yymsp[-5].minor.yy203, &yymsp[-4].minor.yy0);
176736 sqlite3ExprListCheckLength(pParse,yymsp[-2].minor.yy14,"set list");
176742 pSubquery = sqlite3SelectNew(pParse,0,pFromClause,0,0,0,0,SF_NestedFrom,0);
176745 pFromClause = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&as,pSubquery,0);
176747 yymsp[-5].minor.yy203 = sqlite3SrcListAppendList(pParse, yymsp[-5].minor.yy203, pFromClause);
176749 sqlite3Update(pParse,yymsp[-5].minor.yy203,yymsp[-2].minor.yy14,yymsp[0].minor.yy454,yymsp[-6].minor.yy144,0,0,0);
176754 yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse, yymsp[-4].minor.yy14, yymsp[0].minor.yy454);
176755 sqlite3ExprListSetName(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, 1);
176760 yymsp[-6].minor.yy14 = sqlite3ExprListAppendVector(pParse, yymsp[-6].minor.yy14, yymsp[-3].minor.yy132, yymsp[0].minor.yy454);
176765 yylhsminor.yy14 = sqlite3ExprListAppend(pParse, 0, yymsp[0].minor.yy454);
176766 sqlite3ExprListSetName(pParse, yylhsminor.yy14, &yymsp[-2].minor.yy0, 1);
176772 yymsp[-4].minor.yy14 = sqlite3ExprListAppendVector(pParse, 0, yymsp[-3].minor.yy132, yymsp[0].minor.yy454);
176777 sqlite3Insert(pParse, yymsp[-3].minor.yy203, yymsp[-1].minor.yy555, yymsp[-2].minor.yy132, yymsp[-5].minor.yy144, yymsp[0].minor.yy122);
176782 sqlite3Insert(pParse, yymsp[-4].minor.yy203, 0, yymsp[-3].minor.yy132, yymsp[-6].minor.yy144, 0);
176789 { yymsp[-1].minor.yy122 = 0; sqlite3AddReturning(pParse,yymsp[0].minor.yy14); }
176792 { yymsp[-11].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-8].minor.yy14,yymsp[-6].minor.yy454,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,yymsp[0].minor.yy122);}
176795 { yymsp[-8].minor.yy122 = sqlite3UpsertNew(pParse->db,yymsp[-5].minor.yy14,yymsp[-3].minor.yy454,0,0,yymsp[0].minor.yy122); }
176798 { yymsp[-4].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,0,0,0); }
176801 { yymsp[-7].minor.yy122 = sqlite3UpsertNew(pParse->db,0,0,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454,0);}
176804 {sqlite3AddReturning(pParse,yymsp[0].minor.yy14);}
176813 {yymsp[-2].minor.yy132 = sqlite3IdListAppend(pParse,yymsp[-2].minor.yy132,&yymsp[0].minor.yy0);}
176816 {yymsp[0].minor.yy132 = sqlite3IdListAppend(pParse,0,&yymsp[0].minor.yy0); /*A-overwrites-Y*/}
176822 {yymsp[0].minor.yy454=tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0); /*A-overwrites-X*/}
176826 Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0);
176827 Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0);
176828 yylhsminor.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp2);
176834 Expr *temp1 = tokenExpr(pParse,TK_ID,yymsp[-4].minor.yy0);
176835 Expr *temp2 = tokenExpr(pParse,TK_ID,yymsp[-2].minor.yy0);
176836 Expr *temp3 = tokenExpr(pParse,TK_ID,yymsp[0].minor.yy0);
176837 Expr *temp4 = sqlite3PExpr(pParse, TK_DOT, temp2, temp3);
176839 sqlite3RenameTokenRemap(pParse, 0, temp1);
176841 yylhsminor.yy454 = sqlite3PExpr(pParse, TK_DOT, temp1, temp4);
176847 {yymsp[0].minor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0); /*A-overwrites-X*/}
176851 yylhsminor.yy454 = sqlite3ExprAlloc(pParse->db, TK_INTEGER, &yymsp[0].minor.yy0, 1);
176852 if( yylhsminor.yy454 ) yylhsminor.yy454->w.iOfst = (int)(yymsp[0].minor.yy0.z - pParse->zTail);
176860 yymsp[0].minor.yy454 = tokenExpr(pParse, TK_VARIABLE, yymsp[0].minor.yy0);
176861 sqlite3ExprAssignVarNumber(pParse, yymsp[0].minor.yy454, n);
176868 if( pParse->nested==0 ){
176869 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &t);
176872 yymsp[0].minor.yy454 = sqlite3PExpr(pParse, TK_REGISTER, 0, 0);
176880 yymsp[-2].minor.yy454 = sqlite3ExprAddCollateToken(pParse, yymsp[-2].minor.yy454, &yymsp[0].minor.yy0, 1);
176885 yymsp[-5].minor.yy454 = sqlite3ExprAlloc(pParse->db, TK_CAST, &yymsp[-1].minor.yy0, 1);
176886 sqlite3ExprAttachSubtrees(pParse->db, yymsp[-5].minor.yy454, yymsp[-3].minor.yy454, 0);
176891 yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0, yymsp[-2].minor.yy144);
176897 yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-4].minor.yy14, &yymsp[-7].minor.yy0, yymsp[-5].minor.yy144);
176898 sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-1].minor.yy14);
176904 yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-3].minor.yy0, 0);
176910 yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-2].minor.yy14, &yymsp[-5].minor.yy0, yymsp[-3].minor.yy144);
176911 sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
176917 yylhsminor.yy454 = sqlite3ExprFunction(pParse, yymsp[-5].minor.yy14, &yymsp[-8].minor.yy0, yymsp[-6].minor.yy144);
176918 sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
176919 sqlite3ExprAddFunctionOrderBy(pParse, yylhsminor.yy454, yymsp[-2].minor.yy14);
176925 yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[-4].minor.yy0, 0);
176926 sqlite3WindowAttach(pParse, yylhsminor.yy454, yymsp[0].minor.yy211);
176932 yylhsminor.yy454 = sqlite3ExprFunction(pParse, 0, &yymsp[0].minor.yy0, 0);
176938 ExprList *pList = sqlite3ExprListAppend(pParse, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454);
176939 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_VECTOR, 0, 0);
176946 sqlite3ExprListDelete(pParse->db, pList);
176951 {yymsp[-2].minor.yy454=sqlite3ExprAnd(pParse,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
176960 {yymsp[-2].minor.yy454=sqlite3PExpr(pParse,yymsp[-1].major,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);}
176970 pList = sqlite3ExprListAppend(pParse,0, yymsp[0].minor.yy454);
176971 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-2].minor.yy454);
176972 yymsp[-2].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
176973 if( bNot ) yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-2].minor.yy454, 0);
176982 pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
176983 pList = sqlite3ExprListAppend(pParse,pList, yymsp[-4].minor.yy454);
176984 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
176985 yymsp[-4].minor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-3].minor.yy0, 0);
176986 if( bNot ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
176991 {yymsp[-1].minor.yy454 = sqlite3PExpr(pParse,yymsp[0].major,yymsp[-1].minor.yy454,0);}
176994 {yymsp[-2].minor.yy454 = sqlite3PExpr(pParse,TK_NOTNULL,yymsp[-2].minor.yy454,0);}
176998 yymsp[-2].minor.yy454 = sqlite3PExpr(pParse,TK_IS,yymsp[-2].minor.yy454,yymsp[0].minor.yy454);
176999 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-2].minor.yy454, TK_ISNULL);
177004 yymsp[-3].minor.yy454 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-3].minor.yy454,yymsp[0].minor.yy454);
177005 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-3].minor.yy454, TK_NOTNULL);
177010 yymsp[-5].minor.yy454 = sqlite3PExpr(pParse,TK_IS,yymsp[-5].minor.yy454,yymsp[0].minor.yy454);
177011 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-5].minor.yy454, TK_ISNULL);
177016 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse,TK_ISNOT,yymsp[-4].minor.yy454,yymsp[0].minor.yy454);
177017 binaryToUnaryIfNull(pParse, yymsp[0].minor.yy454, yymsp[-4].minor.yy454, TK_NOTNULL);
177022 {yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, yymsp[-1].major, yymsp[0].minor.yy454, 0);/*A-overwrites-B*/}
177034 yymsp[-1].minor.yy454 = sqlite3PExpr(pParse, op, p, 0);
177041 ExprList *pList = sqlite3ExprListAppend(pParse, 0, yymsp[-2].minor.yy454);
177042 pList = sqlite3ExprListAppend(pParse, pList, yymsp[0].minor.yy454);
177043 yylhsminor.yy454 = sqlite3ExprFunction(pParse, pList, &yymsp[-1].minor.yy0, 0);
177053 ExprList *pList = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
177054 pList = sqlite3ExprListAppend(pParse,pList, yymsp[0].minor.yy454);
177055 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_BETWEEN, yymsp[-4].minor.yy454, 0);
177059 sqlite3ExprListDelete(pParse->db, pList);
177061 if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
177075 sqlite3ExprUnmapAndDelete(pParse, yymsp[-4].minor.yy454);
177076 yymsp[-4].minor.yy454 = sqlite3Expr(pParse->db, TK_STRING, yymsp[-3].minor.yy144 ? "true" : "false");
177080 if( yymsp[-1].minor.yy14->nExpr==1 && sqlite3ExprIsConstant(pParse,pRHS) && yymsp[-4].minor.yy454->op!=TK_VECTOR ){
177082 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
177083 pRHS = sqlite3PExpr(pParse, TK_UPLUS, pRHS, 0);
177084 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_EQ, yymsp[-4].minor.yy454, pRHS);
177086 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
177087 sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pRHS->x.pSelect);
177089 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
177091 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
177093 sqlite3ExprListDelete(pParse->db, yymsp[-1].minor.yy14);
177096 Select *pSelectRHS = sqlite3ExprListToValues(pParse, nExpr, yymsp[-1].minor.yy14);
177098 parserDoubleLinkSelect(pParse, pSelectRHS);
177099 sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelectRHS);
177103 sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
177106 if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
177112 yymsp[-2].minor.yy454 = sqlite3PExpr(pParse, TK_SELECT, 0, 0);
177113 sqlite3PExprAddSelect(pParse, yymsp[-2].minor.yy454, yymsp[-1].minor.yy555);
177118 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
177119 sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, yymsp[-1].minor.yy555);
177120 if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
177125 SrcList *pSrc = sqlite3SrcListAppend(pParse, 0,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy0);
177126 Select *pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0);
177127 if( yymsp[0].minor.yy14 ) sqlite3SrcListFuncArgs(pParse, pSelect ? pSrc : 0, yymsp[0].minor.yy14);
177128 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_IN, yymsp[-4].minor.yy454, 0);
177129 sqlite3PExprAddSelect(pParse, yymsp[-4].minor.yy454, pSelect);
177130 if( yymsp[-3].minor.yy144 ) yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_NOT, yymsp[-4].minor.yy454, 0);
177136 p = yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_EXISTS, 0, 0);
177137 sqlite3PExprAddSelect(pParse, p, yymsp[-1].minor.yy555);
177142 yymsp[-4].minor.yy454 = sqlite3PExpr(pParse, TK_CASE, yymsp[-3].minor.yy454, 0);
177144 yymsp[-4].minor.yy454->x.pList = yymsp[-1].minor.yy454 ? sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[-1].minor.yy454) : yymsp[-2].minor.yy14;
177145 sqlite3ExprSetHeightAndFlags(pParse, yymsp[-4].minor.yy454);
177147 sqlite3ExprListDelete(pParse->db, yymsp[-2].minor.yy14);
177148 sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454);
177154 yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[-2].minor.yy454);
177155 yymsp[-4].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-4].minor.yy14, yymsp[0].minor.yy454);
177160 yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,0, yymsp[-2].minor.yy454);
177161 yymsp[-3].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-3].minor.yy14, yymsp[0].minor.yy454);
177165 {yymsp[-2].minor.yy14 = sqlite3ExprListAppend(pParse,yymsp[-2].minor.yy14,yymsp[0].minor.yy454);}
177168 {yymsp[0].minor.yy14 = sqlite3ExprListAppend(pParse,0,yymsp[0].minor.yy454); /*A-overwrites-Y*/}
177176 sqlite3CreateIndex(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0,
177177 sqlite3SrcListAppend(pParse,0,&yymsp[-4].minor.yy0,0), yymsp[-2].minor.yy14, yymsp[-10].minor.yy144,
177179 if( IN_RENAME_OBJECT && pParse->pNewIndex ){
177180 sqlite3RenameTokenMap(pParse, pParse->pNewIndex->zName, &yymsp[-4].minor.yy0);
177193 yymsp[-4].minor.yy14 = parserAddExprIdListTerm(pParse, yymsp[-4].minor.yy14, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144);
177198 yymsp[-2].minor.yy14 = parserAddExprIdListTerm(pParse, 0, &yymsp[-2].minor.yy0, yymsp[-1].minor.yy144, yymsp[0].minor.yy144); /*A-overwrites-Y*/
177202 {sqlite3DropIndex(pParse, yymsp[0].minor.yy203, yymsp[-1].minor.yy144);}
177205 {sqlite3Vacuum(pParse,0,yymsp[0].minor.yy454);}
177208 {sqlite3Vacuum(pParse,&yymsp[-1].minor.yy0,yymsp[0].minor.yy454);}
177211 {sqlite3Pragma(pParse,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy0,0,0);}
177214 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,0);}
177217 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,0);}
177220 {sqlite3Pragma(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0,1);}
177223 {sqlite3Pragma(pParse,&yymsp[-4].minor.yy0,&yymsp[-3].minor.yy0,&yymsp[-1].minor.yy0,1);}
177230 sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy427, &all);
177235 sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy0, &yymsp[-6].minor.yy0, yymsp[-5].minor.yy144, yymsp[-4].minor.yy286.a, yymsp[-4].minor.yy286.b, yymsp[-2].minor.yy203, yymsp[0].minor.yy454, yymsp[-10].minor.yy144, yymsp[-8].minor.yy144);
177279 sqlite3ErrorMsg(pParse,
177286 sqlite3ErrorMsg(pParse,
177293 sqlite3ErrorMsg(pParse,
177299 {yylhsminor.yy427 = sqlite3TriggerUpdateStep(pParse, &yymsp[-6].minor.yy0, yymsp[-2].minor.yy203, yymsp[-3].minor.yy14, yymsp[-1].minor.yy454, yymsp[-7].minor.yy144, yymsp[-8].minor.yy0.z, yymsp[0].minor.yy168);}
177304 yylhsminor.yy427 = sqlite3TriggerInsertStep(pParse,&yymsp[-4].minor.yy0,yymsp[-3].minor.yy132,yymsp[-2].minor.yy555,yymsp[-6].minor.yy144,yymsp[-1].minor.yy122,yymsp[-7].minor.yy168,yymsp[0].minor.yy168);/*yylhsminor.yy427-overwrites-yymsp[-6].minor.yy144*/
177309 {yylhsminor.yy427 = sqlite3TriggerDeleteStep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy454, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy168);}
177313 {yylhsminor.yy427 = sqlite3TriggerSelectStep(pParse->db, yymsp[-1].minor.yy555, yymsp[-2].minor.yy168, yymsp[0].minor.yy168); /*yylhsminor.yy427-overwrites-yymsp[-1].minor.yy555*/}
177318 yymsp[-3].minor.yy454 = sqlite3PExpr(pParse, TK_RAISE, 0, 0);
177326 yymsp[-5].minor.yy454 = sqlite3ExprAlloc(pParse->db, TK_RAISE, &yymsp[-1].minor.yy0, 1);
177340 sqlite3DropTrigger(pParse,yymsp[0].minor.yy203,yymsp[-1].minor.yy144);
177345 sqlite3Attach(pParse, yymsp[-3].minor.yy454, yymsp[-1].minor.yy454, yymsp[0].minor.yy454);
177350 sqlite3Detach(pParse, yymsp[0].minor.yy454);
177354 {sqlite3Reindex(pParse, 0, 0);}
177357 {sqlite3Reindex(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
177360 {sqlite3Analyze(pParse, 0, 0);}
177363 {sqlite3Analyze(pParse, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy0);}
177367 sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy203,&yymsp[0].minor.yy0);
177372 yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
177373 sqlite3AlterFinishAddColumn(pParse, &yymsp[-1].minor.yy0);
177378 sqlite3AlterDropColumn(pParse, yymsp[-3].minor.yy203, &yymsp[0].minor.yy0);
177383 disableLookaside(pParse);
177384 sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy203);
177389 sqlite3AlterRenameColumn(pParse, yymsp[-5].minor.yy203, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
177393 {sqlite3VtabFinishParse(pParse,0);}
177396 {sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);}
177400 sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy0, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0, yymsp[-4].minor.yy144);
177404 {sqlite3VtabArgInit(pParse);}
177409 {sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);}
177413 { sqlite3WithPush(pParse, yymsp[0].minor.yy59, 1); }
177426 yymsp[-5].minor.yy67 = sqlite3CteNew(pParse, &yymsp[-5].minor.yy0, yymsp[-4].minor.yy14, yymsp[-1].minor.yy555, yymsp[-3].minor.yy462); /*A-overwrites-X*/
177430 {pParse->bHasWith = 1;}
177434 yymsp[0].minor.yy59 = sqlite3WithAdd(pParse, 0, yymsp[0].minor.yy67); /*A-overwrites-X*/
177439 yymsp[-2].minor.yy59 = sqlite3WithAdd(pParse, yymsp[-2].minor.yy59, yymsp[0].minor.yy67);
177445 sqlite3WindowChain(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy211);
177454 yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor.yy0.n);
177462 yymsp[-4].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, 0);
177467 yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, yymsp[-2].minor.yy14, yymsp[-1].minor.yy14, &yymsp[-5].minor.yy0);
177473 yymsp[-3].minor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, 0);
177478 yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, yymsp[-1].minor.yy14, &yymsp[-4].minor.yy0);
177484 yylhsminor.yy211 = sqlite3WindowAssemble(pParse, yymsp[0].minor.yy211, 0, 0, &yymsp[-1].minor.yy0);
177490 yymsp[1].minor.yy211 = sqlite3WindowAlloc(pParse, 0, TK_UNBOUNDED, 0, TK_CURRENT, 0, 0);
177495 yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-2].minor.yy144, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, TK_CURRENT, 0, yymsp[0].minor.yy462);
177501 yylhsminor.yy211 = sqlite3WindowAlloc(pParse, yymsp[-5].minor.yy144, yymsp[-3].minor.yy509.eType, yymsp[-3].minor.yy509.pExpr, yymsp[-1].minor.yy509.eType, yymsp[-1].minor.yy509.pExpr, yymsp[0].minor.yy462);
177541 sqlite3ExprDelete(pParse->db, yymsp[-1].minor.yy454);
177555 yylhsminor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
177560 sqlite3ExprDelete(pParse->db, yymsp[0].minor.yy454);
177573 yymsp[-1].minor.yy211 = (Window*)sqlite3DbMallocZero(pParse->db, sizeof(Window));
177575 yymsp[-1].minor.yy211->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
177584 yylhsminor.yy454=tokenExpr(pParse,yymsp[0].major,yymsp[0].minor.yy0);
177585 sqlite3DequoteNumber(pParse, yylhsminor.yy454);
177717 sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN);
177719 sqlite3ErrorMsg(pParse, "incomplete input");
179076 SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql){
179082 sqlite3 *db = pParse->db; /* The database connection */
179095 pParse->rc = SQLITE_OK;
179096 pParse->zTail = zSql;
179107 sqlite3ParserInit(pEngine, pParse);
179109 pEngine = sqlite3ParserAlloc(sqlite3Malloc, pParse);
179115 assert( pParse->pNewTable==0 );
179116 assert( pParse->pNewTrigger==0 );
179117 assert( pParse->nVar==0 );
179118 assert( pParse->pVList==0 );
179119 pParentParse = db->pParse;
179120 db->pParse = pParse;
179125 pParse->rc = SQLITE_TOOBIG;
179126 pParse->nErr++;
179142 pParse->rc = SQLITE_INTERRUPT;
179143 pParse->nErr++;
179176 sqlite3ErrorMsg(pParse, "unrecognized token: \"%T\"", &x);
179180 pParse->sLastToken.z = zSql;
179181 pParse->sLastToken.n = n;
179182 sqlite3Parser(pEngine, tokenType, pParse->sLastToken);
179185 assert( db->mallocFailed==0 || pParse->rc!=SQLITE_OK || startedWithOom );
179186 if( pParse->rc!=SQLITE_OK ) break;
179202 pParse->rc = SQLITE_NOMEM_BKPT;
179204 if( pParse->zErrMsg || (pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE) ){
179205 if( pParse->zErrMsg==0 ){
179206 pParse->zErrMsg = sqlite3MPrintf(db, "%s", sqlite3ErrStr(pParse->rc));
179208 sqlite3_log(pParse->rc, "%s in \"%s\"", pParse->zErrMsg, pParse->zTail);
179211 pParse->zTail = zSql;
179213 sqlite3_free(pParse->apVtabLock);
179216 if( pParse->pNewTable && !IN_SPECIAL_PARSE ){
179217 /* If the pParse->declareVtab flag is set, do not delete any table
179218 ** structure built up in pParse->pNewTable. The calling code (see vtab.c)
179221 sqlite3DeleteTable(db, pParse->pNewTable);
179223 if( pParse->pNewTrigger && !IN_RENAME_OBJECT ){
179224 sqlite3DeleteTrigger(db, pParse->pNewTrigger);
179226 if( pParse->pVList ) sqlite3DbNNFreeNN(db, pParse->pVList);
179227 db->pParse = pParentParse;
179228 assert( nErr==0 || pParse->rc!=SQLITE_OK );
193068 ** and other information (column names etc.) in pParse. Create an Fts3Expr
193079 ParseContext *pParse, /* fts3 query parse context */
193085 sqlite3_tokenizer *pTokenizer = pParse->pTokenizer;
193099 rc = sqlite3Fts3OpenTokenizer(pTokenizer, pParse->iLangid, z, i, &pCursor);
193129 pParse->isNot = 1;
193131 }else if( pParse->bFts4 && iStart>0 && z[iStart-1]=='^' ){
193178 ParseContext *pParse, /* fts3 query parse context */
193182 sqlite3_tokenizer *pTokenizer = pParse->pTokenizer;
193213 pTokenizer, pParse->iLangid, zInput, nInput, &pCursor);
193256 p->pPhrase->iColumn = pParse->iDefaultCol;
193296 ParseContext *pParse, /* fts3 query parse context */
193321 pParse->isNot = 0;
193391 return getNextString(pParse, &zInput[1], ii-1, ppExpr);
193397 pParse->nNest++;
193399 if( pParse->nNest>1000 ) return SQLITE_ERROR;
193401 if( pParse->nNest>SQLITE_MAX_EXPR_DEPTH ) return SQLITE_ERROR;
193403 rc = fts3ExprParse(pParse, zInput+1, nInput-1, ppExpr, &nConsumed);
193407 pParse->nNest--;
193425 iCol = pParse->iDefaultCol;
193427 for(ii=0; ii<pParse->nCol; ii++){
193428 const char *zStr = pParse->azCol[ii];
193438 rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
193515 ParseContext *pParse, /* fts3 query parse context */
193532 rc = getNextNode(pParse, zIn, nIn, &p, &nByte);
193539 && p->eType==FTSQUERY_PHRASE && pParse->isNot
205235 JsonParse *pParse /* The parse object to be added to the cache */
205239 assert( pParse->zJson!=0 );
205240 assert( pParse->bJsonIsRCStr );
205241 assert( pParse->delta==0 );
205257 assert( pParse->nBlobAlloc>0 );
205258 pParse->eEdit = 0;
205259 pParse->nJPRef++;
205260 pParse->bReadOnly = 1;
205261 p->a[p->nUsed] = pParse;
205639 ** If pParse and ctx are both non-NULL, then the SQL string in p is
205640 ** loaded into the zJson field of the pParse object as a RCStr and the
205641 ** pParse is added to the cache.
205645 JsonParse *pParse, /* JSONB source or NULL */
205648 assert( (pParse!=0)==(ctx!=0) );
205658 if( pParse && pParse->bJsonIsRCStr==0 && pParse->nBlobAlloc>0 ){
205660 pParse->zJson = sqlite3RCStrRef(p->zBuf);
205661 pParse->nJson = p->nUsed;
205662 pParse->bJsonIsRCStr = 1;
205663 rc = jsonCacheInsert(ctx, pParse);
205692 static void jsonParseReset(JsonParse *pParse){
205693 assert( pParse->nJPRef<=1 );
205694 if( pParse->bJsonIsRCStr ){
205695 sqlite3RCStrUnref(pParse->zJson);
205696 pParse->zJson = 0;
205697 pParse->nJson = 0;
205698 pParse->bJsonIsRCStr = 0;
205700 if( pParse->nBlobAlloc ){
205701 sqlite3DbFree(pParse->db, pParse->aBlob);
205702 pParse->aBlob = 0;
205703 pParse->nBlob = 0;
205704 pParse->nBlobAlloc = 0;
205712 static void jsonParseFree(JsonParse *pParse){
205713 if( pParse ){
205714 if( pParse->nJPRef>1 ){
205715 pParse->nJPRef--;
205717 jsonParseReset(pParse);
205718 sqlite3DbFree(pParse->db, pParse);
205935 ** Expand pParse->aBlob so that it holds at least N bytes.
205939 static int jsonBlobExpand(JsonParse *pParse, u32 N){
205942 assert( N>pParse->nBlobAlloc );
205943 if( pParse->nBlobAlloc==0 ){
205946 t = pParse->nBlobAlloc*2;
205949 aNew = sqlite3DbRealloc(pParse->db, pParse->aBlob, t);
205950 if( aNew==0 ){ pParse->oom = 1; return 1; }
205951 pParse->aBlob = aNew;
205952 pParse->nBlobAlloc = t;
205957 ** If pParse->aBlob is not previously editable (because it is taken
205959 ** pParse->nBlobAlloc==0 and pParse->nBlob>0) then make it editable
205964 static int jsonBlobMakeEditable(JsonParse *pParse, u32 nExtra){
205967 assert( !pParse->bReadOnly );
205968 if( pParse->oom ) return 0;
205969 if( pParse->nBlobAlloc>0 ) return 1;
205970 aOld = pParse->aBlob;
205971 nSize = pParse->nBlob + nExtra;
205972 pParse->aBlob = 0;
205973 if( jsonBlobExpand(pParse, nSize) ){
205976 assert( pParse->nBlobAlloc >= pParse->nBlob + nExtra );
205977 memcpy(pParse->aBlob, aOld, pParse->nBlob);
205981 /* Expand pParse->aBlob and append one bytes.
205984 JsonParse *pParse,
205987 jsonBlobExpand(pParse, pParse->nBlob+1);
205988 if( pParse->oom==0 ){
205989 assert( pParse->nBlob+1<=pParse->nBlobAlloc );
205990 pParse->aBlob[pParse->nBlob++] = c;
205996 static void jsonBlobAppendOneByte(JsonParse *pParse, u8 c){
205997 if( pParse->nBlob >= pParse->nBlobAlloc ){
205998 jsonBlobExpandAndAppendOneByte(pParse, c);
206000 pParse->aBlob[pParse->nBlob++] = c;
206005 ** pParse->aBlob structure.
206009 JsonParse *pParse,
206014 if( jsonBlobExpand(pParse, pParse->nBlob+szPayload+9) ) return;
206015 jsonBlobAppendNode(pParse, eType, szPayload, aPayload);
206023 ** is also appended. If aPayload is NULL, the pParse->aBlob[] array
206025 ** payload, but the payload is not appended and pParse->nBlob is left
206029 JsonParse *pParse, /* The JsonParse object under construction */
206035 if( pParse->nBlob+szPayload+9 > pParse->nBlobAlloc ){
206036 jsonBlobExpandAndAppendNode(pParse,eType,szPayload,aPayload);
206039 assert( pParse->aBlob!=0 );
206040 a = &pParse->aBlob[pParse->nBlob];
206043 pParse->nBlob += 1;
206047 pParse->nBlob += 2;
206052 pParse->nBlob += 3;
206059 pParse->nBlob += 5;
206062 pParse->nBlob += szPayload;
206063 memcpy(&pParse->aBlob[pParse->nBlob-szPayload], aPayload, szPayload);
206070 JsonParse *pParse,
206079 if( pParse->oom ) return 0;
206080 a = &pParse->aBlob[i];
206102 u32 newSize = pParse->nBlob + delta;
206104 if( newSize>pParse->nBlobAlloc && jsonBlobExpand(pParse, newSize) ){
206105 return 0; /* OOM error. Error state recorded in pParse->oom. */
206107 a = &pParse->aBlob[i];
206108 memmove(&a[1+delta], &a[1], pParse->nBlob - (i+1));
206110 memmove(&a[1], &a[1-delta], pParse->nBlob - (i+1-delta));
206112 pParse->nBlob = newSize;
206146 ** Check a single element of the JSONB in pParse for validity.
206156 const JsonParse *pParse, /* Input JSONB. Only aBlob and nBlob are used */
206157 u32 i, /* Start of element as pParse->aBlob[i] */
206166 n = jsonbPayloadSize(pParse, i, &sz);
206169 z = pParse->aBlob;
206309 n = jsonbPayloadSize(pParse, j, &sz);
206312 sub = jsonbValidityCheck(pParse, j, j+n+sz, iDepth+1);
206326 n = jsonbPayloadSize(pParse, j, &sz);
206333 sub = jsonbValidityCheck(pParse, j, j+n+sz, iDepth+1);
206349 ** Translate a single element of JSON text at pParse->zJson[i] into
206351 ** pParse->aBlob[] beginning at pParse->nBlob. The size of
206352 ** pParse->aBlob[] is increased as necessary.
206360 ** -3 ']' seen \___ For these returns, pParse->iErr is set to
206364 static int jsonTranslateTextToBlob(JsonParse *pParse, u32 i){
206370 const char *z = pParse->zJson;
206375 iThis = pParse->nBlob;
206376 jsonBlobAppendNode(pParse, JSONB_OBJECT, pParse->nJson-i, 0);
206377 if( ++pParse->iDepth > JSON_MAX_DEPTH ){
206378 pParse->iErr = i;
206381 iStart = pParse->nBlob;
206383 u32 iBlob = pParse->nBlob;
206384 x = jsonTranslateTextToBlob(pParse, j);
206388 j = pParse->iErr;
206389 if( pParse->nBlob!=(u32)iStart ) pParse->hasNonstd = 1;
206403 assert( iBlob==pParse->nBlob );
206404 jsonBlobAppendNode(pParse, op, k-j, &z[j]);
206405 pParse->hasNonstd = 1;
206408 if( x!=-1 ) pParse->iErr = j;
206412 if( pParse->oom ) return -1;
206413 t = pParse->aBlob[iBlob] & 0x0f;
206415 pParse->iErr = j;
206430 x = jsonTranslateTextToBlob(pParse, j);
206432 if( x!=(-1) ) pParse->iErr = j;
206435 j = pParse->iErr+1;
206438 x = jsonTranslateTextToBlob(pParse, j);
206440 if( x!=(-1) ) pParse->iErr = j;
206457 x = jsonTranslateTextToBlob(pParse, j);
206459 j = pParse->iErr;
206463 j = pParse->iErr;
206467 pParse->iErr = j;
206470 jsonBlobChangePayloadSize(pParse, iThis, pParse->nBlob - iStart);
206471 pParse->iDepth--;
206476 iThis = pParse->nBlob;
206477 assert( i<=(u32)pParse->nJson );
206478 jsonBlobAppendNode(pParse, JSONB_ARRAY, pParse->nJson - i, 0);
206479 iStart = pParse->nBlob;
206480 if( pParse->oom ) return -1;
206481 if( ++pParse->iDepth > JSON_MAX_DEPTH ){
206482 pParse->iErr = i;
206486 x = jsonTranslateTextToBlob(pParse, j);
206489 j = pParse->iErr;
206490 if( pParse->nBlob!=iStart ) pParse->hasNonstd = 1;
206493 if( x!=(-1) ) pParse->iErr = j;
206510 x = jsonTranslateTextToBlob(pParse, j);
206512 j = pParse->iErr;
206516 j = pParse->iErr;
206520 pParse->iErr = j;
206523 jsonBlobChangePayloadSize(pParse, iThis, pParse->nBlob - iStart);
206524 pParse->iDepth--;
206530 pParse->hasNonstd = 1;
206564 pParse->hasNonstd = 1;
206568 pParse->hasNonstd = 1;
206570 pParse->iErr = j;
206575 pParse->iErr = j;
206581 pParse->hasNonstd = 1;
206587 jsonBlobAppendNode(pParse, opcode, j-1-i, &z[i+1]);
206592 jsonBlobAppendOneByte(pParse, JSONB_TRUE);
206595 pParse->iErr = i;
206600 jsonBlobAppendOneByte(pParse, JSONB_FALSE);
206603 pParse->iErr = i;
206608 pParse->hasNonstd = 1;
206613 pParse->hasNonstd = 1;
206618 pParse->iErr = i;
206644 pParse->hasNonstd = 1;
206649 pParse->iErr = i+1;
206660 pParse->hasNonstd = 1;
206662 jsonBlobAppendNode(pParse, JSONB_FLOAT, 6, "-9e999");
206664 jsonBlobAppendNode(pParse, JSONB_FLOAT, 5, "9e999");
206669 pParse->hasNonstd = 1;
206673 pParse->iErr = i;
206678 pParse->iErr = i+1;
206681 pParse->hasNonstd = 1;
206696 pParse->iErr = j;
206705 pParse->hasNonstd = 1;
206708 pParse->iErr = j;
206713 pParse->iErr = j;
206724 pParse->iErr = j;
206733 pParse->hasNonstd = 1;
206736 pParse->iErr = j;
206745 jsonBlobAppendNode(pParse, JSONB_INT+t, j-i, &z[i]);
206749 pParse->iErr = i;
206753 pParse->iErr = i;
206757 pParse->iErr = i;
206761 pParse->iErr = i;
206785 pParse->hasNonstd = 1;
206788 pParse->iErr = i;
206793 jsonBlobAppendOneByte(pParse, JSONB_NULL);
206811 jsonBlobAppendNode(pParse, JSONB_FLOAT, 5, "9e999");
206813 jsonBlobAppendOneByte(pParse, JSONB_NULL);
206815 pParse->hasNonstd = 1;
206818 pParse->iErr = i;
206827 ** are any errors. If an error occurs, free all memory held by pParse,
206828 ** but not pParse itself.
206830 ** pParse must be initialized to an empty parse object prior to calling
206834 JsonParse *pParse, /* Initialize and fill this JsonParse object */
206838 const char *zJson = pParse->zJson;
206839 i = jsonTranslateTextToBlob(pParse, 0);
206840 if( pParse->oom ) i = -1;
206843 assert( pParse->iDepth==0 );
206845 assert( jsonbValidityCheck(pParse, 0, pParse->nBlob, 0)==0 );
206853 jsonParseReset(pParse);
206856 pParse->hasNonstd = 1;
206861 if( pParse->oom ){
206867 jsonParseReset(pParse);
206905 static u32 jsonbPayloadSize(const JsonParse *pParse, u32 i, u32 *pSz){
206909 if( NEVER(i>pParse->nBlob) ){
206913 x = pParse->aBlob[i]>>4;
206918 if( i+1>=pParse->nBlob ){
206922 sz = pParse->aBlob[i+1];
206925 if( i+2>=pParse->nBlob ){
206929 sz = (pParse->aBlob[i+1]<<8) + pParse->aBlob[i+2];
206932 if( i+4>=pParse->nBlob ){
206936 sz = ((u32)pParse->aBlob[i+1]<<24) + (pParse->aBlob[i+2]<<16) +
206937 (pParse->aBlob[i+3]<<8) + pParse->aBlob[i+4];
206940 if( i+8>=pParse->nBlob
206941 || pParse->aBlob[i+1]!=0
206942 || pParse->aBlob[i+2]!=0
206943 || pParse->aBlob[i+3]!=0
206944 || pParse->aBlob[i+4]!=0
206949 sz = (pParse->aBlob[i+5]<<24) + (pParse->aBlob[i+6]<<16) +
206950 (pParse->aBlob[i+7]<<8) + pParse->aBlob[i+8];
206953 if( (i64)i+sz+n > pParse->nBlob
206954 && (i64)i+sz+n > pParse->nBlob-pParse->delta
206966 ** pParse->aBlob[i] into a JSON text string. Append the JSON
206967 ** text onto the end of pOut. Return the index in pParse->aBlob[]
206978 const JsonParse *pParse, /* the complete parse of the JSON */
206984 n = jsonbPayloadSize(pParse, i, &sz);
206987 return pParse->nBlob+1;
206989 switch( pParse->aBlob[i] & 0x0f ){
207005 jsonAppendRaw(pOut, (const char*)&pParse->aBlob[i+n], sz);
207011 const char *zIn = (const char*)&pParse->aBlob[i+n];
207035 const char *zIn = (const char*)&pParse->aBlob[i+n];
207055 jsonAppendRaw(pOut, (const char*)&pParse->aBlob[i+n], sz);
207063 zIn = (const char*)&pParse->aBlob[i+n];
207150 jsonAppendString(pOut, (const char*)&pParse->aBlob[i+n], sz);
207158 j = jsonTranslateBlobToText(pParse, j, pOut);
207172 j = jsonTranslateBlobToText(pParse, j, pOut);
207194 JsonParse *pParse; /* The BLOB being rendered */
207211 ** pParse->aBlob[i] into a JSON text string. Append the JSON
207212 ** text onto the end of pOut. Return the index in pParse->aBlob[]
207231 const JsonParse *pParse = pPretty->pParse;
207233 n = jsonbPayloadSize(pParse, i, &sz);
207236 return pParse->nBlob+1;
207238 switch( pParse->aBlob[i] & 0x0f ){
207269 j = jsonTranslateBlobToText(pParse, j, pOut);
207288 i = jsonTranslateBlobToText(pParse, i, pOut);
207326 static u32 jsonbArrayCount(JsonParse *pParse, u32 iRoot){
207329 n = jsonbPayloadSize(pParse, iRoot, &sz);
207332 n = jsonbPayloadSize(pParse, i, &sz);
207339 ** pParse->delta.
207341 static void jsonAfterEditSizeAdjust(JsonParse *pParse, u32 iRoot){
207344 assert( pParse->delta!=0 );
207345 assert( pParse->nBlobAlloc >= pParse->nBlob );
207346 nBlob = pParse->nBlob;
207347 pParse->nBlob = pParse->nBlobAlloc;
207348 (void)jsonbPayloadSize(pParse, iRoot, &sz);
207349 pParse->nBlob = nBlob;
207350 sz += pParse->delta;
207351 pParse->delta += jsonBlobChangePayloadSize(pParse, iRoot, sz);
207355 ** Modify the JSONB blob at pParse->aBlob by removing nDel bytes of
207365 ** Set pParse->oom if an OOM occurs.
207368 JsonParse *pParse, /* The JSONB to be modified is in pParse->aBlob */
207376 if( pParse->nBlob + d > pParse->nBlobAlloc ){
207377 jsonBlobExpand(pParse, pParse->nBlob+d);
207378 if( pParse->oom ) return;
207380 memmove(&pParse->aBlob[iDel+nIns],
207381 &pParse->aBlob[iDel+nDel],
207382 pParse->nBlob - (iDel+nDel));
207383 pParse->nBlob += d;
207384 pParse->delta += d;
207386 if( nIns && aIns ) memcpy(&pParse->aBlob[iDel], aIns, nIns);
207604 ** binary data that is to be inserted into pParse.
207606 ** In the common case, pIns just points to pParse->aIns and pParse->nIns.
207623 JsonParse *pParse, /* The original JSONB that is being edited */
207630 pIns->db = pParse->db;
207632 /* No substructure. Just insert what is given in pParse. */
207633 pIns->aBlob = pParse->aIns;
207634 pIns->nBlob = pParse->nIns;
207640 pIns->eEdit = pParse->eEdit;
207641 pIns->nIns = pParse->nIns;
207642 pIns->aIns = pParse->aIns;
207644 pParse->oom |= pIns->oom;
207651 ** index into pParse->aBlob[] for the start of that element's value.
207659 ** This routine will also modify the blob. If pParse->eEdit is one of
207667 JsonParse *pParse, /* The JSON to search */
207677 if( pParse->eEdit && jsonBlobMakeEditable(pParse, pParse->nIns) ){
207678 n = jsonbPayloadSize(pParse, iRoot, &sz);
207680 if( pParse->eEdit==JEDIT_DEL ){
207685 jsonBlobEdit(pParse, iRoot, sz, 0, 0);
207686 }else if( pParse->eEdit==JEDIT_INS ){
207690 jsonBlobEdit(pParse, iRoot, sz, pParse->aIns, pParse->nIns);
207693 pParse->iLabel = iLabel;
207698 x = pParse->aBlob[iRoot];
207720 n = jsonbPayloadSize(pParse, iRoot, &sz);
207726 x = pParse->aBlob[j] & 0x0f;
207728 n = jsonbPayloadSize(pParse, j, &sz);
207732 zLabel = (const char*)&pParse->aBlob[k];
207736 if( ((pParse->aBlob[v])&0x0f)>JSONB_OBJECT ) return JSON_LOOKUP_ERROR;
207737 n = jsonbPayloadSize(pParse, v, &sz);
207740 rc = jsonLookupStep(pParse, v, &zPath[i], j);
207741 if( pParse->delta ) jsonAfterEditSizeAdjust(pParse, iRoot);
207745 if( ((pParse->aBlob[j])&0x0f)>JSONB_OBJECT ) return JSON_LOOKUP_ERROR;
207746 n = jsonbPayloadSize(pParse, j, &sz);
207751 if( pParse->eEdit>=JEDIT_INS ){
207755 testcase( pParse->eEdit==JEDIT_INS );
207756 testcase( pParse->eEdit==JEDIT_SET );
207758 ix.db = pParse->db;
207760 pParse->oom |= ix.oom;
207761 rc = jsonCreateEditSubstructure(pParse, &v, &zPath[i]);
207763 && jsonBlobMakeEditable(pParse, ix.nBlob+nKey+v.nBlob)
207765 assert( !pParse->oom );
207767 jsonBlobEdit(pParse, j, 0, 0, nIns);
207768 if( !pParse->oom ){
207769 assert( pParse->aBlob!=0 ); /* Because pParse->oom!=0 */
207771 memcpy(&pParse->aBlob[j], ix.aBlob, ix.nBlob);
207773 memcpy(&pParse->aBlob[k], zKey, nKey);
207775 memcpy(&pParse->aBlob[k], v.aBlob, v.nBlob);
207776 if( ALWAYS(pParse->delta) ) jsonAfterEditSizeAdjust(pParse, iRoot);
207784 x = pParse->aBlob[iRoot] & 0x0f;
207786 n = jsonbPayloadSize(pParse, iRoot, &sz);
207795 k = jsonbArrayCount(pParse, iRoot);
207818 rc = jsonLookupStep(pParse, j, &zPath[i+1], 0);
207819 if( pParse->delta ) jsonAfterEditSizeAdjust(pParse, iRoot);
207823 n = jsonbPayloadSize(pParse, j, &sz);
207829 if( pParse->eEdit>=JEDIT_INS ){
207831 testcase( pParse->eEdit==JEDIT_INS );
207832 testcase( pParse->eEdit==JEDIT_SET );
207833 rc = jsonCreateEditSubstructure(pParse, &v, &zPath[i+1]);
207835 && jsonBlobMakeEditable(pParse, v.nBlob)
207837 assert( !pParse->oom );
207838 jsonBlobEdit(pParse, j, 0, v.aBlob, v.nBlob);
207841 if( pParse->delta ) jsonAfterEditSizeAdjust(pParse, iRoot);
207881 JsonParse *pParse, /* Complete JSON parse tree */
207890 n = jsonbPayloadSize(pParse, i, &sz);
207895 switch( pParse->aBlob[i] & 0x0f ){
207918 x = (char)pParse->aBlob[i+n];
207925 z = sqlite3DbStrNDup(db, (const char*)&pParse->aBlob[i+n], (int)sz);
207947 z = sqlite3DbStrNDup(db, (const char*)&pParse->aBlob[i+n], (int)sz);
207957 sqlite3_result_text(pCtx, (char*)&pParse->aBlob[i+n], sz,
207968 z = (const char*)&pParse->aBlob[i+n];
208010 sqlite3_result_blob(pCtx, &pParse->aBlob[i], sz+n, SQLITE_TRANSIENT);
208012 jsonReturnTextJsonFromBlob(pCtx, &pParse->aBlob[i], sz+n);
208034 ** Return the results in pParse.
208036 ** pParse is uninitialized upon entry. This routine will handle the
208037 ** initialization of pParse. The result will be contained in
208038 ** pParse->aBlob and pParse->nBlob. pParse->aBlob might be dynamically
208039 ** allocated (if pParse->nBlobAlloc is greater than zero) in which case
208040 ** the caller is responsible for freeing the space allocated to pParse->aBlob
208041 ** when it has finished with it. Or pParse->aBlob might be a static string
208051 JsonParse *pParse
208055 memset(pParse, 0, sizeof(pParse[0]));
208056 pParse->db = sqlite3_context_db_handle(ctx);
208059 pParse->aBlob = aNull;
208060 pParse->nBlob = 1;
208065 pParse->aBlob = (u8*)sqlite3_value_blob(pArg);
208066 pParse->nBlob = sqlite3_value_bytes(pArg);
208078 pParse->zJson = (char*)zJson;
208079 pParse->nJson = nJson;
208080 if( jsonConvertTextToBlob(pParse, ctx) ){
208082 sqlite3DbFree(pParse->db, pParse->aBlob);
208083 memset(pParse, 0, sizeof(pParse[0]));
208087 jsonBlobAppendNode(pParse, JSONB_TEXTRAW, nJson, zJson);
208094 jsonBlobAppendNode(pParse, JSONB_NULL, 0, 0);
208100 jsonBlobAppendNode(pParse, JSONB_FLOAT, 5, "9e999");
208102 jsonBlobAppendNode(pParse, JSONB_FLOAT, 6, "-9e999");
208104 jsonBlobAppendNode(pParse, JSONB_FLOAT, n, z);
208113 jsonBlobAppendNode(pParse, JSONB_INT, n, z);
208117 if( pParse->oom ){
208418 JsonParse *pParse, /* JSON content */
208427 u8 x = pParse->aBlob[iStart] & 0x0f;
208428 u32 savedNBlob = pParse->nBlob;
208430 if( pParse->nBlobAlloc>pParse->nBlob ){
208431 pParse->nBlob = pParse->nBlobAlloc;
208433 nn = n = jsonbPayloadSize(pParse, iStart, &sz);
208439 sqlite3_str_appendf(pOut, " %02x", pParse->aBlob[iStart+i]);
208446 pParse->nBlob = savedNBlob;
208449 if( iEnd>pParse->nBlob ){
208450 if( pParse->nBlobAlloc>0 && iEnd>pParse->nBlobAlloc ){
208451 iEnd = pParse->nBlobAlloc;
208453 iEnd = pParse->nBlob;
208472 jsonDebugPrintBlob(pParse, iStart+n, iStart+n+sz, nIndent+2, pOut);
208478 jsonDebugPrintBlob(pParse, iStart+n, iStart+n+sz, nIndent+2, pOut);
208495 u8 c = pParse->aBlob[j];
208505 static void jsonShowParse(JsonParse *pParse){
208508 if( pParse==0 ){
208512 printf("nBlobAlloc = %u\n", pParse->nBlobAlloc);
208513 printf("nBlob = %u\n", pParse->nBlob);
208514 printf("delta = %d\n", pParse->delta);
208515 if( pParse->nBlob==0 ) return;
208516 printf("content (bytes 0..%u):\n", pParse->nBlob-1);
208519 jsonDebugPrintBlob(pParse, 0, pParse->nBlob, 0, &out);
209227 x.pParse = jsonParseFuncArg(ctx, argv[0], 0);
209228 if( x.pParse==0 ) return;
209239 jsonParseFree(x.pParse);
232844 static void sqlite3Fts5ParseError(Fts5Parse *pParse, const char *zFmt, ...);
232847 Fts5Parse *pParse,
232855 Fts5Parse *pParse,
232861 Fts5Parse *pParse,
232888 static void sqlite3Fts5ParseFinished(Fts5Parse *pParse, Fts5ExprNode *p);
232889 static void sqlite3Fts5ParseNear(Fts5Parse *pParse, Fts5Token*);
233114 #define sqlite3Fts5ParserARG_SDECL Fts5Parse *pParse;
233115 #define sqlite3Fts5ParserARG_PDECL ,Fts5Parse *pParse
233116 #define sqlite3Fts5ParserARG_PARAM ,pParse
233117 #define sqlite3Fts5ParserARG_FETCH Fts5Parse *pParse=fts5yypParser->pParse;
233118 #define sqlite3Fts5ParserARG_STORE fts5yypParser->pParse=pParse;
233562 (void)pParse;
233822 sqlite3Fts5ParseError(pParse, "fts5: parser stack overflow");
233991 { sqlite3Fts5ParseFinished(pParse, fts5yymsp[0].minor.fts5yy24); }
233995 fts5yymsp[-3].minor.fts5yy11 = sqlite3Fts5ParseColsetInvert(pParse, fts5yymsp[-1].minor.fts5yy11);
234003 fts5yylhsminor.fts5yy11 = sqlite3Fts5ParseColset(pParse, 0, &fts5yymsp[0].minor.fts5yy0);
234009 fts5yymsp[-1].minor.fts5yy11 = sqlite3Fts5ParseColset(pParse, 0, &fts5yymsp[0].minor.fts5yy0);
234010 fts5yymsp[-1].minor.fts5yy11 = sqlite3Fts5ParseColsetInvert(pParse, fts5yymsp[-1].minor.fts5yy11);
234015 fts5yylhsminor.fts5yy11 = sqlite3Fts5ParseColset(pParse, fts5yymsp[-1].minor.fts5yy11, &fts5yymsp[0].minor.fts5yy0); }
234020 fts5yylhsminor.fts5yy11 = sqlite3Fts5ParseColset(pParse, 0, &fts5yymsp[0].minor.fts5yy0);
234026 fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_AND, fts5yymsp[-2].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24, 0);
234032 fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_OR, fts5yymsp[-2].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24, 0);
234038 fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_NOT, fts5yymsp[-2].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24, 0);
234044 sqlite3Fts5ParseSetColset(pParse, fts5yymsp[-1].minor.fts5yy24, fts5yymsp[-4].minor.fts5yy11);
234059 fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseImplicitAnd(pParse, fts5yymsp[-1].minor.fts5yy24, fts5yymsp[0].minor.fts5yy24);
234065 fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_STRING, 0, 0, fts5yymsp[0].minor.fts5yy46);
234071 fts5yylhsminor.fts5yy24 = sqlite3Fts5ParseNode(pParse, FTS5_STRING, 0, 0, fts5yymsp[0].minor.fts5yy46);
234072 sqlite3Fts5ParseSetColset(pParse, fts5yylhsminor.fts5yy24, fts5yymsp[-2].minor.fts5yy11);
234077 { fts5yylhsminor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, 0, fts5yymsp[0].minor.fts5yy53); }
234083 fts5yymsp[-1].minor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, 0, fts5yymsp[0].minor.fts5yy53);
234088 sqlite3Fts5ParseNear(pParse, &fts5yymsp[-4].minor.fts5yy0);
234089 sqlite3Fts5ParseSetDistance(pParse, fts5yymsp[-2].minor.fts5yy46, &fts5yymsp[-1].minor.fts5yy0);
234096 fts5yylhsminor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, 0, fts5yymsp[0].minor.fts5yy53);
234102 fts5yylhsminor.fts5yy46 = sqlite3Fts5ParseNearset(pParse, fts5yymsp[-1].minor.fts5yy46, fts5yymsp[0].minor.fts5yy53);
234114 fts5yylhsminor.fts5yy53 = sqlite3Fts5ParseTerm(pParse, fts5yymsp[-3].minor.fts5yy53, &fts5yymsp[-1].minor.fts5yy0, fts5yymsp[0].minor.fts5yy4);
234120 fts5yylhsminor.fts5yy53 = sqlite3Fts5ParseTerm(pParse, 0, &fts5yymsp[-1].minor.fts5yy0, fts5yymsp[0].minor.fts5yy4);
234193 pParse, "fts5: syntax error near \"%.*s\"",FTS5TOKEN.n,FTS5TOKEN.p
236841 static void sqlite3Fts5ParseError(Fts5Parse *pParse, const char *zFmt, ...){
236844 if( pParse->rc==SQLITE_OK ){
236845 assert( pParse->zErr==0 );
236846 pParse->zErr = sqlite3_vmprintf(zFmt, ap);
236847 pParse->rc = SQLITE_ERROR;
236860 Fts5Parse *pParse,
236895 sqlite3Fts5ParseError(pParse, "unterminated string");
236906 sqlite3Fts5ParseError(pParse, "fts5: syntax error near \"%.1s\"", z);
238316 Fts5Parse *pParse, /* Parse context */
238323 if( pParse->rc==SQLITE_OK ){
238332 pParse->rc = SQLITE_NOMEM;
238343 pParse->rc = SQLITE_NOMEM;
238351 assert( pParse->rc!=SQLITE_OK );
238357 assert( pParse!=0 );
238358 assert( pParse->apPhrase!=0 );
238359 assert( pParse->nPhrase>=2 );
238360 assert( pLast==pParse->apPhrase[pParse->nPhrase-2] );
238364 pParse->nPhrase--;
238368 pParse->apPhrase[pParse->nPhrase-2] = pPhrase;
238369 pParse->nPhrase--;
238479 static void sqlite3Fts5ParseFinished(Fts5Parse *pParse, Fts5ExprNode *p){
238480 assert( pParse->pExpr==0 );
238481 pParse->pExpr = p;
238484 static int parseGrowPhraseArray(Fts5Parse *pParse){
238485 if( (pParse->nPhrase % 8)==0 ){
238486 sqlite3_int64 nByte = sizeof(Fts5ExprPhrase*) * (pParse->nPhrase + 8);
238488 apNew = (Fts5ExprPhrase**)sqlite3_realloc64(pParse->apPhrase, nByte);
238490 pParse->rc = SQLITE_NOMEM;
238493 pParse->apPhrase = apNew;
238504 Fts5Parse *pParse, /* Parse context */
238509 Fts5Config *pConfig = pParse->pConfig;
238528 pParse->rc = rc;
238534 if( parseGrowPhraseArray(pParse) ){
238538 pParse->nPhrase++;
238544 sCtx.pPhrase = sqlite3Fts5MallocZero(&pParse->rc, sizeof(Fts5ExprPhrase));
238548 pParse->apPhrase[pParse->nPhrase-1] = sCtx.pPhrase;
238656 ** in the pParse object.
238658 static void sqlite3Fts5ParseNear(Fts5Parse *pParse, Fts5Token *pTok){
238661 pParse, "fts5: syntax error near \"%.*s\"", pTok->n, pTok->p
238667 Fts5Parse *pParse,
238679 pParse, "expected integer, got \"%.*s\"", p->n, p->p
238698 ** If an OOM error occurs, store an error code in pParse and return NULL.
238702 Fts5Parse *pParse, /* Store SQLITE_NOMEM here if required */
238709 assert( pParse->rc==SQLITE_OK );
238710 assert( iCol>=0 && iCol<pParse->pConfig->nCol );
238714 pParse->rc = SQLITE_NOMEM;
238742 static Fts5Colset *sqlite3Fts5ParseColsetInvert(Fts5Parse *pParse, Fts5Colset *p){
238744 int nCol = pParse->pConfig->nCol;
238746 pRet = (Fts5Colset*)sqlite3Fts5MallocZero(&pParse->rc,
238766 Fts5Parse *pParse, /* Store SQLITE_NOMEM here if required */
238774 z = sqlite3Fts5Strndup(&pParse->rc, p->p, p->n);
238775 if( pParse->rc==SQLITE_OK ){
238776 Fts5Config *pConfig = pParse->pConfig;
238782 sqlite3Fts5ParseError(pParse, "no such column: %s", z);
238784 pRet = fts5ParseColset(pParse, pColset, iCol);
238790 assert( pParse->rc!=SQLITE_OK );
238849 Fts5Parse *pParse,
238854 if( pParse->rc==SQLITE_OK ){
238871 pNear->pColset = fts5CloneColset(&pParse->rc, pColset);
238877 fts5ParseSetColset(pParse, pNode->apChild[i], pColset, ppFree);
238887 Fts5Parse *pParse,
238892 if( pParse->pConfig->eDetail==FTS5_DETAIL_NONE ){
238893 sqlite3Fts5ParseError(pParse,
238897 fts5ParseSetColset(pParse, pExpr, pColset, &pFree);
238962 Fts5Parse *pParse,
238971 assert( pParse->bPhraseToAnd );
238974 pRet = (Fts5ExprNode*)sqlite3Fts5MallocZero(&pParse->rc, nByte);
238980 pParse->nPhrase--;
238983 &pParse->rc, sizeof(Fts5ExprPhrase)
238986 if( parseGrowPhraseArray(pParse) ){
238991 pParse->apPhrase[pParse->nPhrase++] = pPhrase;
238993 pTo->pTerm = sqlite3Fts5Strndup(&pParse->rc, p->pTerm, p->nFullTerm);
238996 pRet->apChild[ii] = sqlite3Fts5ParseNode(pParse, FTS5_STRING,
238997 0, 0, sqlite3Fts5ParseNearset(pParse, 0, pPhrase)
239003 if( pParse->rc ){
239016 ** OOM error), leave an error code in pParse and return NULL.
239019 Fts5Parse *pParse, /* Parse context */
239027 if( pParse->rc==SQLITE_OK ){
239039 && pParse->bPhraseToAnd
239042 pRet = fts5ParsePhraseToAnd(pParse, pNear);
239053 pRet = (Fts5ExprNode*)sqlite3Fts5MallocZero(&pParse->rc, nByte);
239069 if( pParse->pConfig->eDetail!=FTS5_DETAIL_FULL ){
239075 sqlite3Fts5ParseError(pParse,
239087 sqlite3Fts5ParseError(pParse,
239100 assert( pParse->rc!=SQLITE_OK );
239109 Fts5Parse *pParse, /* Parse context */
239116 if( pParse->rc ){
239129 || (pRight->eType==FTS5_AND && pParse->bPhraseToAnd)
239143 assert( pParse->apPhrase[pParse->nPhrase-1]==pRight->pNear->apPhrase[0] );
239146 pParse->nPhrase--;
239158 ap = &pParse->apPhrase[pParse->nPhrase-1-pRight->pNear->nPhrase];
239161 pParse->nPhrase--;
239166 pRet = sqlite3Fts5ParseNode(pParse, FTS5_AND, pLeft, pRight, 0);