From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from localhost (localhost [127.0.0.1]) by turing.freelists.org (Avenir Technologies Mail Multiplex) with ESMTP id 0BED120700 for ; Wed, 23 May 2018 10:05:47 -0400 (EDT) Received: from turing.freelists.org ([127.0.0.1]) by localhost (turing.freelists.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 1yzwTFohqSJL for ; Wed, 23 May 2018 10:05:46 -0400 (EDT) Received: from smtpng2.m.smailru.net (smtpng2.m.smailru.net [94.100.179.3]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by turing.freelists.org (Avenir Technologies Mail Multiplex) with ESMTPS id 6A123206CA for ; Wed, 23 May 2018 10:05:46 -0400 (EDT) From: Kirill Shcherbatov Subject: [tarantool-patches] [PATCH v7 6/7] sql: export funcs defined on Expr, ExprList to sql.h Date: Wed, 23 May 2018 17:05:33 +0300 Message-Id: <26d7bf8070e9e573eb61897c34bf027a52eb8d66.1527084287.git.kshcherbatov@tarantool.org> In-Reply-To: References: In-Reply-To: References: Sender: tarantool-patches-bounce@freelists.org Errors-to: tarantool-patches-bounce@freelists.org Reply-To: tarantool-patches@freelists.org List-help: List-unsubscribe: List-software: Ecartis version 1.0.0 List-Id: tarantool-patches List-subscribe: List-owner: List-post: List-archive: To: tarantool-patches@freelists.org Cc: v.shpilevoy@tarantool.org, Kirill Shcherbatov As we would like work with check in server, we need to export - sqlite3ExprListAppend as sql_expr_list_append - sqlite3ExprListDelete as sql_expr_list_delete - sqlite3ExprListDup as sql_expr_list_dup. Part of #3272. --- src/box/sql.h | 57 ++++++++++++++++++++++++++++++ src/box/sql/build.c | 39 +++++++++++---------- src/box/sql/expr.c | 93 +++++++++++++++++++++---------------------------- src/box/sql/fkey.c | 11 +++--- src/box/sql/insert.c | 2 +- src/box/sql/parse.y | 81 +++++++++++++++++++++--------------------- src/box/sql/prepare.c | 2 +- src/box/sql/resolve.c | 37 +++++++------------- src/box/sql/select.c | 40 +++++++++++---------- src/box/sql/sqliteInt.h | 4 --- src/box/sql/trigger.c | 8 ++--- src/box/sql/update.c | 2 +- src/box/sql/wherecode.c | 12 +++---- src/box/sql/whereexpr.c | 6 ++-- 14 files changed, 214 insertions(+), 180 deletions(-) diff --git a/src/box/sql.h b/src/box/sql.h index 20f0651..d031d9b 100644 --- a/src/box/sql.h +++ b/src/box/sql.h @@ -178,6 +178,63 @@ int sql_table_def_rebuild(struct sqlite3 *db, struct Table *table); /** + * Duplicate Expr list. + * The flags parameter contains a combination of the EXPRDUP_XXX flags. + * If the EXPRDUP_REDUCE flag is set, then the structure returned is a + * truncated version of the usual Expr structure that will be stored as + * part of the in-memory representation of the database schema. + * @param db The database connection. + * @param p The ExprList to duplicate. + * @param flags EXPRDUP_XXX flags. + * @retval NULL on memory allocation error. + * @retval not NULL on success. + */ +struct ExprList * +sql_expr_list_dup(struct sqlite3 * db, struct ExprList * p, int flags); + +/** + * Free AST pointed by expr list. + * @param db SQL handle. + * @param expr_list Root pointer of ExprList. + */ +void +sql_expr_list_delete(struct sqlite3 *db, struct ExprList *expr_list); + +/** + * Add a new element to the end of an expression list. If expr_list is + * initially NULL, then create a new expression list. + * + * If a memory allocation error occurs, the entire list is freed and + * NULL is returned. If non-NULL is returned, then it is guaranteed + * that the new entry was successfully appended. + * @param db SQL handle. + * @param expr_list List to which to append. Might be NULL. + * @param expr Expression to be appended. Might be NULL. + * @retval NULL on memory allocation error. + * @retval not NULL on success. + */ +struct ExprList * +sql_expr_list_append(struct sqlite3 * db, struct ExprList *expr_list, + struct Expr *expr); + +/** + * Resolve names in expressions that can only reference a single table: + * * CHECK constraints + * * WHERE clauses on partial indices + * The Expr.iTable value for Expr.op==TK_COLUMN nodes of the expression + * is set to -1 and the Expr.iColumn value is set to the column number. + * Any errors cause an error message to be set in pParse. + * @param parser Parsing context. + * @param table The table being referenced. + * @param type NC_IsCheck or NC_PartIdx or NC_IdxExpr. + * @param expr Expression to resolve. May be NULL. + * @param expr_list Expression list to resolve. May be NUL. + */ +void +sql_resolve_self_reference(struct Parse *parser, struct Table *table, int type, + struct Expr *expr, struct ExprList *expr_list); + +/** * Initialize a new parser object. * A number of service allocations are performed on the region, which is also * cleared in the destroy function. diff --git a/src/box/sql/build.c b/src/box/sql/build.c index afb1128..d00bb1d 100644 --- a/src/box/sql/build.c +++ b/src/box/sql/build.c @@ -252,7 +252,7 @@ static void freeIndex(sqlite3 * db, Index * p) { sql_expr_delete(db, p->pPartIdxWhere, false); - sqlite3ExprListDelete(db, p->aColExpr); + sql_expr_list_delete(db, p->aColExpr); sqlite3DbFree(db, p->zColAff); sqlite3DbFree(db, p); } @@ -406,7 +406,7 @@ deleteTable(sqlite3 * db, Table * pTable) sqlite3DbFree(db, pTable->aCol); sqlite3DbFree(db, pTable->zColAff); sqlite3SelectDelete(db, pTable->pSelect); - sqlite3ExprListDelete(db, pTable->pCheck); + sql_expr_list_delete(db, pTable->pCheck); assert(pTable->def != NULL); /* Do not delete pTable->def allocated on region. */ if (!pTable->def->opts.temporary) @@ -1015,7 +1015,7 @@ sqlite3AddPrimaryKey(Parse * pParse, /* Parsing context */ } primary_key_exit: - sqlite3ExprListDelete(pParse->db, pList); + sql_expr_list_delete(pParse->db, pList); return; } @@ -1027,7 +1027,7 @@ sql_add_check_constraint(Parse *parser, ExprSpan *span) Table *table = parser->pNewTable; if (table != NULL) { table->pCheck = - sqlite3ExprListAppend(parser, table->pCheck, expr); + sql_expr_list_append(parser->db, table->pCheck, expr); if (parser->constraintName.n) { sqlite3ExprListSetName(parser, table->pCheck, &parser->constraintName, 1); @@ -1411,7 +1411,7 @@ convertToWithoutRowidTable(Parse * pParse, Table * pTab) ExprList *pList; Token ipkToken; sqlite3TokenInit(&ipkToken, pTab->def->fields[pTab->iPKey].name); - pList = sqlite3ExprListAppend(pParse, 0, + pList = sql_expr_list_append(pParse->db, NULL, sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0)); if (pList == 0) @@ -1855,7 +1855,7 @@ sqlite3EndTable(Parse * pParse, /* Parse context */ /* Resolve names in all CHECK constraint expressions. */ if (p->pCheck) { - sqlite3ResolveSelfReference(pParse, p, NC_IsCheck, 0, + sql_resolve_self_reference(pParse, p, NC_IsCheck, NULL, p->pCheck); } #endif /* !defined(SQLITE_OMIT_CHECK) */ @@ -2020,7 +2020,7 @@ sqlite3CreateView(Parse * pParse, /* The parsing context */ */ p->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); p->def->opts.is_view = true; - p->pCheck = sqlite3ExprListDup(db, pCNames, EXPRDUP_REDUCE); + p->pCheck = sql_expr_list_dup(db, pCNames, EXPRDUP_REDUCE); if (db->mallocFailed) goto create_view_fail; @@ -2047,7 +2047,7 @@ sqlite3CreateView(Parse * pParse, /* The parsing context */ create_view_fail: sqlite3SelectDelete(db, pSelect); - sqlite3ExprListDelete(db, pCNames); + sql_expr_list_delete(db, pCNames); return; } #endif /* SQLITE_OMIT_VIEW */ @@ -2561,8 +2561,8 @@ sqlite3CreateForeignKey(Parse * pParse, /* Parsing context */ fk_end: sqlite3DbFree(db, pFKey); #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ - sqlite3ExprListDelete(db, pFromCol); - sqlite3ExprListDelete(db, pToCol); + sql_expr_list_delete(db, pFromCol); + sql_expr_list_delete(db, pToCol); } /* @@ -2952,7 +2952,7 @@ sql_create_index(struct Parse *parse, struct Token *token, Token prevCol; sqlite3TokenInit(&prevCol, pTab->def->fields[ pTab->def->field_count - 1].name); - col_list = sqlite3ExprListAppend(parse, 0, + col_list = sql_expr_list_append(parse->db, NULL, sqlite3ExprAlloc(db, TK_ID, &prevCol, 0)); if (col_list == NULL) @@ -3005,7 +3005,8 @@ sql_create_index(struct Parse *parse, struct Token *token, pIndex->nColumn = col_list->nExpr; /* Tarantool have access to each column by any index */ if (where) { - sqlite3ResolveSelfReference(parse, pTab, NC_PartIdx, where, 0); + sql_resolve_self_reference(parse, pTab, NC_PartIdx, where, + NULL); pIndex->pPartIdxWhere = where; where = NULL; } @@ -3022,8 +3023,8 @@ sql_create_index(struct Parse *parse, struct Token *token, for (i = 0, col_listItem = col_list->a; i < col_list->nExpr; i++, col_listItem++) { Expr *pCExpr; /* The i-th index expression */ - sqlite3ResolveSelfReference(parse, pTab, NC_IdxExpr, - col_listItem->pExpr, 0); + sql_resolve_self_reference(parse, pTab, NC_IdxExpr, + col_listItem->pExpr, NULL); if (parse->nErr > 0) goto exit_create_index; pCExpr = sqlite3ExprSkipCollate(col_listItem->pExpr); @@ -3236,7 +3237,7 @@ sql_create_index(struct Parse *parse, struct Token *token, if (pIndex) freeIndex(db, pIndex); sql_expr_delete(db, where, false); - sqlite3ExprListDelete(db, col_list); + sql_expr_list_delete(db, col_list); sqlite3SrcListDelete(db, tbl_name); sqlite3DbFree(db, zName); } @@ -3648,7 +3649,7 @@ sqlite3SrcListDelete(sqlite3 * db, SrcList * pList) if (pItem->fg.isIndexedBy) sqlite3DbFree(db, pItem->u1.zIndexedBy); if (pItem->fg.isTabFunc) - sqlite3ExprListDelete(db, pItem->u1.pFuncArg); + sql_expr_list_delete(db, pItem->u1.pFuncArg); sqlite3DeleteTable(db, pItem->pTab); sqlite3SelectDelete(db, pItem->pSelect); sql_expr_delete(db, pItem->pOn, false); @@ -3754,7 +3755,7 @@ sqlite3SrcListFuncArgs(Parse * pParse, SrcList * p, ExprList * pList) pItem->u1.pFuncArg = pList; pItem->fg.isTabFunc = 1; } else { - sqlite3ExprListDelete(pParse->db, pList); + sql_expr_list_delete(pParse->db, pList); } } @@ -4110,7 +4111,7 @@ sqlite3WithAdd(Parse * pParse, /* Parsing context */ assert((pNew != 0 && zName != 0) || db->mallocFailed); if (db->mallocFailed) { - sqlite3ExprListDelete(db, pArglist); + sql_expr_list_delete(db, pArglist); sqlite3SelectDelete(db, pQuery); sqlite3DbFree(db, zName); pNew = pWith; @@ -4135,7 +4136,7 @@ sqlite3WithDelete(sqlite3 * db, With * pWith) int i; for (i = 0; i < pWith->nCte; i++) { struct Cte *pCte = &pWith->a[i]; - sqlite3ExprListDelete(db, pCte->pCols); + sql_expr_list_delete(db, pCte->pCols); sqlite3SelectDelete(db, pCte->pSelect); sqlite3DbFree(db, pCte->zName); } diff --git a/src/box/sql/expr.c b/src/box/sql/expr.c index 64991ee..ecb0915 100644 --- a/src/box/sql/expr.c +++ b/src/box/sql/expr.c @@ -1043,7 +1043,7 @@ sqlite3ExprFunction(Parse * pParse, ExprList * pList, Token * pToken) assert(pToken); pNew = sqlite3ExprAlloc(db, TK_FUNCTION, pToken, 1); if (pNew == 0) { - sqlite3ExprListDelete(db, pList); /* Avoid memory leak when malloc fails */ + sql_expr_list_delete(db, pList); /* Avoid memory leak when malloc fails */ return 0; } pNew->x.pList = pList; @@ -1162,7 +1162,7 @@ sqlite3ExprDeleteNN(sqlite3 * db, Expr * p, bool extern_alloc) if (ExprHasProperty(p, EP_xIsSelect)) { sqlite3SelectDelete(db, p->x.pSelect); } else { - sqlite3ExprListDelete(db, p->x.pList); + sql_expr_list_delete(db, p->x.pList); } } if (ExprHasProperty(p, EP_MemToken)) @@ -1350,8 +1350,7 @@ sql_expr_dup(struct sqlite3 *db, struct Expr *p, int flags, char **buffer) flags); } else { pNew->x.pList = - sqlite3ExprListDup(db, p->x.pList, - flags); + sql_expr_list_dup(db, p->x.pList, flags); } } @@ -1408,7 +1407,7 @@ withDup(sqlite3 * db, With * p) pRet->a[i].pSelect = sqlite3SelectDup(db, p->a[i].pSelect, 0); pRet->a[i].pCols = - sqlite3ExprListDup(db, p->a[i].pCols, 0); + sql_expr_list_dup(db, p->a[i].pCols, 0); pRet->a[i].zName = sqlite3DbStrDup(db, p->a[i].zName); } @@ -1426,7 +1425,7 @@ withDup(sqlite3 * db, With * p) * be deleted (by being passed to their respective ...Delete() routines) * without effecting the originals. * - * The expression list, ID, and source lists return by sqlite3ExprListDup(), + * The expression list, ID, and source lists return by sql_expr_list_dup(), * sqlite3IdListDup(), and sqlite3SrcListDup() can not be further expanded * by subsequent calls to sqlite*ListAppend() routines. * @@ -1444,8 +1443,8 @@ sqlite3ExprDup(sqlite3 * db, Expr * p, int flags) return p ? sql_expr_dup(db, p, flags, 0) : 0; } -ExprList * -sqlite3ExprListDup(sqlite3 * db, ExprList * p, int flags) +struct ExprList * +sql_expr_list_dup(struct sqlite3 * db, struct ExprList *p, int flags) { ExprList *pNew; struct ExprList_item *pItem, *pOldItem; @@ -1538,7 +1537,7 @@ sqlite3SrcListDup(sqlite3 * db, SrcList * p, int flags) pNewItem->pIBIndex = pOldItem->pIBIndex; if (pNewItem->fg.isTabFunc) { pNewItem->u1.pFuncArg = - sqlite3ExprListDup(db, pOldItem->u1.pFuncArg, + sql_expr_list_dup(db, pOldItem->u1.pFuncArg, flags); } pTab = pNewItem->pTab = pOldItem->pTab; @@ -1594,12 +1593,12 @@ sqlite3SelectDup(sqlite3 * db, Select * p, int flags) pNew = sqlite3DbMallocRawNN(db, sizeof(*p)); if (pNew == 0) return 0; - pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags); + pNew->pEList = sql_expr_list_dup(db, p->pEList, flags); pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags); pNew->pWhere = sqlite3ExprDup(db, p->pWhere, flags); - pNew->pGroupBy = sqlite3ExprListDup(db, p->pGroupBy, flags); + pNew->pGroupBy = sql_expr_list_dup(db, p->pGroupBy, flags); pNew->pHaving = sqlite3ExprDup(db, p->pHaving, flags); - pNew->pOrderBy = sqlite3ExprListDup(db, p->pOrderBy, flags); + pNew->pOrderBy = sql_expr_list_dup(db, p->pOrderBy, flags); pNew->op = p->op; pNew->pPrior = pPrior = sqlite3SelectDup(db, p->pPrior, flags); if (pPrior) @@ -1618,51 +1617,39 @@ sqlite3SelectDup(sqlite3 * db, Select * p, int flags) return pNew; } -/* - * Add a new element to the end of an expression list. If pList is - * initially NULL, then create a new expression list. - * - * If a memory allocation error occurs, the entire list is freed and - * NULL is returned. If non-NULL is returned, then it is guaranteed - * that the new entry was successfully appended. - */ -ExprList * -sqlite3ExprListAppend(Parse * pParse, /* Parsing context */ - ExprList * pList, /* List to which to append. Might be NULL */ - Expr * pExpr /* Expression to be appended. Might be NULL */ - ) +struct ExprList * +sql_expr_list_append(struct sqlite3 * db, struct ExprList *expr_list, + struct Expr *expr) { - sqlite3 *db = pParse->db; - assert(db != 0); - if (pList == 0) { - pList = sqlite3DbMallocRawNN(db, sizeof(ExprList)); - if (pList == 0) { + assert(db != NULL); + if (expr_list == NULL) { + expr_list = sqlite3DbMallocRawNN(db, sizeof(ExprList)); + if (expr_list == NULL) goto no_mem; - } - pList->nExpr = 0; - pList->a = sqlite3DbMallocRawNN(db, sizeof(pList->a[0])); - if (pList->a == 0) + expr_list->nExpr = 0; + expr_list->a = + sqlite3DbMallocRawNN(db, sizeof(expr_list->a[0])); + if (expr_list->a == NULL) goto no_mem; - } else if ((pList->nExpr & (pList->nExpr - 1)) == 0) { + } else if ((expr_list->nExpr & (expr_list->nExpr - 1)) == 0) { struct ExprList_item *a; - assert(pList->nExpr > 0); - a = sqlite3DbRealloc(db, pList->a, - pList->nExpr * 2 * sizeof(pList->a[0])); - if (a == 0) { + assert(expr_list->nExpr > 0); + a = sqlite3DbRealloc(db, expr_list->a, expr_list->nExpr * 2 * + sizeof(expr_list->a[0])); + if (a == NULL) goto no_mem; - } - pList->a = a; + expr_list->a = a; } - assert(pList->a != 0); - struct ExprList_item *pItem = &pList->a[pList->nExpr++]; + assert(expr_list->a != NULL); + struct ExprList_item *pItem = &expr_list->a[expr_list->nExpr++]; memset(pItem, 0, sizeof(*pItem)); - pItem->pExpr = pExpr; - return pList; + pItem->pExpr = expr; + return expr_list; no_mem: /* Avoid leaking memory if malloc has failed. */ - sql_expr_delete(db, pExpr, false); - sqlite3ExprListDelete(db, pList); + sql_expr_delete(db, expr, false); + sql_expr_list_delete(db, expr_list); return 0; } @@ -1710,7 +1697,7 @@ sqlite3ExprListAppendVector(Parse * pParse, /* Parsing context */ for (i = 0; i < pColumns->nId; i++) { Expr *pSubExpr = sqlite3ExprForVectorField(pParse, pExpr, i); - pList = sqlite3ExprListAppend(pParse, pList, pSubExpr); + pList = sql_expr_list_append(pParse->db, pList, pSubExpr); if (pList) { assert(pList->nExpr == iFirst + i + 1); pList->a[pList->nExpr - 1].zName = pColumns->a[i].zName; @@ -1724,7 +1711,7 @@ sqlite3ExprListAppendVector(Parse * pParse, /* Parsing context */ assert(pFirst->op == TK_SELECT_COLUMN); /* Store the SELECT statement in pRight so it will be deleted when - * sqlite3ExprListDelete() is called + * sql_expr_list_delete() is called */ pFirst->pRight = pExpr; pExpr = 0; @@ -1847,10 +1834,10 @@ exprListDeleteNN(sqlite3 * db, ExprList * pList) } void -sqlite3ExprListDelete(sqlite3 * db, ExprList * pList) +sql_expr_list_delete(sqlite3 *db, ExprList *expr_list) { - if (pList) - exprListDeleteNN(db, pList); + if (expr_list) + exprListDeleteNN(db, expr_list); } /* @@ -4394,7 +4381,7 @@ sqlite3ExprCodeAtInit(Parse * pParse, /* Parsing context */ assert(ConstFactorOk(pParse)); p = pParse->pConstExpr; pExpr = sqlite3ExprDup(pParse->db, pExpr, 0); - p = sqlite3ExprListAppend(pParse, p, pExpr); + p = sql_expr_list_append(pParse->db, p, pExpr); if (p) { struct ExprList_item *pItem = &p->a[p->nExpr - 1]; pItem->u.iConstExprReg = regDest; diff --git a/src/box/sql/fkey.c b/src/box/sql/fkey.c index 2ab8fdd..3e30a44 100644 --- a/src/box/sql/fkey.c +++ b/src/box/sql/fkey.c @@ -743,7 +743,7 @@ fkTriggerDelete(sqlite3 * dbMem, Trigger * p) if (p) { TriggerStep *pStep = p->step_list; sql_expr_delete(dbMem, pStep->pWhere, false); - sqlite3ExprListDelete(dbMem, pStep->pExprList); + sql_expr_list_delete(dbMem, pStep->pExprList); sqlite3SelectDelete(dbMem, pStep->pSelect); sql_expr_delete(dbMem, p->pWhen, false); sqlite3DbFree(dbMem, p); @@ -1353,7 +1353,8 @@ fkActionTrigger(Parse * pParse, /* Parse context */ sqlite3ExprAlloc(db, TK_NULL, 0, 0); } pList = - sqlite3ExprListAppend(pParse, pList, pNew); + sql_expr_list_append(pParse->db, pList, + pNew); sqlite3ExprListSetName(pParse, pList, &tFromCol, 0); } @@ -1376,7 +1377,7 @@ fkActionTrigger(Parse * pParse, /* Parse context */ pRaise->affinity = ON_CONFLICT_ACTION_ABORT; } pSelect = sqlite3SelectNew(pParse, - sqlite3ExprListAppend(pParse, + sql_expr_list_append(pParse->db, 0, pRaise), sqlite3SrcListAppend(db, 0, @@ -1401,7 +1402,7 @@ fkActionTrigger(Parse * pParse, /* Parse context */ pStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); pStep->pExprList = - sqlite3ExprListDup(db, pList, EXPRDUP_REDUCE); + sql_expr_list_dup(db, pList, EXPRDUP_REDUCE); pStep->pSelect = sqlite3SelectDup(db, pSelect, EXPRDUP_REDUCE); if (pWhen) { @@ -1416,7 +1417,7 @@ fkActionTrigger(Parse * pParse, /* Parse context */ sql_expr_delete(db, pWhere, false); sql_expr_delete(db, pWhen, false); - sqlite3ExprListDelete(db, pList); + sql_expr_list_delete(db, pList); sqlite3SelectDelete(db, pSelect); if (db->mallocFailed == 1) { fkTriggerDelete(db, pTrigger); diff --git a/src/box/sql/insert.c b/src/box/sql/insert.c index 6cc6805..6e7144c 100644 --- a/src/box/sql/insert.c +++ b/src/box/sql/insert.c @@ -919,7 +919,7 @@ sqlite3Insert(Parse * pParse, /* Parser context */ insert_cleanup: sqlite3SrcListDelete(db, pTabList); - sqlite3ExprListDelete(db, pList); + sql_expr_list_delete(db, pList); sqlite3SelectDelete(db, pSelect); sqlite3IdListDelete(db, pColumn); sqlite3DbFree(db, aRegIdx); diff --git a/src/box/sql/parse.y b/src/box/sql/parse.y index cc3931d..6f385ba 100644 --- a/src/box/sql/parse.y +++ b/src/box/sql/parse.y @@ -528,25 +528,25 @@ distinct(A) ::= . {A = 0;} // opcode of TK_ASTERISK. // %type selcollist {ExprList*} -%destructor selcollist {sqlite3ExprListDelete(pParse->db, $$);} +%destructor selcollist {sql_expr_list_delete(pParse->db, $$);} %type sclp {ExprList*} -%destructor sclp {sqlite3ExprListDelete(pParse->db, $$);} +%destructor sclp {sql_expr_list_delete(pParse->db, $$);} sclp(A) ::= selcollist(A) COMMA. sclp(A) ::= . {A = 0;} selcollist(A) ::= sclp(A) expr(X) as(Y). { - A = sqlite3ExprListAppend(pParse, A, X.pExpr); + A = sql_expr_list_append(pParse->db, A, X.pExpr); if( Y.n>0 ) sqlite3ExprListSetName(pParse, A, &Y, 1); sqlite3ExprListSetSpan(pParse,A,&X); } selcollist(A) ::= sclp(A) STAR. { Expr *p = sqlite3Expr(pParse->db, TK_ASTERISK, 0); - A = sqlite3ExprListAppend(pParse, A, p); + A = sql_expr_list_append(pParse->db, A, p); } selcollist(A) ::= sclp(A) nm(X) DOT STAR. { Expr *pRight = sqlite3PExpr(pParse, TK_ASTERISK, 0, 0); Expr *pLeft = sqlite3ExprAlloc(pParse->db, TK_ID, &X, 1); Expr *pDot = sqlite3PExpr(pParse, TK_DOT, pLeft, pRight); - A = sqlite3ExprListAppend(pParse,A, pDot); + A = sql_expr_list_append(pParse->db,A, pDot); } // An option "AS " phrase that can follow one of the expressions that @@ -661,23 +661,24 @@ using_opt(U) ::= . {U = 0;} %type orderby_opt {ExprList*} -%destructor orderby_opt {sqlite3ExprListDelete(pParse->db, $$);} +%destructor orderby_opt {sql_expr_list_delete(pParse->db, $$);} // the sortlist non-terminal stores a list of expression where each // expression is optionally followed by ASC or DESC to indicate the // sort order. // %type sortlist {ExprList*} -%destructor sortlist {sqlite3ExprListDelete(pParse->db, $$);} +%destructor sortlist {sql_expr_list_delete(pParse->db, $$);} orderby_opt(A) ::= . {A = 0;} orderby_opt(A) ::= ORDER BY sortlist(X). {A = X;} sortlist(A) ::= sortlist(A) COMMA expr(Y) sortorder(Z). { - A = sqlite3ExprListAppend(pParse,A,Y.pExpr); + A = sql_expr_list_append(pParse->db,A,Y.pExpr); sqlite3ExprListSetSortOrder(A,Z); } sortlist(A) ::= expr(Y) sortorder(Z). { - A = sqlite3ExprListAppend(pParse,0,Y.pExpr); /*A-overwrites-Y*/ + /* A-overwrites-Y. */ + A = sql_expr_list_append(pParse->db,NULL,Y.pExpr); sqlite3ExprListSetSortOrder(A,Z); } @@ -688,7 +689,7 @@ sortorder(A) ::= DESC. {A = SORT_ORDER_DESC;} sortorder(A) ::= . {A = SORT_ORDER_UNDEF;} %type groupby_opt {ExprList*} -%destructor groupby_opt {sqlite3ExprListDelete(pParse->db, $$);} +%destructor groupby_opt {sql_expr_list_delete(pParse->db, $$);} groupby_opt(A) ::= . {A = 0;} groupby_opt(A) ::= GROUP BY nexprlist(X). {A = X;} @@ -750,17 +751,17 @@ cmd ::= with(C) UPDATE orconf(R) fullname(X) indexed_opt(I) SET setlist(Y) %endif %type setlist {ExprList*} -%destructor setlist {sqlite3ExprListDelete(pParse->db, $$);} +%destructor setlist {sql_expr_list_delete(pParse->db, $$);} setlist(A) ::= setlist(A) COMMA nm(X) EQ expr(Y). { - A = sqlite3ExprListAppend(pParse, A, Y.pExpr); + A = sql_expr_list_append(pParse->db, A, Y.pExpr); sqlite3ExprListSetName(pParse, A, &X, 1); } setlist(A) ::= setlist(A) COMMA LP idlist(X) RP EQ expr(Y). { A = sqlite3ExprListAppendVector(pParse, A, X, Y.pExpr); } setlist(A) ::= nm(X) EQ expr(Y). { - A = sqlite3ExprListAppend(pParse, 0, Y.pExpr); + A = sql_expr_list_append(pParse->db, NULL, Y.pExpr); sqlite3ExprListSetName(pParse, A, &X, 1); } setlist(A) ::= LP idlist(X) RP EQ expr(Y). { @@ -942,13 +943,13 @@ term(A) ::= CTIME_KW(OP). { } expr(A) ::= LP(L) nexprlist(X) COMMA expr(Y) RP(R). { - ExprList *pList = sqlite3ExprListAppend(pParse, X, Y.pExpr); + ExprList *pList = sql_expr_list_append(pParse->db, X, Y.pExpr); A.pExpr = sqlite3PExpr(pParse, TK_VECTOR, 0, 0); if( A.pExpr ){ A.pExpr->x.pList = pList; spanSet(&A, &L, &R); }else{ - sqlite3ExprListDelete(pParse->db, pList); + sql_expr_list_delete(pParse->db, pList); } } @@ -971,8 +972,8 @@ expr(A) ::= expr(A) likeop(OP) expr(Y). [LIKE_KW] { ExprList *pList; int bNot = OP.n & 0x80000000; OP.n &= 0x7fffffff; - pList = sqlite3ExprListAppend(pParse,0, Y.pExpr); - pList = sqlite3ExprListAppend(pParse,pList, A.pExpr); + pList = sql_expr_list_append(pParse->db,NULL, Y.pExpr); + pList = sql_expr_list_append(pParse->db,pList, A.pExpr); A.pExpr = sqlite3ExprFunction(pParse, pList, &OP); exprNot(pParse, bNot, &A); A.zEnd = Y.zEnd; @@ -982,9 +983,9 @@ expr(A) ::= expr(A) likeop(OP) expr(Y) ESCAPE expr(E). [LIKE_KW] { ExprList *pList; int bNot = OP.n & 0x80000000; OP.n &= 0x7fffffff; - pList = sqlite3ExprListAppend(pParse,0, Y.pExpr); - pList = sqlite3ExprListAppend(pParse,pList, A.pExpr); - pList = sqlite3ExprListAppend(pParse,pList, E.pExpr); + pList = sql_expr_list_append(pParse->db,NULL, Y.pExpr); + pList = sql_expr_list_append(pParse->db,pList, A.pExpr); + pList = sql_expr_list_append(pParse->db,pList, E.pExpr); A.pExpr = sqlite3ExprFunction(pParse, pList, &OP); exprNot(pParse, bNot, &A); A.zEnd = E.zEnd; @@ -1067,13 +1068,13 @@ expr(A) ::= PLUS(B) expr(X). [BITNOT] between_op(A) ::= BETWEEN. {A = 0;} between_op(A) ::= NOT BETWEEN. {A = 1;} expr(A) ::= expr(A) between_op(N) expr(X) AND expr(Y). [BETWEEN] { - ExprList *pList = sqlite3ExprListAppend(pParse,0, X.pExpr); - pList = sqlite3ExprListAppend(pParse,pList, Y.pExpr); + ExprList *pList = sql_expr_list_append(pParse->db,NULL, X.pExpr); + pList = sql_expr_list_append(pParse->db,pList, Y.pExpr); A.pExpr = sqlite3PExpr(pParse, TK_BETWEEN, A.pExpr, 0); if( A.pExpr ){ A.pExpr->x.pList = pList; }else{ - sqlite3ExprListDelete(pParse->db, pList); + sql_expr_list_delete(pParse->db, pList); } exprNot(pParse, N, &A); A.zEnd = Y.zEnd; @@ -1112,7 +1113,7 @@ expr(A) ::= expr(A) in_op(N) LP exprlist(Y) RP(E). [IN] { */ Expr *pRHS = Y->a[0].pExpr; Y->a[0].pExpr = 0; - sqlite3ExprListDelete(pParse->db, Y); + sql_expr_list_delete(pParse->db, Y); /* pRHS cannot be NULL because a malloc error would have been detected ** before now and control would have never reached this point */ if( ALWAYS(pRHS) ){ @@ -1126,7 +1127,7 @@ expr(A) ::= expr(A) in_op(N) LP exprlist(Y) RP(E). [IN] { A.pExpr->x.pList = Y; sqlite3ExprSetHeightAndFlags(pParse, A.pExpr); }else{ - sqlite3ExprListDelete(pParse->db, Y); + sql_expr_list_delete(pParse->db, Y); } exprNot(pParse, N, &A); } @@ -1164,22 +1165,22 @@ expr(A) ::= CASE(C) case_operand(X) case_exprlist(Y) case_else(Z) END(E). { spanSet(&A,&C,&E); /*A-overwrites-C*/ A.pExpr = sqlite3PExpr(pParse, TK_CASE, X, 0); if( A.pExpr ){ - A.pExpr->x.pList = Z ? sqlite3ExprListAppend(pParse,Y,Z) : Y; + A.pExpr->x.pList = Z ? sql_expr_list_append(pParse->db,Y,Z) : Y; sqlite3ExprSetHeightAndFlags(pParse, A.pExpr); }else{ - sqlite3ExprListDelete(pParse->db, Y); + sql_expr_list_delete(pParse->db, Y); sql_expr_delete(pParse->db, Z, false); } } %type case_exprlist {ExprList*} -%destructor case_exprlist {sqlite3ExprListDelete(pParse->db, $$);} +%destructor case_exprlist {sql_expr_list_delete(pParse->db, $$);} case_exprlist(A) ::= case_exprlist(A) WHEN expr(Y) THEN expr(Z). { - A = sqlite3ExprListAppend(pParse,A, Y.pExpr); - A = sqlite3ExprListAppend(pParse,A, Z.pExpr); + A = sql_expr_list_append(pParse->db,A, Y.pExpr); + A = sql_expr_list_append(pParse->db,A, Z.pExpr); } case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). { - A = sqlite3ExprListAppend(pParse,0, Y.pExpr); - A = sqlite3ExprListAppend(pParse,A, Z.pExpr); + A = sql_expr_list_append(pParse->db,NULL, Y.pExpr); + A = sql_expr_list_append(pParse->db,A, Z.pExpr); } %type case_else {Expr*} %destructor case_else {sql_expr_delete(pParse->db, $$, false);} @@ -1191,21 +1192,21 @@ case_operand(A) ::= expr(X). {A = X.pExpr; /*A-overwrites-X*/} case_operand(A) ::= . {A = 0;} %type exprlist {ExprList*} -%destructor exprlist {sqlite3ExprListDelete(pParse->db, $$);} +%destructor exprlist {sql_expr_list_delete(pParse->db, $$);} %type nexprlist {ExprList*} -%destructor nexprlist {sqlite3ExprListDelete(pParse->db, $$);} +%destructor nexprlist {sql_expr_list_delete(pParse->db, $$);} exprlist(A) ::= nexprlist(A). exprlist(A) ::= . {A = 0;} nexprlist(A) ::= nexprlist(A) COMMA expr(Y). - {A = sqlite3ExprListAppend(pParse,A,Y.pExpr);} + {A = sql_expr_list_append(pParse->db,A,Y.pExpr);} nexprlist(A) ::= expr(Y). - {A = sqlite3ExprListAppend(pParse,0,Y.pExpr); /*A-overwrites-Y*/} + {A = sql_expr_list_append(pParse->db,NULL,Y.pExpr); /*A-overwrites-Y*/} /* A paren_exprlist is an optional expression list contained inside ** of parenthesis */ %type paren_exprlist {ExprList*} -%destructor paren_exprlist {sqlite3ExprListDelete(pParse->db, $$);} +%destructor paren_exprlist {sql_expr_list_delete(pParse->db, $$);} paren_exprlist(A) ::= . {A = 0;} paren_exprlist(A) ::= LP exprlist(X) RP. {A = X;} @@ -1232,9 +1233,9 @@ uniqueflag(A) ::= . {A = ON_CONFLICT_ACTION_NONE;} // used for the arguments to an index. That is just an historical accident. // %type eidlist {ExprList*} -%destructor eidlist {sqlite3ExprListDelete(pParse->db, $$);} +%destructor eidlist {sql_expr_list_delete(pParse->db, $$);} %type eidlist_opt {ExprList*} -%destructor eidlist_opt {sqlite3ExprListDelete(pParse->db, $$);} +%destructor eidlist_opt {sql_expr_list_delete(pParse->db, $$);} %include { /* Add a single new term to an ExprList that is used to store a @@ -1249,7 +1250,7 @@ uniqueflag(A) ::= . {A = ON_CONFLICT_ACTION_NONE;} int hasCollate, int sortOrder ){ - ExprList *p = sqlite3ExprListAppend(pParse, pPrior, 0); + ExprList *p = sql_expr_list_append(pParse->db, pPrior, NULL); if( (hasCollate || sortOrder != SORT_ORDER_UNDEF) && pParse->db->init.busy==0 ){ diff --git a/src/box/sql/prepare.c b/src/box/sql/prepare.c index 8d94642..e7fc583 100644 --- a/src/box/sql/prepare.c +++ b/src/box/sql/prepare.c @@ -447,7 +447,7 @@ sql_parser_destroy(Parse *parser) assert(parser != NULL); sqlite3 *db = parser->db; sqlite3DbFree(db, parser->aLabel); - sqlite3ExprListDelete(db, parser->pConstExpr); + sql_expr_list_delete(db, parser->pConstExpr); if (db != NULL) { assert(db->lookaside.bDisable >= parser->disableLookaside); diff --git a/src/box/sql/resolve.c b/src/box/sql/resolve.c index 7f0858a..fd82119 100644 --- a/src/box/sql/resolve.c +++ b/src/box/sql/resolve.c @@ -1578,40 +1578,27 @@ sqlite3ResolveSelectNames(Parse * pParse, /* The parser context */ sqlite3WalkSelect(&w, p); } -/* - * Resolve names in expressions that can only reference a single table: - * - * * CHECK constraints - * * WHERE clauses on partial indices - * - * The Expr.iTable value for Expr.op==TK_COLUMN nodes of the expression - * is set to -1 and the Expr.iColumn value is set to the column number. - * - * Any errors cause an error message to be set in pParse. - */ void -sqlite3ResolveSelfReference(Parse * pParse, /* Parsing context */ - Table * pTab, /* The table being referenced */ - int type, /* NC_IsCheck or NC_PartIdx or NC_IdxExpr */ - Expr * pExpr, /* Expression to resolve. May be NULL. */ - ExprList * pList /* Expression list to resolve. May be NUL. */ - ) +sql_resolve_self_reference(struct Parse *parser, struct Table *table, int type, + struct Expr *expr, struct ExprList *expr_list) { - SrcList sSrc; /* Fake SrcList for pParse->pNewTable */ - NameContext sNC; /* Name context for pParse->pNewTable */ + /* Fake SrcList for pParse->pNewTable */ + SrcList sSrc; + /* Name context for pParse->pNewTable */ + NameContext sNC; assert(type == NC_IsCheck || type == NC_PartIdx || type == NC_IdxExpr); memset(&sNC, 0, sizeof(sNC)); memset(&sSrc, 0, sizeof(sSrc)); sSrc.nSrc = 1; - sSrc.a[0].zName = pTab->def->name; - sSrc.a[0].pTab = pTab; + sSrc.a[0].zName = table->def->name; + sSrc.a[0].pTab = table; sSrc.a[0].iCursor = -1; - sNC.pParse = pParse; + sNC.pParse = parser; sNC.pSrcList = &sSrc; sNC.ncFlags = type; - if (sqlite3ResolveExprNames(&sNC, pExpr)) + if (sqlite3ResolveExprNames(&sNC, expr)) return; - if (pList) - sqlite3ResolveExprListNames(&sNC, pList); + if (expr_list != NULL) + sqlite3ResolveExprListNames(&sNC, expr_list); } diff --git a/src/box/sql/select.c b/src/box/sql/select.c index 75bd53d..cd305be 100644 --- a/src/box/sql/select.c +++ b/src/box/sql/select.c @@ -95,12 +95,12 @@ clearSelect(sqlite3 * db, Select * p, int bFree) { while (p) { Select *pPrior = p->pPrior; - sqlite3ExprListDelete(db, p->pEList); + sql_expr_list_delete(db, p->pEList); sqlite3SrcListDelete(db, p->pSrc); sql_expr_delete(db, p->pWhere, false); - sqlite3ExprListDelete(db, p->pGroupBy); + sql_expr_list_delete(db, p->pGroupBy); sql_expr_delete(db, p->pHaving, false); - sqlite3ExprListDelete(db, p->pOrderBy); + sql_expr_list_delete(db, p->pOrderBy); sql_expr_delete(db, p->pLimit, false); sql_expr_delete(db, p->pOffset, false); if (p->pWith) @@ -151,7 +151,7 @@ sqlite3SelectNew(Parse * pParse, /* Parsing context */ } if (pEList == 0) { pEList = - sqlite3ExprListAppend(pParse, 0, + sql_expr_list_append(pParse->db, NULL, sqlite3Expr(db, TK_ASTERISK, 0)); } struct session MAYBE_UNUSED *user_session; @@ -2336,7 +2336,7 @@ generateWithRecursiveQuery(Parse * pParse, /* Parsing context */ sqlite3VdbeResolveLabel(v, addrBreak); end_of_recursive_query: - sqlite3ExprListDelete(pParse->db, p->pOrderBy); + sql_expr_list_delete(pParse->db, p->pOrderBy); p->pOrderBy = pOrderBy; p->pLimit = pLimit; p->pOffset = pOffset; @@ -2629,7 +2629,7 @@ multiSelect(Parse * pParse, /* Parsing context */ /* Query flattening in sqlite3Select() might refill p->pOrderBy. * Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */ - sqlite3ExprListDelete(db, p->pOrderBy); + sql_expr_list_delete(db, p->pOrderBy); pDelete = p->pPrior; p->pPrior = pPrior; p->pOrderBy = 0; @@ -3191,7 +3191,7 @@ multiSelectOrderBy(Parse * pParse, /* Parsing context */ pNew->flags |= EP_IntValue; pNew->u.iValue = i; pOrderBy = - sqlite3ExprListAppend(pParse, pOrderBy, + sql_expr_list_append(pParse->db, pOrderBy, pNew); if (pOrderBy) pOrderBy->a[nOrderBy++].u.x. @@ -3224,7 +3224,7 @@ multiSelectOrderBy(Parse * pParse, /* Parsing context */ /* Reattach the ORDER BY clause to the query. */ p->pOrderBy = pOrderBy; - pPrior->pOrderBy = sqlite3ExprListDup(pParse->db, pOrderBy, 0); + pPrior->pOrderBy = sql_expr_list_dup(pParse->db, pOrderBy, 0); /* Allocate a range of temporary registers and the key_def needed * for the logic that removes duplicate result rows when the @@ -4086,7 +4086,7 @@ flattenSubquery(Parse * pParse, /* Parsing context */ pParent->pHaving); assert(pParent->pGroupBy == 0); pParent->pGroupBy = - sqlite3ExprListDup(db, pSub->pGroupBy, 0); + sql_expr_list_dup(db, pSub->pGroupBy, 0); } else { pParent->pWhere = sqlite3ExprAnd(db, pWhere, pParent->pWhere); @@ -4376,7 +4376,8 @@ convertCompoundSelectToSubquery(Walker * pWalker, Select * p) *pNew = *p; p->pSrc = pNewSrc; p->pEList = - sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db, TK_ASTERISK, 0)); + sql_expr_list_append(pParse->db, NULL, + sqlite3Expr(db, TK_ASTERISK, 0)); p->op = TK_SELECT; p->pWhere = 0; pNew->pGroupBy = 0; @@ -4817,7 +4818,7 @@ selectExpander(Walker * pWalker, Select * p) /* This particular expression does not need to be expanded. */ pNew = - sqlite3ExprListAppend(pParse, pNew, + sql_expr_list_append(pParse->db, pNew, a[k].pExpr); if (pNew) { pNew->a[pNew->nExpr - 1].zName = @@ -4922,7 +4923,10 @@ selectExpander(Walker * pWalker, Select * p) } else { pExpr = pRight; } - pNew = sqlite3ExprListAppend(pParse, pNew, pExpr); + pNew = + sql_expr_list_append( + pParse->db, + pNew, pExpr); sqlite3TokenInit(&sColname, zColname); sqlite3ExprListSetName(pParse, pNew, @@ -4964,7 +4968,7 @@ selectExpander(Walker * pWalker, Select * p) } } } - sqlite3ExprListDelete(db, pEList); + sql_expr_list_delete(db, pEList); p->pEList = pNew; } #if SQLITE_MAX_COLUMN @@ -5367,7 +5371,7 @@ sqlite3Select(Parse * pParse, /* The parser context */ /* If ORDER BY makes no difference in the output then neither does * DISTINCT so it can be removed too. */ - sqlite3ExprListDelete(db, p->pOrderBy); + sql_expr_list_delete(db, p->pOrderBy); p->pOrderBy = 0; p->selFlags &= ~SF_Distinct; } @@ -5614,7 +5618,7 @@ sqlite3Select(Parse * pParse, /* The parser context */ if ((p->selFlags & (SF_Distinct | SF_Aggregate)) == SF_Distinct && sqlite3ExprListCompare(sSort.pOrderBy, pEList, -1) == 0) { p->selFlags &= ~SF_Distinct; - pGroupBy = p->pGroupBy = sqlite3ExprListDup(db, pEList, 0); + pGroupBy = p->pGroupBy = sql_expr_list_dup(db, pEList, 0); /* Notice that even thought SF_Distinct has been cleared from p->selFlags, * the sDistinct.isTnct is still set. Hence, isTnct represents the * original setting of the SF_Distinct flag, not the current setting @@ -6165,7 +6169,7 @@ sqlite3Select(Parse * pParse, /* The parser context */ if (flag) { pMinMax = - sqlite3ExprListDup(db, pMinMax, 0); + sql_expr_list_dup(db, pMinMax, 0); pDel = pMinMax; assert(db->mallocFailed || pMinMax != 0); @@ -6187,7 +6191,7 @@ sqlite3Select(Parse * pParse, /* The parser context */ sqlite3WhereBegin(pParse, pTabList, pWhere, pMinMax, 0, flag, 0); if (pWInfo == 0) { - sqlite3ExprListDelete(db, pDel); + sql_expr_list_delete(db, pDel); goto select_end; } updateAccumulator(pParse, &sAggInfo); @@ -6203,7 +6207,7 @@ sqlite3Select(Parse * pParse, /* The parser context */ } sqlite3WhereEnd(pWInfo); finalizeAggFunctions(pParse, &sAggInfo); - sqlite3ExprListDelete(db, pDel); + sql_expr_list_delete(db, pDel); } sSort.pOrderBy = 0; diff --git a/src/box/sql/sqliteInt.h b/src/box/sql/sqliteInt.h index a1a5269..5746cb4 100644 --- a/src/box/sql/sqliteInt.h +++ b/src/box/sql/sqliteInt.h @@ -3487,7 +3487,6 @@ void sqlite3PExprAddSelect(Parse *, Expr *, Select *); Expr *sqlite3ExprAnd(sqlite3 *, Expr *, Expr *); Expr *sqlite3ExprFunction(Parse *, ExprList *, Token *); void sqlite3ExprAssignVarNumber(Parse *, Expr *, u32); -ExprList *sqlite3ExprListAppend(Parse *, ExprList *, Expr *); ExprList *sqlite3ExprListAppendVector(Parse *, ExprList *, IdList *, Expr *); /** @@ -3500,7 +3499,6 @@ void sqlite3ExprListSetSortOrder(ExprList *, enum sort_order sort_order); void sqlite3ExprListSetName(Parse *, ExprList *, Token *, int); void sqlite3ExprListSetSpan(Parse *, ExprList *, ExprSpan *); -void sqlite3ExprListDelete(sqlite3 *, ExprList *); u32 sqlite3ExprListFlags(const ExprList *); int sqlite3Init(sqlite3 *); int sqlite3InitCallback(void *, int, char **, char **); @@ -4004,7 +4002,6 @@ void sqlite3MayAbort(Parse *); void sqlite3HaltConstraint(Parse *, int, int, char *, i8, u8); void sqlite3UniqueConstraint(Parse *, int, Index *); Expr *sqlite3ExprDup(sqlite3 *, Expr *, int); -ExprList *sqlite3ExprListDup(sqlite3 *, ExprList *, int); SrcList *sqlite3SrcListDup(sqlite3 *, SrcList *, int); IdList *sqlite3IdListDup(sqlite3 *, IdList *); Select *sqlite3SelectDup(sqlite3 *, Select *, int); @@ -4225,7 +4222,6 @@ int sqlite3MatchSpanName(const char *, const char *, const char *); int sqlite3ResolveExprNames(NameContext *, Expr *); int sqlite3ResolveExprListNames(NameContext *, ExprList *); void sqlite3ResolveSelectNames(Parse *, Select *, NameContext *); -void sqlite3ResolveSelfReference(Parse *, Table *, int, Expr *, ExprList *); int sqlite3ResolveOrderGroupBy(Parse *, Select *, ExprList *, const char *); /** diff --git a/src/box/sql/trigger.c b/src/box/sql/trigger.c index 2704816..27902fd 100644 --- a/src/box/sql/trigger.c +++ b/src/box/sql/trigger.c @@ -53,7 +53,7 @@ sqlite3DeleteTriggerStep(sqlite3 * db, TriggerStep * pTriggerStep) pTriggerStep = pTriggerStep->pNext; sql_expr_delete(db, pTmp->pWhere, false); - sqlite3ExprListDelete(db, pTmp->pExprList); + sql_expr_list_delete(db, pTmp->pExprList); sqlite3SelectDelete(db, pTmp->pSelect); sqlite3IdListDelete(db, pTmp->pIdList); @@ -438,12 +438,12 @@ sqlite3TriggerUpdateStep(sqlite3 * db, /* The database connection */ pTriggerStep = triggerStepAllocate(db, TK_UPDATE, pTableName); if (pTriggerStep) { pTriggerStep->pExprList = - sqlite3ExprListDup(db, pEList, EXPRDUP_REDUCE); + sql_expr_list_dup(db, pEList, EXPRDUP_REDUCE); pTriggerStep->pWhere = sqlite3ExprDup(db, pWhere, EXPRDUP_REDUCE); pTriggerStep->orconf = orconf; } - sqlite3ExprListDelete(db, pEList); + sql_expr_list_delete(db, pEList); sql_expr_delete(db, pWhere, false); return pTriggerStep; } @@ -723,7 +723,7 @@ codeTriggerProgram(Parse * pParse, /* The parser context */ case TK_UPDATE:{ sqlite3Update(pParse, targetSrcList(pParse, pStep), - sqlite3ExprListDup(db, + sql_expr_list_dup(db, pStep-> pExprList, 0), sqlite3ExprDup(db, pStep->pWhere, diff --git a/src/box/sql/update.c b/src/box/sql/update.c index 848ae20..590aad2 100644 --- a/src/box/sql/update.c +++ b/src/box/sql/update.c @@ -642,7 +642,7 @@ sqlite3Update(Parse * pParse, /* The parser context */ update_cleanup: sqlite3DbFree(db, aXRef); /* Also frees aRegIdx[] and aToOpen[] */ sqlite3SrcListDelete(db, pTabList); - sqlite3ExprListDelete(db, pChanges); + sql_expr_list_delete(db, pChanges); sql_expr_delete(db, pWhere, false); return; } diff --git a/src/box/sql/wherecode.c b/src/box/sql/wherecode.c index 8b0f21a..9fb3f18 100644 --- a/src/box/sql/wherecode.c +++ b/src/box/sql/wherecode.c @@ -511,11 +511,11 @@ codeEqualityTerm(Parse * pParse, /* The parsing context */ pExpr, 0); pRhs = - sqlite3ExprListAppend(pParse, pRhs, - pNewRhs); + sql_expr_list_append(pParse->db, + pRhs, pNewRhs); pLhs = - sqlite3ExprListAppend(pParse, pLhs, - pNewLhs); + sql_expr_list_append(pParse->db, + pLhs, pNewLhs); } } if (!db->mallocFailed) { @@ -562,8 +562,8 @@ codeEqualityTerm(Parse * pParse, /* The parsing context */ pLeft->x.pList = pOrigLhs; pX->pLeft = pLeft; } - sqlite3ExprListDelete(pParse->db, pLhs); - sqlite3ExprListDelete(pParse->db, pRhs); + sql_expr_list_delete(pParse->db, pLhs); + sql_expr_list_delete(pParse->db, pRhs); } if (eType == IN_INDEX_INDEX_DESC) { diff --git a/src/box/sql/whereexpr.c b/src/box/sql/whereexpr.c index 6da2762..d5a5b07 100644 --- a/src/box/sql/whereexpr.c +++ b/src/box/sql/whereexpr.c @@ -784,8 +784,8 @@ exprAnalyzeOrTerm(SrcList * pSrc, /* the FROM clause */ sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0); pList = - sqlite3ExprListAppend(pWInfo->pParse, pList, - pDup); + sql_expr_list_append(pWInfo->pParse->db, + pList, pDup); pLeft = pOrTerm->pExpr->pLeft; } assert(pLeft != 0); @@ -805,7 +805,7 @@ exprAnalyzeOrTerm(SrcList * pSrc, /* the FROM clause */ pTerm = &pWC->a[idxTerm]; markTermAsChild(pWC, idxNew, idxTerm); } else { - sqlite3ExprListDelete(db, pList); + sql_expr_list_delete(db, pList); } pTerm->eOperator = WO_NOOP; /* case 1 trumps case 3 */ } -- 2.7.4