From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from [87.239.111.99] (localhost [127.0.0.1]) by dev.tarantool.org (Postfix) with ESMTP id BB1246BD34; Tue, 23 Mar 2021 12:43:48 +0300 (MSK) DKIM-Filter: OpenDKIM Filter v2.11.0 dev.tarantool.org BB1246BD34 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=tarantool.org; s=dev; t=1616492628; bh=46WwvuY7WsRpSPytVGcr41YmoWLcgJcU6N1lP9TGjiU=; h=To:Cc:Date:In-Reply-To:References:Subject:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=lgmKyha34cYecPzpwwsrrBEyVC/rDp81PxldfLU/ktr0U9AtYHgQCCm+WpYF3I1So N4UOhe2t+RdJdfwVNBbIxj0ZMRn5gI1ipLp42VFSX50HWS75RQqLBtQ/pChKRMNBIc ZGPpiVmp5hRFiIJeTt6EpuDNn5ek+Ct2Af2+sjLk= Received: from smtp53.i.mail.ru (smtp53.i.mail.ru [94.100.177.113]) (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 44A5868F47 for ; Tue, 23 Mar 2021 12:35:33 +0300 (MSK) DKIM-Filter: OpenDKIM Filter v2.11.0 dev.tarantool.org 44A5868F47 Received: by smtp53.i.mail.ru with esmtpa (envelope-from ) id 1lOdRk-0002ew-DE; Tue, 23 Mar 2021 12:35:32 +0300 To: v.shpilevoy@tarantool.org, tsafin@tarantool.org Cc: tarantool-patches@dev.tarantool.org Date: Tue, 23 Mar 2021 12:35:32 +0300 Message-Id: <3f1a796a92670c57203c5a6c7d1b47856db96917.1616491731.git.imeevma@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-7564579A: 78E4E2B564C1792B X-77F55803: 4F1203BC0FB41BD95D6E7CC48CB1F5F19D4B90E2C0E110A6B701D7D268243E19182A05F538085040454D8452B0AA34FF651442A161C283012906B7D6D3B4485FA3114DBD27FD8210 X-7FA49CB5: FF5795518A3D127A4AD6D5ED66289B5278DA827A17800CE7FBCED7D376B82B5EEA1F7E6F0F101C67BD4B6F7A4D31EC0BCC500DACC3FED6E28638F802B75D45FF8AA50765F79006378B6D775AC58C227F8638F802B75D45FF914D58D5BE9E6BC131B5C99E7648C95C686AF563A045C75EC227A58D7F46C94954C4C222CD96E835A471835C12D1D9774AD6D5ED66289B5259CC434672EE6371117882F4460429724CE54428C33FAD30A8DF7F3B2552694AC26CFBAC0749D213D2E47CDBA5A9658378DA827A17800CE71AE4D56B06699BBC9FA2833FD35BB23DF004C90652538430302FCEF25BFAB3454AD6D5ED66289B5278DA827A17800CE7AA7A4EF0F5BEAA0CD32BA5DBAC0009BE395957E7521B51C20BC6067A898B09E4090A508E0FED629923F8577A6DFFEA7C6386F4032A53F176CD04E86FAF290E2D7E9C4E3C761E06A71DD303D21008E29813377AFFFEAFD269A417C69337E82CC2E827F84554CEF5012EF20D2F80756B5F868A13BD56FB6657A7F4EDE966BC389F9E8FC8737B5C2249D635BA3ABDB36C18089D37D7C0E48F6CCF19DD082D7633A0E7DDDDC251EA7DABAAAE862A0553A39223F8577A6DFFEA7CB59C7783CC88FA9643847C11F186F3C5E7DDDDC251EA7DABCC89B49CDF41148FBC2A4A7A8370ED8B3C9F3DD0FB1AF5EB4E70A05D1297E1BBCB5012B2E24CD356 X-B7AD71C0: AC4F5C86D027EB782CDD5689AFBDA7A24A6D60772A99906F8E1CD14B953EB46D2E956CD40F9E01CB355D89D7DBCDD132 X-C1DE0DAB: C20DE7B7AB408E4181F030C43753B8186998911F362727C414F749A5E30D975C686AF563A045C75EC227A58D7F46C94954C4C222CD96E8359C2B6934AE262D3EE7EAB7254005DCED7532B743992DF240BDC6A1CF3F042BAD6DF99611D93F60EF0417BEADF48D1460699F904B3F4130E343918A1A30D5E7FCCB5012B2E24CD356 X-C8649E89: 4E36BF7865823D7055A7F0CF078B5EC49A30900B95165D349FD10E01B3CDC9E2F694B01559A39E299F1F56574F7146DDBFE26E9041BD6EB823C35FD3E955498B1D7E09C32AA3244CE390982CA8E837A280525839BE0D35C1F522A1CF68F4BE05FACE5A9C96DEB163 X-D57D3AED: 3ZO7eAau8CL7WIMRKs4sN3D3tLDjz0dLbV79QFUyzQ2Ujvy7cMT6pYYqY16iZVKkSc3dCLJ7zSJH7+u4VD18S7Vl4ZUrpaVfd2+vE6kuoey4m4VkSEu530nj6fImhcD4MUrOEAnl0W826KZ9Q+tr5ycPtXkTV4k65bRjmOUUP8cvGozZ33TWg5HZplvhhXbhDGzqmQDTd6OAevLeAnq3Ra9uf7zvY2zzsIhlcp/Y7m53TZgf2aB4JOg4gkr2biojWJZv20R+6UgSG5lqJuZICQ== X-Mailru-Sender: 5C3750E245F362008BC1685FEC6306EDCC50A73D1C90373B651442A161C2830152685D71546B8E9E5105BD0848736F9966FEC6BF5C9C28D97E07721503EA2E00ED97202A5A4E92BF7402F9BA4338D657ED14614B50AE0675 X-Mras: Ok Subject: [Tarantool-patches] [PATCH v4 18/53] sql: introduce mem_arithmetic() X-BeenThere: tarantool-patches@dev.tarantool.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Tarantool development patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , From: Mergen Imeev via Tarantool-patches Reply-To: imeevma@tarantool.org Errors-To: tarantool-patches-bounces@dev.tarantool.org Sender: "Tarantool-patches" This patch introduces mem_arithmetic(). Function mem_arithmetic() executes arithmetic operations on the first and the second MEMs and writes the result to the third MEM. Part of #5818 --- src/box/sql/mem.c | 224 +++++++++++++++++++++++++++++++++++++-------- src/box/sql/mem.h | 6 +- src/box/sql/vdbe.c | 111 +--------------------- 3 files changed, 193 insertions(+), 148 deletions(-) diff --git a/src/box/sql/mem.c b/src/box/sql/mem.c index f160439c9..6120939d8 100644 --- a/src/box/sql/mem.c +++ b/src/box/sql/mem.c @@ -370,6 +370,192 @@ mem_concat(struct Mem *left, struct Mem *right, struct Mem *result) return 0; } +int +mem_arithmetic(const struct Mem *left, const struct Mem *right, + struct Mem *result, int op) +{ + sqlVdbeMemSetNull(result); + result->field_type = FIELD_TYPE_NUMBER; + if (((left->flags | right->flags) & MEM_Null) != 0) + return 0; + + int64_t il; + bool is_l_neg; + double dl; + uint16_t type_left = 0; + if ((left->flags & MEM_Real) != 0) { + dl = left->u.r; + type_left = MEM_Real; + } else if ((left->flags & MEM_Int) != 0) { + il = left->u.i; + type_left = MEM_Int; + is_l_neg = true; + } else if ((left->flags & MEM_UInt) != 0) { + il = left->u.i; + type_left = MEM_UInt; + is_l_neg = false; + } else if ((left->flags & (MEM_Str | MEM_Blob)) != 0) { + if (sql_atoi64(left->z, &il, &is_l_neg, left->n) == 0) + type_left = is_l_neg ? MEM_Int : MEM_UInt; + else if (sqlAtoF(left->z, &dl, left->n) != 0) + type_left = MEM_Real; + } + + int64_t ir; + bool is_r_neg; + double dr; + uint16_t type_right = 0; + if ((right->flags & MEM_Real) != 0) { + dr = right->u.r; + type_right = MEM_Real; + } else if ((right->flags & MEM_Int) != 0) { + ir = right->u.i; + type_right = MEM_Int; + is_r_neg = true; + } else if ((right->flags & MEM_UInt) != 0) { + ir = right->u.i; + type_right = MEM_UInt; + is_r_neg = false; + } else if ((right->flags & (MEM_Str | MEM_Blob)) != 0) { + if (sql_atoi64(right->z, &ir, &is_r_neg, right->n) == 0) + type_right = is_r_neg ? MEM_Int : MEM_UInt; + else if (sqlAtoF(right->z, &dr, right->n) != 0) + type_right = MEM_Real; + } + + if ((type_right & (MEM_Int | MEM_UInt | MEM_Real)) == 0) { + diag_set(ClientError, ER_SQL_TYPE_MISMATCH, + mem_str(right), "numeric"); + return -1; + } + if ((type_left & (MEM_Int | MEM_UInt | MEM_Real)) == 0) { + diag_set(ClientError, ER_SQL_TYPE_MISMATCH, + mem_str(left), "numeric"); + return -1; + } + if (((type_left | type_right) & MEM_Real) != 0) { + if (type_left == MEM_Int) + dl = (double)il; + else if (type_left == MEM_UInt) + dl = (double)(uint64_t)il; + + if (type_right == MEM_Int) + dr = (double)ir; + else if (type_right == MEM_UInt) + dr = (double)(uint64_t)ir; + + double dres; + switch(op) { + case OP_Add: + dres = dl + dr; + break; + case OP_Subtract: + dres = dl - dr; + break; + case OP_Multiply: + dres = dl * dr; + break; + case OP_Divide: + if (dr == 0.) { + diag_set(ClientError, ER_SQL_EXECUTE, + "division by zero"); + return -1; + } + dres = dl / dr; + break; + case OP_Remainder: { + int64_t il = (int64_t)dl; + int64_t ir = (int64_t)dr; + if (ir == 0) { + diag_set(ClientError, ER_SQL_EXECUTE, + "division by zero"); + return -1; + } + if (ir == -1) + ir = 1; + dres = (double)(il % ir); + break; + } + default: + unreachable(); + } + if (sqlIsNaN(dres)) + return 0; + result->u.r = dres; + result->flags = MEM_Real; + return 0; + } + int64_t ires; + /* + * TODO: This is wrong. Both these flags should already be set. This + * assignment done to not change behaviour of the function, which + * is currently bugged. + */ + is_l_neg = (left->flags & MEM_Int) != 0; + is_r_neg = (right->flags & MEM_Int) != 0; + bool is_res_neg; + switch(op) { + case OP_Add: + if (sql_add_int(il, is_l_neg, ir, is_r_neg, &ires, + &is_res_neg) != 0) { + diag_set(ClientError, ER_SQL_EXECUTE, + "integer is overflowed"); + return -1; + } + break; + case OP_Subtract: + if (sql_sub_int(il, is_l_neg, ir, is_r_neg, &ires, + &is_res_neg) != 0) { + diag_set(ClientError, ER_SQL_EXECUTE, + "integer is overflowed"); + return -1; + } + break; + case OP_Multiply: + if (sql_mul_int(il, is_l_neg, ir, is_r_neg, &ires, + &is_res_neg) != 0) { + diag_set(ClientError, ER_SQL_EXECUTE, + "integer is overflowed"); + return -1; + } + break; + case OP_Divide: + if (ir == 0) { + diag_set(ClientError, ER_SQL_EXECUTE, + "division by zero"); + return -1; + } + if (sql_div_int(il, is_l_neg, ir, is_r_neg, &ires, + &is_res_neg) != 0) { + diag_set(ClientError, ER_SQL_EXECUTE, + "integer is overflowed"); + return -1; + } + break; + case OP_Remainder: { + if (ir == 0) { + diag_set(ClientError, ER_SQL_EXECUTE, + "division by zero"); + return -1; + } + if (ir == -1) + ir = 1; + if (sql_rem_int(il, is_l_neg, ir, is_r_neg, &ires, + &is_res_neg) != 0) { + diag_set(ClientError, ER_SQL_EXECUTE, + "integer is overflowed"); + return -1; + } + break; + } + default: + unreachable(); + } + result->u.i = ires; + result->flags = is_res_neg ? MEM_Int : MEM_UInt; + return 0; +} + static inline bool mem_has_msgpack_subtype(struct Mem *mem) { @@ -574,44 +760,6 @@ sql_value_type(sql_value *pVal) return mem_mp_type(mem); } - -/* - * pMem currently only holds a string type (or maybe a BLOB that we can - * interpret as a string if we want to). Compute its corresponding - * numeric type, if has one. Set the pMem->u.r and pMem->u.i fields - * accordingly. - */ -static u16 SQL_NOINLINE -computeNumericType(Mem *pMem) -{ - assert((pMem->flags & (MEM_Int | MEM_UInt | MEM_Real)) == 0); - assert((pMem->flags & (MEM_Str|MEM_Blob))!=0); - if (sqlAtoF(pMem->z, &pMem->u.r, pMem->n)==0) - return 0; - bool is_neg; - if (sql_atoi64(pMem->z, (int64_t *) &pMem->u.i, &is_neg, pMem->n) == 0) - return is_neg ? MEM_Int : MEM_UInt; - return MEM_Real; -} - -/* - * Return the numeric type for pMem, either MEM_Int or MEM_Real or both or - * none. - * - * Unlike mem_apply_numeric_type(), this routine does not modify pMem->flags. - * But it does set pMem->u.r and pMem->u.i appropriately. - */ -u16 -numericType(Mem *pMem) -{ - if ((pMem->flags & (MEM_Int | MEM_UInt | MEM_Real)) != 0) - return pMem->flags & (MEM_Int | MEM_UInt | MEM_Real); - if (pMem->flags & (MEM_Str|MEM_Blob)) { - return computeNumericType(pMem); - } - return 0; -} - /* * The sqlValueBytes() routine returns the number of bytes in the * sql_value object assuming that it uses the encoding "enc". diff --git a/src/box/sql/mem.h b/src/box/sql/mem.h index 9b0eb8444..7cea07dc9 100644 --- a/src/box/sql/mem.h +++ b/src/box/sql/mem.h @@ -192,6 +192,10 @@ mem_move(struct Mem *to, struct Mem *from); int mem_concat(struct Mem *left, struct Mem *right, struct Mem *result); +int +mem_arithmetic(const struct Mem *left, const struct Mem *right, + struct Mem *result, int op); + /* One or more of the following flags are set to indicate the validOK * representations of the value stored in the Mem struct. * @@ -261,8 +265,6 @@ mem_mp_type(struct Mem *mem); enum mp_type sql_value_type(struct Mem *); -u16 -numericType(Mem *pMem); int sqlValueBytes(struct Mem *); diff --git a/src/box/sql/vdbe.c b/src/box/sql/vdbe.c index c04bd40f3..55cb42932 100644 --- a/src/box/sql/vdbe.c +++ b/src/box/sql/vdbe.c @@ -1080,117 +1080,12 @@ case OP_Subtract: /* same as TK_MINUS, in1, in2, out3 */ case OP_Multiply: /* same as TK_STAR, in1, in2, out3 */ case OP_Divide: /* same as TK_SLASH, in1, in2, out3 */ case OP_Remainder: { /* same as TK_REM, in1, in2, out3 */ - u16 type1; /* Numeric type of left operand */ - u16 type2; /* Numeric type of right operand */ - i64 iA; /* Integer value of left operand */ - i64 iB; /* Integer value of right operand */ - double rA; /* Real value of left operand */ - double rB; /* Real value of right operand */ - pIn1 = &aMem[pOp->p1]; - type1 = numericType(pIn1); pIn2 = &aMem[pOp->p2]; - type2 = numericType(pIn2); - pOut = vdbe_prepare_null_out(p, pOp->p3); - if (mem_is_null(pIn1) || mem_is_null(pIn2)) - goto arithmetic_result_is_null; - if ((type1 & (MEM_Int | MEM_UInt)) != 0 && - (type2 & (MEM_Int | MEM_UInt)) != 0) { - iA = pIn1->u.i; - iB = pIn2->u.i; - bool is_lhs_neg = mem_is_integer(pIn1) && - !mem_is_unsigned(pIn1); - bool is_rhs_neg = mem_is_integer(pIn2) && - !mem_is_unsigned(pIn2); - bool is_res_neg; - switch( pOp->opcode) { - case OP_Add: { - if (sql_add_int(iA, is_lhs_neg, iB, is_rhs_neg, - (int64_t *) &iB, &is_res_neg) != 0) - goto integer_overflow; - break; - } - case OP_Subtract: { - if (sql_sub_int(iB, is_rhs_neg, iA, is_lhs_neg, - (int64_t *) &iB, &is_res_neg) != 0) - goto integer_overflow; - break; - } - case OP_Multiply: { - if (sql_mul_int(iA, is_lhs_neg, iB, is_rhs_neg, - (int64_t *) &iB, &is_res_neg) != 0) - goto integer_overflow; - break; - } - case OP_Divide: { - if (iA == 0) - goto division_by_zero; - if (sql_div_int(iB, is_rhs_neg, iA, is_lhs_neg, - (int64_t *) &iB, &is_res_neg) != 0) - goto integer_overflow; - break; - } - default: { - if (iA == 0) - goto division_by_zero; - if (iA==-1) iA = 1; - if (sql_rem_int(iB, is_rhs_neg, iA, is_lhs_neg, - (int64_t *) &iB, &is_res_neg) != 0) - goto integer_overflow; - break; - } - } - mem_set_int(pOut, iB, is_res_neg); - } else { - if (sqlVdbeRealValue(pIn1, &rA) != 0) { - diag_set(ClientError, ER_SQL_TYPE_MISMATCH, - mem_str(pIn1), "numeric"); - goto abort_due_to_error; - } - if (sqlVdbeRealValue(pIn2, &rB) != 0) { - diag_set(ClientError, ER_SQL_TYPE_MISMATCH, - mem_str(pIn2), "numeric"); - goto abort_due_to_error; - } - assert(((type1 | type2) & MEM_Real) != 0); - switch( pOp->opcode) { - case OP_Add: rB += rA; break; - case OP_Subtract: rB -= rA; break; - case OP_Multiply: rB *= rA; break; - case OP_Divide: { - if (rA == (double)0) - goto division_by_zero; - rB /= rA; - break; - } - default: { - iA = (i64)rA; - iB = (i64)rB; - if (iA == 0) - goto division_by_zero; - if (iA==-1) iA = 1; - rB = (double)(iB % iA); - break; - } - } - if (sqlIsNaN(rB)) { - goto arithmetic_result_is_null; - } - mem_set_double(pOut, rB); - } - break; - -arithmetic_result_is_null: - /* Force NULL be of type NUMBER. */ - pOut->field_type = FIELD_TYPE_NUMBER; + pOut = &aMem[pOp->p3]; + if (mem_arithmetic(pIn2, pIn1, pOut, pOp->opcode) != 0) + goto abort_due_to_error; break; - -division_by_zero: - diag_set(ClientError, ER_SQL_EXECUTE, "division by zero"); - goto abort_due_to_error; -integer_overflow: - diag_set(ClientError, ER_SQL_EXECUTE, "integer is overflowed"); - goto abort_due_to_error; } /* Opcode: CollSeq P1 * * P4 -- 2.25.1