Tarantool development patches archive
 help / color / mirror / Atom feed
From: Mergen Imeev via Tarantool-patches <tarantool-patches@dev.tarantool.org>
To: v.shpilevoy@tarantool.org, tsafin@tarantool.org
Cc: tarantool-patches@dev.tarantool.org
Subject: [Tarantool-patches] [PATCH v4 19/53] sql: introduce mem_compare()
Date: Tue, 23 Mar 2021 12:35:34 +0300	[thread overview]
Message-ID: <f8b6afc28c57815c14d7fdcd10ed088749afc272.1616491731.git.imeevma@gmail.com> (raw)
In-Reply-To: <cover.1616491730.git.imeevma@gmail.com>

This patch introduces mem_compare(). Function mem_compare() compares the
first and the second MEMs and returns result of comparison.

Part of #5818
---
 src/box/sql/mem.c  | 241 +++++++++++++++++++++++++++++++++++++++++++++
 src/box/sql/mem.h  |   4 +
 src/box/sql/vdbe.c |  92 +----------------
 3 files changed, 247 insertions(+), 90 deletions(-)

diff --git a/src/box/sql/mem.c b/src/box/sql/mem.c
index 6120939d8..8119644ed 100644
--- a/src/box/sql/mem.c
+++ b/src/box/sql/mem.c
@@ -556,6 +556,247 @@ mem_arithmetic(const struct Mem *left, const struct Mem *right,
 	return 0;
 }
 
