From: Alexey Zavodchenkov <zavodchen@gmail.com>
To: tarantool-patches@freelists.org
Cc: Alexey Zavodchenkov <zavodchen@gmail.com>
Subject: [tarantool-patches] [PATCH 2/2] Group assertions and move them out of functions
Date: Fri, 30 Aug 2019 18:48:01 +0300 [thread overview]
Message-ID: <a6e62b9f935c16bd88e30aef0c4255e4d315a3c7.1567178109.git.zavodchen@gmail.com> (raw)
In-Reply-To: <cover.1567178109.git.zavodchen@gmail.com>
---
src/box/sql/expr.c | 95 +++++++++++------------------------------
src/box/sql/vdbe.c | 40 +++++++----------
src/box/sql/whereexpr.c | 28 ++++--------
3 files changed, 50 insertions(+), 113 deletions(-)
diff --git a/src/box/sql/expr.c b/src/box/sql/expr.c
index 668562896..de356d29b 100644
--- a/src/box/sql/expr.c
+++ b/src/box/sql/expr.c
@@ -3669,6 +3669,31 @@ exprCodeVector(Parse * pParse, Expr * p, int *piFreeable)
return iResult;
}
+/*
+ * static asserts for sqlExprCodeTarget, sqlExprIfTrue and sqlExprIfFalse
+ */
+static_assert(TK_LT == OP_Lt, "inconsistent token/opcode definition");
+static_assert(TK_LE == OP_Le, "inconsistent token/opcode definition");
+static_assert(TK_GT == OP_Gt, "inconsistent token/opcode definition");
+static_assert(TK_GE == OP_Ge, "inconsistent token/opcode definition");
+static_assert(TK_EQ == OP_Eq, "inconsistent token/opcode definition");
+static_assert(TK_NE == OP_Ne, "inconsistent token/opcode definition");
+static_assert(TK_AND == OP_And, "inconsistent token/opcode definition");
+static_assert(TK_OR == OP_Or, "inconsistent token/opcode definition");
+static_assert(TK_PLUS == OP_Add, "inconsistent token/opcode definition");
+static_assert(TK_MINUS == OP_Subtract, "inconsistent token/opcode definition");
+static_assert(TK_REM == OP_Remainder, "inconsistent token/opcode definition");
+static_assert(TK_BITAND == OP_BitAnd, "inconsistent token/opcode definition");
+static_assert(TK_BITOR == OP_BitOr, "inconsistent token/opcode definition");
+static_assert(TK_SLASH == OP_Divide, "inconsistent token/opcode definition");
+static_assert(TK_LSHIFT == OP_ShiftLeft, "inconsistent token/opcode definition");
+static_assert(TK_RSHIFT == OP_ShiftRight, "inconsistent token/opcode definition");
+static_assert(TK_CONCAT == OP_Concat, "inconsistent token/opcode definition");
+static_assert(TK_BITNOT == OP_BitNot, "inconsistent token/opcode definition");
+static_assert(TK_NOT == OP_Not, "inconsistent token/opcode definition");
+static_assert(TK_ISNULL == OP_IsNull, "inconsistent token/opcode definition");
+static_assert(TK_NOTNULL == OP_NotNull, "inconsistent token/opcode definition");
+
/*
* Generate code into the current Vdbe to evaluate the given
* expression. Attempt to store the results in register "target".
@@ -3839,28 +3864,16 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target)
®Free2);
codeCompare(pParse, pLeft, pExpr->pRight, op,
r1, r2, inReg, SQL_STOREP2);
- static_assert(TK_LT == OP_Lt,
- "inconsistent token/opcode definition");
testcase(op == OP_Lt);
VdbeCoverageIf(v, op == OP_Lt);
- static_assert(TK_LE == OP_Le,
- "inconsistent token/opcode definition");
testcase(op == OP_Le);
VdbeCoverageIf(v, op == OP_Le);
- static_assert(TK_GT == OP_Gt,
- "inconsistent token/opcode definition");
testcase(op == OP_Gt);
VdbeCoverageIf(v, op == OP_Gt);
- static_assert(TK_GE == OP_Ge,
- "inconsistent token/opcode definition");
testcase(op == OP_Ge);
VdbeCoverageIf(v, op == OP_Ge);
- static_assert(TK_EQ == OP_Eq,
- "inconsistent token/opcode definition");
testcase(op == OP_Eq);
VdbeCoverageIf(v, op == OP_Eq);
- static_assert(TK_NE == OP_Ne,
- "inconsistent token/opcode definition");
testcase(op == OP_Ne);
VdbeCoverageIf(v, op == OP_Ne);
testcase(regFree1 == 0);
@@ -3880,38 +3893,16 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target)
case TK_LSHIFT:
case TK_RSHIFT:
case TK_CONCAT:{
- static_assert(TK_AND == OP_And,
- "inconsistent token/opcode definition");
testcase(op == TK_AND);
- static_assert(TK_OR == OP_Or,
- "inconsistent token/opcode definition");
testcase(op == TK_OR);
- static_assert(TK_PLUS == OP_Add,
- "inconsistent token/opcode definition");
testcase(op == TK_PLUS);
- static_assert(TK_MINUS == OP_Subtract,
- "inconsistent token/opcode definition");
testcase(op == TK_MINUS);
- static_assert(TK_REM == OP_Remainder,
- "inconsistent token/opcode definition");
testcase(op == TK_REM);
- static_assert(TK_BITAND == OP_BitAnd,
- "inconsistent token/opcode definition");
testcase(op == TK_BITAND);
- static_assert(TK_BITOR == OP_BitOr,
- "inconsistent token/opcode definition");
testcase(op == TK_BITOR);
- static_assert(TK_SLASH == OP_Divide,
- "inconsistent token/opcode definition");
testcase(op == TK_SLASH);
- static_assert(TK_LSHIFT == OP_ShiftLeft,
- "inconsistent token/opcode definition");
testcase(op == TK_LSHIFT);
- static_assert(TK_RSHIFT == OP_ShiftRight,
- "inconsistent token/opcode definition");
testcase(op == TK_RSHIFT);
- static_assert(TK_CONCAT == OP_Concat,
- "inconsistent token/opcode definition");
testcase(op == TK_CONCAT);
r1 = sqlExprCodeTemp(pParse, pExpr->pLeft,
®Free1);
@@ -3948,11 +3939,7 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target)
}
case TK_BITNOT:
case TK_NOT:{
- static_assert(TK_BITNOT == OP_BitNot,
- "inconsistent token/opcode definition");
testcase(op == TK_BITNOT);
- static_assert(TK_NOT == OP_Not,
- "inconsistent token/opcode definition");
testcase(op == TK_NOT);
r1 = sqlExprCodeTemp(pParse, pExpr->pLeft,
®Free1);
@@ -3963,11 +3950,7 @@ sqlExprCodeTarget(Parse * pParse, Expr * pExpr, int target)
case TK_ISNULL:
case TK_NOTNULL:{
int addr;
- static_assert(TK_ISNULL == OP_IsNull,
- "inconsistent token/opcode definition");
testcase(op == TK_ISNULL);
- static_assert(TK_NOTNULL == OP_NotNull,
- "inconsistent token/opcode definition");
testcase(op == TK_NOTNULL);
sqlVdbeAddOp2(v, OP_Bool, true, target);
r1 = sqlExprCodeTemp(pParse, pExpr->pLeft,
@@ -4780,31 +4763,19 @@ sqlExprIfTrue(Parse * pParse, Expr * pExpr, int dest, int jumpIfNull)
®Free2);
codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, r1,
r2, dest, jumpIfNull);
- static_assert(TK_LT == OP_Lt,
- "inconsistent token/opcode definition");
testcase(op == OP_Lt);
VdbeCoverageIf(v, op == OP_Lt);
- static_assert(TK_LE == OP_Le,
- "inconsistent token/opcode definition");
testcase(op == OP_Le);
VdbeCoverageIf(v, op == OP_Le);
- static_assert(TK_GT == OP_Gt,
- "inconsistent token/opcode definition");
testcase(op == OP_Gt);
VdbeCoverageIf(v, op == OP_Gt);
- static_assert(TK_GE == OP_Ge,
- "inconsistent token/opcode definition");
testcase(op == OP_Ge);
VdbeCoverageIf(v, op == OP_Ge);
- static_assert(TK_EQ == OP_Eq,
- "inconsistent token/opcode definition");
testcase(op == OP_Eq);
VdbeCoverageIf(v, op == OP_Eq
&& jumpIfNull == SQL_NULLEQ);
VdbeCoverageIf(v, op == OP_Eq
&& jumpIfNull != SQL_NULLEQ);
- static_assert(TK_NE == OP_Ne,
- "inconsistent token/opcode definition");
testcase(op == OP_Ne);
VdbeCoverageIf(v, op == OP_Ne
&& jumpIfNull == SQL_NULLEQ);
@@ -4816,11 +4787,7 @@ sqlExprIfTrue(Parse * pParse, Expr * pExpr, int dest, int jumpIfNull)
}
case TK_ISNULL:
case TK_NOTNULL:{
- static_assert(TK_ISNULL == OP_IsNull,
- "inconsistent token/opcode definition");
testcase(op == TK_ISNULL);
- static_assert(TK_NOTNULL == OP_NotNull,
- "inconsistent token/opcode definition");
testcase(op == TK_NOTNULL);
r1 = sqlExprCodeTemp(pParse, pExpr->pLeft,
®Free1);
@@ -4981,31 +4948,19 @@ sqlExprIfFalse(Parse * pParse, Expr * pExpr, int dest, int jumpIfNull)
®Free2);
codeCompare(pParse, pExpr->pLeft, pExpr->pRight, op, r1,
r2, dest, jumpIfNull);
- static_assert(TK_LT == OP_Lt,
- "inconsistent token/opcode definition");
testcase(op == OP_Lt);
VdbeCoverageIf(v, op == OP_Lt);
- static_assert(TK_LE == OP_Le,
- "inconsistent token/opcode definition");
testcase(op == OP_Le);
VdbeCoverageIf(v, op == OP_Le);
- static_assert(TK_GT == OP_Gt,
- "inconsistent token/opcode definition");
testcase(op == OP_Gt);
VdbeCoverageIf(v, op == OP_Gt);
- static_assert(TK_GE == OP_Ge,
- "inconsistent token/opcode definition");
testcase(op == OP_Ge);
VdbeCoverageIf(v, op == OP_Ge);
- static_assert(TK_EQ == OP_Eq,
- "inconsistent token/opcode definition");
testcase(op == OP_Eq);
VdbeCoverageIf(v, op == OP_Eq
&& jumpIfNull != SQL_NULLEQ);
VdbeCoverageIf(v, op == OP_Eq
&& jumpIfNull == SQL_NULLEQ);
- static_assert(TK_NE == OP_Ne,
- "inconsistent token/opcode definition");
testcase(op == OP_Ne);
VdbeCoverageIf(v, op == OP_Ne
&& jumpIfNull != SQL_NULLEQ);
diff --git a/src/box/sql/vdbe.c b/src/box/sql/vdbe.c
index 8560e51a1..414b89272 100644
--- a/src/box/sql/vdbe.c
+++ b/src/box/sql/vdbe.c
@@ -743,6 +743,20 @@ vdbe_field_ref_fetch(struct vdbe_field_ref *field_ref, uint32_t fieldno,
return 0;
}
+/*
+ * static asserts for sqlVdbeExec
+ */
+static_assert(OP_ShiftRight==OP_ShiftLeft+1, "inconsistent opcode definition");
+static_assert(OP_SeekLE == OP_SeekLT+1, "inconsistent opcode definition");
+static_assert(OP_SeekGE == OP_SeekLT+2, "inconsistent opcode definition");
+static_assert(OP_SeekGT == OP_SeekGE+1, "inconsistent opcode definition");
+static_assert((OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001),
+ "inconsistent opcode definition");
+static_assert((OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001),
+ "inconsistent opcode definition");
+static_assert((OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1),
+ "inconsistent opcode definition");
+
/*
* Execute as much of a VDBE program as we can.
* This is the core of sql_step().
@@ -1847,8 +1861,6 @@ case OP_ShiftRight: { /* same as TK_RSHIFT, in1, in2, out3 */
/* If shifting by a negative amount, shift in the other direction */
if (iB<0) {
- static_assert(OP_ShiftRight==OP_ShiftLeft+1,
- "inconsistent opcode definition");
op = 2*OP_ShiftLeft + 1 - op;
iB = iB>(-64) ? -iB : 64;
}
@@ -3281,12 +3293,6 @@ case OP_SeekGT: { /* jump, in3 */
pC = p->apCsr[pOp->p1];
assert(pC!=0);
assert(pC->eCurType==CURTYPE_TARANTOOL);
- static_assert(OP_SeekLE == OP_SeekLT+1,
- "inconsistent opcode definition");
- static_assert(OP_SeekGE == OP_SeekLT+2,
- "inconsistent opcode definition");
- static_assert(OP_SeekGT == OP_SeekLT+3,
- "inconsistent opcode definition");
assert(pC->uc.pCursor!=0);
oc = pOp->opcode;
eqOnly = 0;
@@ -3355,26 +3361,14 @@ case OP_SeekGT: { /* jump, in3 */
* (x > 4.9) -> (x >= 5)
* (x <= 4.9) -> (x < 5)
*/
- if (pIn3->u.r<(double)iKey) {
- static_assert(OP_SeekGE==(OP_SeekGT-1),
- "inconsistent opcode definition");
- static_assert(OP_SeekLT==(OP_SeekLE-1),
- "inconsistent opcode definition");
- static_assert((OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001),
- "inconsistent opcode definition");
+ if (pIn3->u.r < (double)iKey) {
if ((oc & 0x0001)==(OP_SeekGT & 0x0001)) oc--;
}
/* If the approximation iKey is smaller than the actual real search
* term, substitute <= for < and > for >=.
*/
- else if (pIn3->u.r>(double)iKey) {
- static_assert(OP_SeekLE==(OP_SeekLT+1),
- "inconsistent opcode definition");
- static_assert(OP_SeekGT==(OP_SeekGE+1),
- "inconsistent opcode definition");
- static_assert((OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001),
- "inconsistent opcode definition");
+ else if (pIn3->u.r > (double)iKey) {
if ((oc & 0x0001)==(OP_SeekLT & 0x0001)) oc++;
}
}
@@ -4539,8 +4533,6 @@ case OP_IdxGE: { /* jump */
{ int i; for(i=0; i<r.nField; i++) assert(memIsValid(&r.aMem[i])); }
#endif
int res = tarantoolsqlIdxKeyCompare(pC->uc.pCursor, &r);
- static_assert((OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1),
- "inconsistent opcode definition");
if ((pOp->opcode&1)==(OP_IdxLT&1)) {
assert(pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT);
res = -res;
diff --git a/src/box/sql/whereexpr.c b/src/box/sql/whereexpr.c
index 2d29c0bc7..3b7d51f80 100644
--- a/src/box/sql/whereexpr.c
+++ b/src/box/sql/whereexpr.c
@@ -124,6 +124,15 @@ whereClauseInsert(WhereClause * pWC, Expr * p, u16 wtFlags)
return idx;
}
+/*
+ * static asserts for allowedOp, exprCommute, exprMightBeIndexed
+ */
+static_assert(TK_GE == TK_EQ + 4, "inconsistent token definition");
+static_assert(TK_LT == TK_GT + 2, "inconsistent token definition");
+static_assert(TK_LE == TK_GT + 1, "inconsistent token definition");
+static_assert(TK_GE == TK_LE + 2, "inconsistent token definition");
+static_assert(TK_IN < TK_GE, "inconsistent token definition");
+
/*
* Return TRUE if the given operator is one of the operators that is
* allowed for an indexable WHERE clause term. The allowed operators are
@@ -132,14 +141,6 @@ whereClauseInsert(WhereClause * pWC, Expr * p, u16 wtFlags)
static int
allowedOp(int op)
{
- static_assert(TK_GT > TK_EQ && TK_GT < TK_GE,
- "inconsistent token definition");
- static_assert(TK_LT > TK_EQ && TK_LT < TK_GE,
- "inconsistent token definition");
- static_assert(TK_LE > TK_EQ && TK_LE < TK_GE,
- "inconsistent token definition");
- static_assert(TK_GE == TK_EQ + 4,
- "inconsistent token definition");
return op == TK_IN || (op >= TK_EQ && op <= TK_GE) || op == TK_ISNULL;
}
@@ -190,14 +191,6 @@ exprCommute(Parse * pParse, Expr * pExpr)
}
SWAP(pExpr->pRight, pExpr->pLeft);
if (pExpr->op >= TK_GT) {
- static_assert(TK_LT == TK_GT + 2,
- "inconsistent token definition");
- static_assert(TK_GE == TK_LE + 2,
- "inconsistent token definition");
- static_assert(TK_GT > TK_EQ,
- "inconsistent token definition");
- static_assert(TK_GT < TK_LE,
- "inconsistent token definition");
assert(pExpr->op >= TK_GT && pExpr->op <= TK_GE);
pExpr->op = ((pExpr->op - TK_GT) ^ 2) + TK_GT;
}
@@ -953,9 +946,6 @@ exprMightBeIndexed(int op, /* The specific comparison operator */
* inequality constraint (>, <, >= or <=), perform the processing
* on the first element of the vector.
*/
- static_assert(TK_GT + 1 == TK_LE && TK_GT + 2 == TK_LT && TK_GT + 3 == TK_GE,
- "inconsistent token definition");
- static_assert(TK_IN < TK_GE, "inconsistent token definition");
assert(op <= TK_GE || op == TK_ISNULL || op == TK_NOTNULL);
if (pExpr->op == TK_VECTOR && (op >= TK_GT && op <= TK_GE)) {
pExpr = pExpr->x.pList->a[0].pExpr;
--
2.21.0
next prev parent reply other threads:[~2019-08-30 15:48 UTC|newest]
Thread overview: 6+ messages / expand[flat|nested] mbox.gz Atom feed top
2019-08-23 15:49 [tarantool-patches] [PATCH] sql: Change token/opcode relation assertions to static Alexey Zavodchenkov
2019-08-27 16:40 ` [tarantool-patches] " n.pettik
2019-08-30 15:47 ` [tarantool-patches] [PATCH 0/2] " Alexey Zavodchenkov
2019-08-30 15:48 ` [tarantool-patches] [PATCH 1/2] sql: Change token/opcode relative positions assertion " Alexey Zavodchenkov
2019-08-30 15:48 ` Alexey Zavodchenkov [this message]
2019-09-10 23:14 ` [tarantool-patches] Re: [PATCH 2/2] Group assertions and move them out of functions Nikita Pettik
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=a6e62b9f935c16bd88e30aef0c4255e4d315a3c7.1567178109.git.zavodchen@gmail.com \
--to=zavodchen@gmail.com \
--cc=tarantool-patches@freelists.org \
--subject='Re: [tarantool-patches] [PATCH 2/2] Group assertions and move them out of functions' \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox