From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp44.i.mail.ru (smtp44.i.mail.ru [94.100.177.104]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dev.tarantool.org (Postfix) with ESMTPS id 845BE469719 for ; Fri, 9 Oct 2020 16:45:31 +0300 (MSK) From: Roman Khabibov Date: Fri, 9 Oct 2020 16:45:25 +0300 Message-Id: <20201009134529.13212-2-roman.habibov@tarantool.org> In-Reply-To: <20201009134529.13212-1-roman.habibov@tarantool.org> References: <20201009134529.13212-1-roman.habibov@tarantool.org> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Subject: [Tarantool-patches] [PATCH v4 1/5] sql: rename TK_COLUMN to TK_COLUMN_REF List-Id: Tarantool development patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: tarantool-patches@dev.tarantool.org Rename TK_COLUMN used for tokens treated as a column name to TK_COLUMN_REF. It is needed to allow the typing of COLUMN keyword in statement. Needed for #3075 --- extra/addopcodes.sh | 2 +- extra/mkkeywordhash.c | 5 +--- src/box/sql/build.c | 2 +- src/box/sql/expr.c | 48 ++++++++++++++++++++----------------- src/box/sql/fk_constraint.c | 2 +- src/box/sql/resolve.c | 10 ++++---- src/box/sql/select.c | 10 ++++---- src/box/sql/sqlInt.h | 8 +++---- src/box/sql/treeview.c | 2 +- src/box/sql/where.c | 18 +++++++------- src/box/sql/whereexpr.c | 12 +++++----- 11 files changed, 61 insertions(+), 58 deletions(-) diff --git a/extra/addopcodes.sh b/extra/addopcodes.sh index cb6c84725..3f8cfdf02 100755 --- a/extra/addopcodes.sh +++ b/extra/addopcodes.sh @@ -39,7 +39,7 @@ extras=" \ END_OF_FILE \ UNCLOSED_STRING \ FUNCTION \ - COLUMN \ + COLUMN_REF \ AGG_FUNCTION \ AGG_COLUMN \ UMINUS \ diff --git a/extra/mkkeywordhash.c b/extra/mkkeywordhash.c index dd42c8f5f..bacdad9b3 100644 --- a/extra/mkkeywordhash.c +++ b/extra/mkkeywordhash.c @@ -75,10 +75,7 @@ static Keyword aKeywordTable[] = { { "CAST", "TK_CAST", false }, { "CHECK", "TK_CHECK", true }, { "COLLATE", "TK_COLLATE", true }, - /* gh-3075: Reserved until ALTER ADD COLUMN is implemeneted. - * Move it back to ALTER when done. - */ - /* { "COLUMN", "TK_COLUMNKW", true }, */ + { "COLUMN_REF", "TK_COLUMN_REF", true }, { "COLUMN", "TK_STANDARD", true }, { "COMMIT", "TK_COMMIT", true }, { "CONFLICT", "TK_CONFLICT", false }, diff --git a/src/box/sql/build.c b/src/box/sql/build.c index 8f6b403b9..d55c1cd71 100644 --- a/src/box/sql/build.c +++ b/src/box/sql/build.c @@ -2295,7 +2295,7 @@ index_fill_def(struct Parse *parse, struct index *index, goto cleanup; struct Expr *column_expr = sqlExprSkipCollate(expr); - if (column_expr->op != TK_COLUMN) { + if (column_expr->op != TK_COLUMN_REF) { diag_set(ClientError, ER_UNSUPPORTED, "Tarantool", "functional indexes"); goto tnt_error; diff --git a/src/box/sql/expr.c b/src/box/sql/expr.c index bc2182446..3772596d6 100644 --- a/src/box/sql/expr.c +++ b/src/box/sql/expr.c @@ -62,7 +62,7 @@ sql_expr_type(struct Expr *pExpr) assert(!ExprHasProperty(pExpr, EP_IntValue)); return pExpr->type; case TK_AGG_COLUMN: - case TK_COLUMN: + case TK_COLUMN_REF: case TK_TRIGGER: assert(pExpr->iColumn >= 0); return pExpr->space_def->fields[pExpr->iColumn].type; @@ -262,13 +262,13 @@ sql_expr_coll(Parse *parse, Expr *p, bool *is_explicit_coll, uint32_t *coll_id, *is_explicit_coll = true; break; } - if ((op == TK_AGG_COLUMN || op == TK_COLUMN || + if ((op == TK_AGG_COLUMN || op == TK_COLUMN_REF || op == TK_REGISTER || op == TK_TRIGGER) && p->space_def != NULL) { /* * op==TK_REGISTER && p->space_def!=0 * happens when pExpr was originally - * a TK_COLUMN but was previously + * a TK_COLUMN_REF but was previously * evaluated and cached in a register. */ int j = p->iColumn; @@ -2061,11 +2061,11 @@ exprNodeIsConstant(Walker * pWalker, Expr * pExpr) return WRC_Abort; } case TK_ID: - case TK_COLUMN: + case TK_COLUMN_REF: case TK_AGG_FUNCTION: case TK_AGG_COLUMN: testcase(pExpr->op == TK_ID); - testcase(pExpr->op == TK_COLUMN); + testcase(pExpr->op == TK_COLUMN_REF); testcase(pExpr->op == TK_AGG_FUNCTION); testcase(pExpr->op == TK_AGG_COLUMN); if (pWalker->eCode == 3 && pExpr->iTable == pWalker->u.iCur) { @@ -2236,7 +2236,7 @@ sqlExprCanBeNull(const Expr * p) case TK_FLOAT: case TK_BLOB: return 0; - case TK_COLUMN: + case TK_COLUMN_REF: assert(p->space_def != 0); return ExprHasProperty(p, EP_CanBeNull) || (p->iColumn >= 0 @@ -2267,7 +2267,7 @@ sql_expr_needs_no_type_change(const struct Expr *p, enum field_type type) return type == FIELD_TYPE_STRING; case TK_BLOB: return type == FIELD_TYPE_VARBINARY; - case TK_COLUMN: + case TK_COLUMN_REF: /* p cannot be part of a CHECK constraint. */ assert(p->iTable >= 0); return p->iColumn < 0 && sql_type_is_numeric(type); @@ -2324,7 +2324,7 @@ isCandidateForInOpt(Expr * pX) /* All SELECT results must be columns. */ for (i = 0; i < pEList->nExpr; i++) { Expr *pRes = pEList->a[i].pExpr; - if (pRes->op != TK_COLUMN) + if (pRes->op != TK_COLUMN_REF) return 0; assert(pRes->iTable == pSrc->a[0].iCursor); /* Not a correlated subquery */ } @@ -3707,10 +3707,13 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target) } return target; } - /* Otherwise, fall thru into the TK_COLUMN case */ + /* + * Otherwise, fall thru into the + * TK_COLUMN_REF case. + */ FALLTHROUGH; } - case TK_COLUMN:{ + case TK_COLUMN_REF:{ int iTab = pExpr->iTable; int col = pExpr->iColumn; if (iTab < 0) { @@ -4102,7 +4105,7 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target) assert(nFarg == 1); assert(pFarg->a[0].pExpr != 0); exprOp = pFarg->a[0].pExpr->op; - if (exprOp == TK_COLUMN + if (exprOp == TK_COLUMN_REF || exprOp == TK_AGG_COLUMN) { assert(SQL_FUNC_LENGTH == OPFLAG_LENGTHARG); @@ -4319,7 +4322,7 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target) endLabel = sqlVdbeMakeLabel(v); if ((pX = pExpr->pLeft) != 0) { tempX = *pX; - testcase(pX->op == TK_COLUMN); + testcase(pX->op == TK_COLUMN_REF); exprToRegister(&tempX, exprCodeVector(pParse, &tempX, ®Free1)); @@ -4344,11 +4347,11 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target) pTest = aListelem[i].pExpr; } nextCase = sqlVdbeMakeLabel(v); - testcase(pTest->op == TK_COLUMN); + testcase(pTest->op == TK_COLUMN_REF); sqlExprIfFalse(pParse, pTest, nextCase, SQL_JUMPIFNULL); testcase(aListelem[i + 1].pExpr->op == - TK_COLUMN); + TK_COLUMN_REF); sqlExprCode(pParse, aListelem[i + 1].pExpr, target); sqlVdbeGoto(v, endLabel); @@ -5081,7 +5084,8 @@ sqlExprCompare(Expr * pA, Expr * pB, int iTab) } return 2; } - if (pA->op != TK_COLUMN && pA->op != TK_AGG_COLUMN && pA->u.zToken) { + if (pA->op != TK_COLUMN_REF && pA->op != TK_AGG_COLUMN && + pA->u.zToken) { if (pA->op == TK_FUNCTION) { if (sqlStrICmp(pA->u.zToken, pB->u.zToken) != 0) return 2; @@ -5161,8 +5165,8 @@ sqlExprListCompare(ExprList * pA, ExprList * pB, int iTab) * pE1: x IS NULL pE2: x IS NOT NULL Result: false * pE1: x IS ?2 pE2: x IS NOT NULL Reuslt: false * - * When comparing TK_COLUMN nodes between pE1 and pE2, if pE2 has - * Expr.iTable<0 then assume a table number given by iTab. + * When comparing TK_COLUMN_REF nodes between pE1 and pE2, if + * pE2 has Expr.iTable<0 then assume a table number given by iTab. * * When in doubt, return false. Returning true might give a performance * improvement. Returning false might cause a performance reduction, but @@ -5209,11 +5213,11 @@ exprSrcCount(Walker * pWalker, Expr * pExpr) { /* The NEVER() on the second term is because sqlFunctionUsesThisSrc() * is always called before sqlExprAnalyzeAggregates() and so the - * TK_COLUMNs have not yet been converted into TK_AGG_COLUMN. If + * TK_COLUMN_REFs have not yet been converted into TK_AGG_COLUMN. If * sqlFunctionUsesThisSrc() is used differently in the future, the * NEVER() will need to be removed. */ - if (pExpr->op == TK_COLUMN || NEVER(pExpr->op == TK_AGG_COLUMN)) { + if (pExpr->op == TK_COLUMN_REF || NEVER(pExpr->op == TK_AGG_COLUMN)) { int i; struct SrcCount *p = pWalker->u.pSrcCount; SrcList *pSrc = p->pSrc; @@ -5299,9 +5303,9 @@ analyzeAggregate(Walker * pWalker, Expr * pExpr) switch (pExpr->op) { case TK_AGG_COLUMN: - case TK_COLUMN:{ + case TK_COLUMN_REF:{ testcase(pExpr->op == TK_AGG_COLUMN); - testcase(pExpr->op == TK_COLUMN); + testcase(pExpr->op == TK_COLUMN_REF); /* Check to see if the column is in one of the tables in the FROM * clause of the aggregate query */ @@ -5370,7 +5374,7 @@ analyzeAggregate(Walker * pWalker, Expr * pExpr) if (pE-> op == - TK_COLUMN + TK_COLUMN_REF && pE-> iTable diff --git a/src/box/sql/fk_constraint.c b/src/box/sql/fk_constraint.c index 482220a95..0dd10c420 100644 --- a/src/box/sql/fk_constraint.c +++ b/src/box/sql/fk_constraint.c @@ -338,7 +338,7 @@ static struct Expr * sql_expr_new_column_by_cursor(struct sql *db, struct space_def *def, int cursor, int column) { - struct Expr *expr = sql_expr_new_anon(db, TK_COLUMN); + struct Expr *expr = sql_expr_new_anon(db, TK_COLUMN_REF); if (expr == NULL) return NULL; expr->space_def = def; diff --git a/src/box/sql/resolve.c b/src/box/sql/resolve.c index 6f625dc18..11b6139e3 100644 --- a/src/box/sql/resolve.c +++ b/src/box/sql/resolve.c @@ -189,7 +189,7 @@ sqlMatchSpanName(const char *zSpan, * pExpr->space_def Points to the space_def structure of X.Y * (even if X and/or Y are implied.) * pExpr->iColumn Set to the column number within the table. - * pExpr->op Set to TK_COLUMN. + * pExpr->op Set to TK_COLUMN_REF. * pExpr->pLeft Any expression this points to is deleted * pExpr->pRight Any expression this points to is deleted. * @@ -461,7 +461,7 @@ lookupName(Parse * pParse, /* The parsing context */ pExpr->pLeft = 0; sql_expr_delete(db, pExpr->pRight, false); pExpr->pRight = 0; - pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN); + pExpr->op = (isTrigger ? TK_TRIGGER : TK_COLUMN_REF); lookupname_end: if (cnt == 1) { assert(pNC != 0); @@ -485,7 +485,7 @@ struct Expr * sql_expr_new_column(struct sql *db, struct SrcList *src_list, int src_idx, int column) { - struct Expr *expr = sql_expr_new_anon(db, TK_COLUMN); + struct Expr *expr = sql_expr_new_anon(db, TK_COLUMN_REF); if (expr == NULL) return NULL; struct SrcList_item *item = &src_list->a[src_idx]; @@ -518,7 +518,7 @@ exprProbability(Expr * p) /* * This routine is callback for sqlWalkExpr(). * - * Resolve symbolic names into TK_COLUMN operators for the current + * Resolve symbolic names into TK_COLUMN_REF operators for the current * node in the expression tree. Return 0 to continue the search down * the tree or 2 to abort the tree walk. * @@ -1451,7 +1451,7 @@ resolveSelectStep(Walker * pWalker, Select * p) * * The node at the root of the subtree is modified as follows: * - * Expr.op Changed to TK_COLUMN + * Expr.op Changed to TK_COLUMN_REF * Expr.pTab Points to the Table object for X.Y * Expr.iColumn The column index in X.Y. -1 for the rowid. * Expr.iTable The VDBE cursor number for X.Y diff --git a/src/box/sql/select.c b/src/box/sql/select.c index b0554a172..c638511ef 100644 --- a/src/box/sql/select.c +++ b/src/box/sql/select.c @@ -1817,7 +1817,7 @@ generate_column_metadata(struct Parse *pParse, struct SrcList *pTabList, vdbe_metadata_set_col_nullability(v, i, -1); const char *colname = pEList->a[i].zName; const char *span = pEList->a[i].zSpan; - if (p->op == TK_COLUMN || p->op == TK_AGG_COLUMN) { + if (p->op == TK_COLUMN_REF || p->op == TK_AGG_COLUMN) { char *zCol; int iCol = p->iColumn; for (j = 0; ALWAYS(j < pTabList->nSrc); j++) { @@ -1939,7 +1939,7 @@ sqlColumnsFromExprList(Parse * parse, ExprList * expr_list, pColExpr = pColExpr->pRight; assert(pColExpr != 0); } - if (pColExpr->op == TK_COLUMN + if (pColExpr->op == TK_COLUMN_REF && ALWAYS(pColExpr->space_def != NULL)) { /* For columns use the column name name */ int iCol = pColExpr->iColumn; @@ -3653,7 +3653,7 @@ substExpr(Parse * pParse, /* Report errors here */ sql *db = pParse->db; if (pExpr == 0) return 0; - if (pExpr->op == TK_COLUMN && pExpr->iTable == iTable) { + if (pExpr->op == TK_COLUMN_REF && pExpr->iTable == iTable) { if (pExpr->iColumn < 0) { pExpr->op = TK_NULL; } else { @@ -6044,7 +6044,7 @@ sqlSelect(Parse * pParse, /* The parser context */ /* Create a label to jump to when we want to abort the query */ addrEnd = sqlVdbeMakeLabel(v); - /* Convert TK_COLUMN nodes into TK_AGG_COLUMN and make entries in + /* Convert TK_COLUMN_REF nodes into TK_AGG_COLUMN and make entries in * sAggInfo for all TK_AGG_FUNCTION nodes in expressions of the * SELECT statement. */ @@ -6416,7 +6416,7 @@ sqlSelect(Parse * pParse, /* The parser context */ flag != WHERE_ORDERBY_MIN ? 1 : 0; pMinMax->a[0].pExpr->op = - TK_COLUMN; + TK_COLUMN_REF; } } diff --git a/src/box/sql/sqlInt.h b/src/box/sql/sqlInt.h index adf90d824..5913d7614 100644 --- a/src/box/sql/sqlInt.h +++ b/src/box/sql/sqlInt.h @@ -1517,7 +1517,7 @@ typedef int ynVar; * valid. * * An expression of the form ID or ID.ID refers to a column in a table. - * For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is + * For such expressions, Expr.op is set to TK_COLUMN_REF and Expr.iTable is * the integer cursor number of a VDBE cursor pointing to that table and * Expr.iColumn is the column number for the specific column. If the * expression is used as a result in an aggregate SELECT, then the @@ -1587,20 +1587,20 @@ struct Expr { #if SQL_MAX_EXPR_DEPTH>0 int nHeight; /* Height of the tree headed by this node */ #endif - int iTable; /* TK_COLUMN: cursor number of table holding column + int iTable; /* TK_COLUMN_REF: cursor number of table holding column * TK_REGISTER: register number * TK_TRIGGER: 1 -> new, 0 -> old * EP_Unlikely: 134217728 times likelihood * TK_SELECT: 1st register of result vector */ - ynVar iColumn; /* TK_COLUMN: column index. + ynVar iColumn; /* TK_COLUMN_REF: column index. * TK_VARIABLE: variable number (always >= 1). * TK_SELECT_COLUMN: column of the result vector */ i16 iAgg; /* Which entry in pAggInfo->aCol[] or ->aFunc[] */ i16 iRightJoinTable; /* If EP_FromJoin, the right table of the join */ u8 op2; /* TK_REGISTER: original value of Expr.op - * TK_COLUMN: the value of p5 for OP_Column + * TK_COLUMN_REF: the value of p5 for OP_Column * TK_AGG_FUNCTION: nesting depth */ AggInfo *pAggInfo; /* Used by TK_AGG_COLUMN and TK_AGG_FUNCTION */ diff --git a/src/box/sql/treeview.c b/src/box/sql/treeview.c index a04597979..5f042ce8b 100644 --- a/src/box/sql/treeview.c +++ b/src/box/sql/treeview.c @@ -327,7 +327,7 @@ sqlTreeViewExpr(TreeView * pView, const Expr * pExpr, u8 moreToFollow) zFlgs); break; } - case TK_COLUMN:{ + case TK_COLUMN_REF:{ if (pExpr->iTable < 0) { /* This only happens when coding check constraints */ sqlTreeViewLine(pView, "COLUMN(%d)%s", diff --git a/src/box/sql/where.c b/src/box/sql/where.c index e9e936856..bb84cbadb 100644 --- a/src/box/sql/where.c +++ b/src/box/sql/where.c @@ -276,7 +276,7 @@ whereScanNext(WhereScan * pScan) sqlExprSkipCollate(pTerm-> pExpr-> pRight))-> - op == TK_COLUMN) { + op == TK_COLUMN_REF) { int j; for (j = 0; j < pScan->nEquiv; j++) { if (pScan->aiCur[j] == pX->iTable @@ -319,7 +319,7 @@ whereScanNext(WhereScan * pScan) } } if ((pTerm->eOperator & WO_EQ) != 0 - && (pX = pTerm->pExpr->pRight)->op == TK_COLUMN + && (pX = pTerm->pExpr->pRight)->op == TK_COLUMN_REF && pX->iTable == pScan->aiCur[0] && pX->iColumn == pScan->aiColumn[0]) { continue; @@ -555,7 +555,7 @@ findIndexCol(Parse * pParse, /* Parse context */ struct key_part *part_to_match = &idx_def->key_def->parts[iCol]; for (int i = 0; i < pList->nExpr; i++) { Expr *p = sqlExprSkipCollate(pList->a[i].pExpr); - if (p->op == TK_COLUMN && p->iTable == iBase && + if (p->op == TK_COLUMN_REF && p->iTable == iBase && p->iColumn == (int) part_to_match->fieldno) { bool is_found; uint32_t id; @@ -601,7 +601,8 @@ isDistinctRedundant(Parse * pParse, /* Parsing context */ */ for (int i = 0; i < pDistinct->nExpr; i++) { Expr *p = sqlExprSkipCollate(pDistinct->a[i].pExpr); - if (p->op == TK_COLUMN && p->iTable == iBase && p->iColumn < 0) + if (p->op == TK_COLUMN_REF && p->iTable == iBase && + p->iColumn < 0) return 1; } if (space == NULL) @@ -2245,7 +2246,7 @@ whereRangeVectorLen(Parse * pParse, /* Parsing context */ * leftmost index column. */ struct key_part *parts = idx_def->key_def->parts; - if (pLhs->op != TK_COLUMN || pLhs->iTable != iCur || + if (pLhs->op != TK_COLUMN_REF || pLhs->iTable != iCur || pLhs->iColumn != (int)parts[i + nEq].fieldno || parts[i + nEq].sort_order != parts[nEq].sort_order) break; @@ -2677,7 +2678,7 @@ indexMightHelpWithOrderBy(WhereLoopBuilder * pBuilder, return 0; for (ii = 0; ii < pOB->nExpr; ii++) { Expr *pExpr = sqlExprSkipCollate(pOB->a[ii].pExpr); - if (pExpr->op == TK_COLUMN && pExpr->iTable == iCursor) { + if (pExpr->op == TK_COLUMN_REF && pExpr->iTable == iCursor) { if (pExpr->iColumn < 0) return 1; for (jj = 0; jj < part_count; jj++) { @@ -3213,7 +3214,7 @@ wherePathSatisfiesOrderBy(WhereInfo * pWInfo, /* The WHERE clause */ if (MASKBIT(i) & obSat) continue; pOBExpr = sqlExprSkipCollate(pOrderBy->a[i].pExpr); - if (pOBExpr->op != TK_COLUMN) + if (pOBExpr->op != TK_COLUMN_REF) continue; if (pOBExpr->iTable != iCur) continue; @@ -3361,7 +3362,8 @@ wherePathSatisfiesOrderBy(WhereInfo * pWInfo, /* The WHERE clause */ if ((wctrlFlags & (WHERE_GROUPBY | WHERE_DISTINCTBY)) == 0) bOnce = 0; if (iColumn >= (-1)) { - if (pOBExpr->op != TK_COLUMN) + if (pOBExpr->op != + TK_COLUMN_REF) continue; if (pOBExpr->iTable != iCur) continue; diff --git a/src/box/sql/whereexpr.c b/src/box/sql/whereexpr.c index d9b5c78f5..3811ef3cf 100644 --- a/src/box/sql/whereexpr.c +++ b/src/box/sql/whereexpr.c @@ -279,7 +279,7 @@ like_optimization_is_valid(Parse *pParse, Expr *pExpr, Expr **ppPrefix, pList = pExpr->x.pList; pLeft = pList->a[1].pExpr; /* Value might be numeric */ - if (pLeft->op != TK_COLUMN || + if (pLeft->op != TK_COLUMN_REF || sql_expr_type(pLeft) != FIELD_TYPE_STRING) { /* IMP: R-02065-49465 The left-hand side of the * LIKE operator must be the name of an indexed @@ -928,7 +928,7 @@ exprSelectUsage(WhereMaskSet * pMaskSet, Select * pS) * number of the table that is indexed and *piColumn to the column number * of the column that is indexed. * - * If pExpr is a TK_COLUMN column reference, then this routine always returns + * If pExpr is a TK_COLUMN_REF column reference, then this routine always returns * true even if that particular column is not indexed, because the column * might be added to an automatic index later. */ @@ -950,7 +950,7 @@ exprMightBeIndexed(int op, /* The specific comparison operator */ pExpr = pExpr->x.pList->a[0].pExpr; } - if (pExpr->op == TK_COLUMN) { + if (pExpr->op == TK_COLUMN_REF) { *piCur = pExpr->iTable; *piColumn = pExpr->iColumn; return 1; @@ -1272,7 +1272,7 @@ exprAnalyze(SrcList * pSrc, /* the FROM clause */ * Note that the virtual term must be tagged with TERM_VNULL. */ if (pExpr->op == TK_NOTNULL - && pExpr->pLeft->op == TK_COLUMN + && pExpr->pLeft->op == TK_COLUMN_REF && pExpr->pLeft->iColumn >= 0) { Expr *pNewExpr; Expr *pLeft = pExpr->pLeft; @@ -1397,7 +1397,7 @@ sqlWhereExprUsage(WhereMaskSet * pMaskSet, Expr * p) Bitmask mask; if (p == 0) return 0; - if (p->op == TK_COLUMN) { + if (p->op == TK_COLUMN_REF) { mask = sqlWhereGetMask(pMaskSet, p->iTable); return mask; } @@ -1475,7 +1475,7 @@ sqlWhereTabFuncArgs(Parse * pParse, /* Parsing context */ * unused. */ assert(k < (int)space_def->field_count); - pColRef = sql_expr_new_anon(pParse->db, TK_COLUMN); + pColRef = sql_expr_new_anon(pParse->db, TK_COLUMN_REF); if (pColRef == NULL) { pParse->is_aborted = true; return; -- 2.24.3 (Apple Git-128)