+static int
+compare_blobs(const struct Mem *left, const struct Mem *right, int *result)
+{
+	int nl = left->n;
+	int nr = right->n;
+	int minlen = MIN(nl, nr);
+
+	/*
+	 * It is possible to have a Blob value that has some non-zero content
+	 * followed by zero content.  But that only comes up for Blobs formed
+	 * by the OP_MakeRecord opcode, and such Blobs never get passed into
+	 * mem_compare().
+	 */
+	assert((left->flags & MEM_Zero) == 0 || nl == 0);
+	assert((right->flags & MEM_Zero) == 0 || nr == 0);
+
+	if (left->flags & right->flags & MEM_Zero) {
+		*result = left->u.nZero - right->u.nZero;
+		return 0;
+	}
+	if (left->flags & MEM_Zero) {
+		for (int i = 0; i < minlen; ++i) {
+			if (right->z[i] != 0) {
+				*result = -1;
+				return 0;
+			}
+		}
+		*result = left->u.nZero - nr;
+		return 0;
+	}
+	if (right->flags & MEM_Zero) {
+		for (int i = 0; i < minlen; ++i) {
+			if (left->z[i] != 0){
+				*result = 1;
+				return 0;
+			}
+		}
+		*result = right->u.nZero - nl;
+		return 0;
+	}
+	*result = memcmp(left->z, right->z, minlen);
+	if (*result != 0)
+		return 0;
+	*result = nl - nr;
+	return 0;
+}
+
+static int
+compare_numbers(const struct Mem *left, const struct Mem *right, int *result)
+{
+	int64_t il;
+	double dl;
+	int left_type = left->flags & (MEM_Int | MEM_UInt | MEM_Real);
+	if (left_type == MEM_Real) {
+		dl = left->u.r;
+	} else if (left_type != 0) {
+		il = left->u.i;
+	} else if ((left->flags & MEM_Str) != 0) {
+		bool is_l_neg;
+		if (sql_atoi64(left->z, &il, &is_l_neg, left->n) == 0)
+			left_type = is_l_neg ? MEM_Int : MEM_UInt;
+		else if (sqlAtoF(left->z, &dl, left->n) != 0)
+			left_type = MEM_Real;
+	}
+	if (left_type == 0) {
+		diag_set(ClientError, ER_SQL_TYPE_MISMATCH,
+			 mem_str(left), "numeric");
+		return -1;
+	}
+
+	int64_t ir;
+	double dr;
+	int right_type = right->flags & (MEM_Int | MEM_UInt | MEM_Real);
+	if (right_type == MEM_Real) {
+		dr = right->u.r;
+	} else if (right_type != 0) {
+		ir = right->u.i;
+	} else if ((right->flags & MEM_Str) != 0) {
+		bool is_r_neg;
+		if (sql_atoi64(right->z, &ir, &is_r_neg, right->n) == 0)
+			right_type = is_r_neg ? MEM_Int : MEM_UInt;
+		else if (sqlAtoF(right->z, &dr, right->n) != 0)
+			right_type = MEM_Real;
+	}
+	/* TODO: There should be check for rvalue type. */
+	if (right_type == 0) {
+		*result = -1;
+		return 0;
+	}
+	if (left_type == right_type) {
+		if (left_type == MEM_Real) {
+			if (dl > dr)
+				*result = 1;
+			else if (dl < dr)
+				*result = -1;
+			else
+				*result = 0;
+			return 0;
+		}
+		if (left_type == MEM_Int) {
+			if (il > ir)
+				*result = 1;
+			else if (il < ir)
+				*result = -1;
+			else
+				*result = 0;
+			return 0;
+		}
+		uint64_t ul = (uint64_t)il;
+		uint64_t ur = (uint64_t)ir;
+		if (ul > ur)
+			*result = 1;
+		else if (ul < ur)
+			*result = -1;
+		else
+			*result = 0;
+		return 0;
+	}
+	if (left_type == MEM_Real) {
+		if (right_type == MEM_Int) {
+			*result = double_compare_nint64(dl, ir, 1);
+			return 0;
+		}
+		*result = double_compare_uint64(dl, (uint64_t)ir, 1);
+		return 0;
+	}
+	if (right_type == MEM_Real) {
+		if (left_type == MEM_Int) {
+			*result = double_compare_nint64(dr, il, -1);
+			return 0;
+		}
+		*result = double_compare_uint64(dr, (uint64_t)il, -1);
+		return 0;
+	}
+	if (left_type == MEM_Int) {
+		*result = -1;
+		return 0;
+	}
+	assert(right_type == MEM_Int && left_type == MEM_UInt);
+	*result = 1;
+	return 0;
+}
+
+static int
+compare_strings(const struct Mem *left, const struct Mem *right, int *result,
+		struct coll *coll)
+{
+	char *sl;
+	uint32_t nl;
+	char bufl[BUF_SIZE];
+	if ((left->flags & MEM_Str) != 0) {
+		sl = left->z;
+		nl = left->n;
+	} else {
+		assert((left->flags & (MEM_Int | MEM_UInt | MEM_Real)) != 0);
+		sl = &bufl[0];
+		if ((left->flags & MEM_Int) != 0)
+			sql_snprintf(BUF_SIZE, sl, "%lld", left->u.i);
+		else if ((left->flags & MEM_UInt) != 0)
+			sql_snprintf(BUF_SIZE, sl, "%llu", left->u.u);
+		else
+			sql_snprintf(BUF_SIZE, sl, "%!.15g", left->u.r);
+		nl = strlen(sl);
+	}
+
+	char *sr;
+	uint32_t nr;
+	char bufr[BUF_SIZE];
+	if ((right->flags & MEM_Str) != 0) {
+		sr = right->z;
+		nr = right->n;
+	} else {
+		assert((right->flags & (MEM_Int | MEM_UInt | MEM_Real)) != 0);
+		sr = &bufr[0];
+		if ((right->flags & MEM_Int) != 0)
+			sql_snprintf(BUF_SIZE, sr, "%lld", right->u.i);
+		else if ((right->flags & MEM_UInt) != 0)
+			sql_snprintf(BUF_SIZE, sr, "%llu", right->u.u);
+		else
+			sql_snprintf(BUF_SIZE, sr, "%!.15g", right->u.r);
+		nr = strlen(sr);
+	}
+	if (coll) {
+		*result = coll->cmp(sl, nl, sr, nr, coll);
+		return 0;
+	}
+	uint32_t minlen = MIN(nl, nr);
+	*result = memcmp(sl, sr, minlen);
+	if (*result != 0)
+		return 0;
+	*result = nl - nr;
+	return 0;
+}
+
+int
+mem_compare(const struct Mem *left, const struct Mem *right, int *result,
+	    enum field_type type, struct coll *coll)
+{
+	assert(((left->flags | right->flags) & MEM_Null) == 0);
+	if ((right->flags & MEM_Bool) != 0) {
+		if ((left->flags & MEM_Bool) != 0) {
+			if (left->u.b == right->u.b)
+				*result = 0;
+			else if (left->u.b)
+				*result = 1;
+			else
+				*result = -1;
+			return 0;
+		}
+		diag_set(ClientError, ER_SQL_TYPE_MISMATCH,
+			 mem_type_to_str(left), "boolean");
+		return -1;
+	}
+	if ((left->flags & MEM_Bool) != 0) {
+		diag_set(ClientError, ER_SQL_TYPE_MISMATCH,
+			 mem_type_to_str(right), "boolean");
+		return -1;
+	}
+	if ((right->flags & MEM_Blob) != 0) {
+		if ((left->flags & MEM_Blob) != 0)
+			return compare_blobs(left, right, result);
+		diag_set(ClientError, ER_SQL_TYPE_MISMATCH,
+			 mem_type_to_str(left), "varbinary");
+		return -1;
+	}
+	if ((left->flags & MEM_Blob) != 0) {
+		diag_set(ClientError, ER_SQL_TYPE_MISMATCH,
+			 mem_type_to_str(right), "varbinary");
+		return -1;
+	}
+	if (sql_type_is_numeric(type))
+		return compare_numbers(left, right, result);
+	if (type == FIELD_TYPE_STRING)
+		return compare_strings(left, right, result, coll);
+	if (((left->flags | right->flags) &
+	     (MEM_Int | MEM_UInt | MEM_Real)) != 0)
+		return compare_numbers(left, right, result);
+	assert((left->flags & MEM_Str) != 0 && (right->flags & MEM_Str) != 0);
+	return compare_strings(left, right, result, coll);
+}
+
 static inline bool
 mem_has_msgpack_subtype(struct Mem *mem)
 {
diff --git a/src/box/sql/mem.h b/src/box/sql/mem.h
index 7cea07dc9..096ce6533 100644
--- a/src/box/sql/mem.h
+++ b/src/box/sql/mem.h
@@ -196,6 +196,10 @@ int
 mem_arithmetic(const struct Mem *left, const struct Mem *right,
 	       struct Mem *result, int op);
 
+int
+mem_compare(const struct Mem *left, const struct Mem *right, int *result,
+	    enum field_type type, struct coll *coll);
+
 /* One or more of the following flags are set to indicate the validOK
  * representations of the value stored in the Mem struct.
  *
diff --git a/src/box/sql/vdbe.c b/src/box/sql/vdbe.c
index 55cb42932..726066c17 100644
--- a/src/box/sql/vdbe.c
+++ b/src/box/sql/vdbe.c
@@ -1543,15 +1543,9 @@ case OP_Le:               /* same as TK_LE, jump, in1, in3 */
 case OP_Gt:               /* same as TK_GT, jump, in1, in3 */
 case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
 	int res, res2;      /* Result of the comparison of pIn1 against pIn3 */
-	u32 flags1;         /* Copy of initial value of pIn1->flags */
-	u32 flags3;         /* Copy of initial value of pIn3->flags */
 
 	pIn1 = &aMem[pOp->p1];
 	pIn3 = &aMem[pOp->p3];
-	flags1 = pIn1->flags;
-	flags3 = pIn3->flags;
-	enum field_type ft_p1 = pIn1->field_type;
-	enum field_type ft_p3 = pIn3->field_type;
 	if (mem_is_null(pIn1) || mem_is_null(pIn3)) {
 		/* One or both operands are NULL */
 		if (pOp->p5 & SQL_NULLEQ) {
@@ -1585,85 +1579,11 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
 			}
 			break;
 		}
-	} else if (mem_is_boolean(pIn1) || mem_is_boolean(pIn3) ||
-		   mem_is_binary(pIn1) || mem_is_binary(pIn3)) {
-		if (!mem_is_same_type(pIn1, pIn3)) {
-			char *inconsistent_type = mem_is_boolean(pIn1) ||
-						  mem_is_binary(pIn1) ?
-						  mem_type_to_str(pIn3) :
-						  mem_type_to_str(pIn1);
-			char *expected_type = mem_is_boolean(pIn1) ||
-					      mem_is_binary(pIn1) ?
-					      mem_type_to_str(pIn1) :
-					      mem_type_to_str(pIn3);
-			diag_set(ClientError, ER_SQL_TYPE_MISMATCH,
-				 inconsistent_type, expected_type);
-			goto abort_due_to_error;
-		}
-		res = sqlMemCompare(pIn3, pIn1, NULL);
 	} else {
 		enum field_type type = pOp->p5 & FIELD_TYPE_MASK;
-		if (sql_type_is_numeric(type)) {
-			if (mem_is_string(pIn1)) {
-				mem_apply_numeric_type(pIn1);
-				flags3 = pIn3->flags;
-			}
-			if (mem_is_string(pIn3)) {
-				if (mem_apply_numeric_type(pIn3) != 0) {
-					diag_set(ClientError,
-						 ER_SQL_TYPE_MISMATCH,
-						 mem_str(pIn3),
-						 "numeric");
-					goto abort_due_to_error;
-				}
-			}
-			/* Handle the common case of integer comparison here, as an
-			 * optimization, to avoid a call to sqlMemCompare()
-			 */
-			if (mem_is_integer(pIn1) && mem_is_integer(pIn3)) {
-				if (!mem_is_unsigned(pIn1) &&
-				    !mem_is_unsigned(pIn3)) {
-					if (pIn3->u.i > pIn1->u.i)
-						res = +1;
-					else if (pIn3->u.i < pIn1->u.i)
-						res = -1;
-					else
-						res = 0;
-					goto compare_op;
-				}
-				if (mem_is_unsigned(pIn1) &&
-				    mem_is_unsigned(pIn3)) {
-					if (pIn3->u.u > pIn1->u.u)
-						res = +1;
-					else if (pIn3->u.u < pIn1->u.u)
-						res = -1;
-					else
-						res = 0;
-					goto compare_op;
-				}
-				if (mem_is_unsigned(pIn1) &&
-				    !mem_is_unsigned(pIn3)) {
-					res = -1;
-					goto compare_op;
-				}
-				res = 1;
-				goto compare_op;
-			}
-		} else if (type == FIELD_TYPE_STRING) {
-			if (!mem_is_string(pIn1) && mem_is_number(pIn1)) {
-				sqlVdbeMemStringify(pIn1);
-				flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask);
-				assert(pIn1!=pIn3);
-			}
-			if (!mem_is_string(pIn3) && mem_is_number(pIn3)) {
-				sqlVdbeMemStringify(pIn3);
-				flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask);
-			}
-		}
-		assert(pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0);
-		res = sqlMemCompare(pIn3, pIn1, pOp->p4.pColl);
+		if (mem_compare(pIn3, pIn1, &res, type, pOp->p4.pColl))
+			goto abort_due_to_error;
 	}
-			compare_op:
 	switch( pOp->opcode) {
 	case OP_Eq:    res2 = res==0;     break;
 	case OP_Ne:    res2 = res;        break;
@@ -1673,14 +1593,6 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
 	default:       res2 = res>=0;     break;
 	}
 
-	/* Undo any changes made by mem_apply_type() to the input registers. */
-	assert((pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn));
-	pIn1->flags = flags1;
-	pIn1->field_type = ft_p1;
-	assert((pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn));
-	pIn3->flags = flags3;
-	pIn3->field_type = ft_p3;
-
 	if (pOp->p5 & SQL_STOREP2) {
 		iCompare = res;
 		res2 = res2!=0;  /* For this path res2 must be exactly 0 or 1 */
-- 
2.25.1


  parent reply	other threads:[~2021-03-23  9:44 UTC|newest]

Thread overview: 90+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2021-03-23  9:34 [Tarantool-patches] [PATCH v4 00/53] Move mem-related functions to mem.c/mem.h Mergen Imeev via Tarantool-patches
2021-03-23  9:34 ` [Tarantool-patches] [PATCH v4 01/53] sql: enchance vdbe_decode_msgpack_into_mem() Mergen Imeev via Tarantool-patches
2021-03-29 22:57   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:34 ` [Tarantool-patches] [PATCH v4 02/53] sql: disable unused code in sql/analyze.c Mergen Imeev via Tarantool-patches
2021-03-23  9:34 ` [Tarantool-patches] [PATCH v4 03/53] sql: disable unused code in sql/legacy.c Mergen Imeev via Tarantool-patches
2021-03-23  9:34 ` [Tarantool-patches] [PATCH v4 04/53] sql: remove NULL-termination in OP_ResultRow Mergen Imeev via Tarantool-patches
2021-03-23  9:34 ` [Tarantool-patches] [PATCH v4 05/53] sql: move MEM-related functions to mem.c/mem.h Mergen Imeev via Tarantool-patches
2021-03-29 22:58   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 06/53] sql: remove unused MEM-related functions Mergen Imeev via Tarantool-patches
2021-03-29 22:58   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 07/53] sql: disable unused code in sql/vdbemem.c Mergen Imeev via Tarantool-patches
2021-03-29 22:58   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 08/53] sql: introduce mem_str() Mergen Imeev via Tarantool-patches
2021-03-29 22:58   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 09/53] sql: introduce mem_create() Mergen Imeev via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 10/53] sql: introduce mem_destroy() Mergen Imeev via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 11/53] sql: introduce mem_is_*() functions() Mergen Imeev via Tarantool-patches
2021-03-29 23:01   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 12/53] sql: introduce mem_copy() Mergen Imeev via Tarantool-patches
2021-03-29 23:01   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 13/53] sql: introduce mem_copy_as_ephemeral() Mergen Imeev via Tarantool-patches
2021-03-29 23:01   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 14/53] sql: rework mem_move() Mergen Imeev via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 15/53] sql: rework vdbe_decode_msgpack_into_mem() Mergen Imeev via Tarantool-patches
2021-03-29 23:02   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 16/53] sql: remove sql_column_to_messagepack() Mergen Imeev via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 17/53] sql: introduce mem_concat() Mergen Imeev via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 18/53] sql: introduce mem_arithmetic() Mergen Imeev via Tarantool-patches
2021-03-29 23:02   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` Mergen Imeev via Tarantool-patches [this message]
2021-03-29 23:03   ` [Tarantool-patches] [PATCH v4 19/53] sql: introduce mem_compare() Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 20/53] sql: introduce mem_bitwise() Mergen Imeev via Tarantool-patches
2021-03-29 23:03   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 21/53] sql: introduce mem_bit_not() Mergen Imeev via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 22/53] sql: Initialize MEM in sqlVdbeAllocUnpackedRecord() Mergen Imeev via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 23/53] sql: introduce mem_set_null() Mergen Imeev via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 24/53] sql: introduce mem_set_integer() Mergen Imeev via Tarantool-patches
2021-03-29 23:04   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 25/53] sql: introduce mem_set_unsigned() Mergen Imeev via Tarantool-patches
2021-03-29 23:04   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 26/53] sql: introduce mem_set_boolean() Mergen Imeev via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 27/53] sql: refactor mem_set_double() Mergen Imeev via Tarantool-patches
2021-03-29 23:04   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 28/53] sql: refactor mem_set_*_string() Mergen Imeev via Tarantool-patches
2021-03-29 23:05   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:35 ` [Tarantool-patches] [PATCH v4 29/53] sql: introduce mem_copy_string() Mergen Imeev via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 30/53] sql: introduce mem_set_*_binary() Mergen Imeev via Tarantool-patches
2021-03-29 23:05   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 31/53] sql: introduce mem_copy_binary() Mergen Imeev via Tarantool-patches
2021-03-29 23:05   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 32/53] sql: introduce mem_set_zerobinary() Mergen Imeev via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 33/53] sql: introduce mem_append_to_binary() Mergen Imeev via Tarantool-patches
2021-03-29 23:05   ` Vladislav Shpilevoy via Tarantool-patches
2021-04-09 19:52     ` Mergen Imeev via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 34/53] sql: introduce mem_set_*_map() and mem_set_*_array() Mergen Imeev via Tarantool-patches
2021-03-29 23:05   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 35/53] sql: introduce mem_set_undefined() Mergen Imeev via Tarantool-patches
2021-03-29 23:06   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 36/53] sql: introduce mem_set_pointer() Mergen Imeev via Tarantool-patches
2021-03-29 23:06   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 37/53] sql: introduce mem_set_frame() Mergen Imeev via Tarantool-patches
2021-03-29 23:06   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 38/53] sql: introduce mem_*_aggregate() Mergen Imeev via Tarantool-patches
2021-03-29 23:06   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 39/53] sql: introduce mem_set_cleared() Mergen Imeev via Tarantool-patches
2021-03-29 23:07   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 40/53] sql: move MEM flags to mem.c Mergen Imeev via Tarantool-patches
2021-03-29 23:07   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 41/53] sql: introduce mem_convert_to_integer() Mergen Imeev via Tarantool-patches
2021-03-29 23:07   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 42/53] sql: introduce mem_convert_to_double() Mergen Imeev via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 43/53] sql: introduce mem_convert_to_number() Mergen Imeev via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 44/53] sql: introduce mem_convert_to_string() Mergen Imeev via Tarantool-patches
2021-03-29 23:07   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 45/53] sql: introduce mem_explicit_cast() Mergen Imeev via Tarantool-patches
2021-03-29 23:08   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 46/53] sql: introduce mem_implicit_cast() Mergen Imeev via Tarantool-patches
2021-03-29 23:08   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 47/53] sql: introduce mem_get_integer() Mergen Imeev via Tarantool-patches
2021-03-29 23:08   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 48/53] sql: introduce mem_get_unsigned() Mergen Imeev via Tarantool-patches
2021-03-29 23:08   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 49/53] sql: introduce mem_get_double() Mergen Imeev via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 50/53] sql: introduce mem_get_boolean() Mergen Imeev via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 51/53] sql: introduce mem_get_string0() Mergen Imeev via Tarantool-patches
2021-03-29 23:08   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 52/53] sql: introduce mem_get_binary() Mergen Imeev via Tarantool-patches
2021-03-29 23:09   ` Vladislav Shpilevoy via Tarantool-patches
2021-03-23  9:36 ` [Tarantool-patches] [PATCH v4 53/53] sql: introduce mem_get_length() Mergen Imeev via Tarantool-patches
2021-03-29 23:09   ` Vladislav Shpilevoy via Tarantool-patches

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=f8b6afc28c57815c14d7fdcd10ed088749afc272.1616491731.git.imeevma@gmail.com \
    --to=tarantool-patches@dev.tarantool.org \
    --cc=imeevma@tarantool.org \
    --cc=tsafin@tarantool.org \
    --cc=v.shpilevoy@tarantool.org \
    --subject='Re: [Tarantool-patches] [PATCH v4 19/53] sql: introduce mem_compare()' \
    /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