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 5C5F36EC55; Sun, 11 Jul 2021 20:59:20 +0300 (MSK) DKIM-Filter: OpenDKIM Filter v2.11.0 dev.tarantool.org 5C5F36EC55 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=tarantool.org; s=dev; t=1626026360; bh=kIFco7IKtsmi6d/iu6ddAtgzddQ193wgxnHB18jpyLI=; h=Date:To:Cc:References:In-Reply-To:Subject:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From:Reply-To:From; b=hhyKeDAImk76OZq70YnbbTIzdVRHHDAHPgiL1OTcJhcJZIrbomhKXiSNNVUxLKejz Nd3Ybp4CY6sqELJbeT/Nr9BdGTJvpLHdwt5+X4stjoo9uEY03MwKqfHsj6JI/OU1gn CNl8ms0TCQnLTBafouKYSO1BlNS3rJsJwGi2ASnc= Received: from smtpng2.i.mail.ru (smtpng2.i.mail.ru [94.100.179.3]) (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 15A4F6EC55 for ; Sun, 11 Jul 2021 20:59:19 +0300 (MSK) DKIM-Filter: OpenDKIM Filter v2.11.0 dev.tarantool.org 15A4F6EC55 Received: by smtpng2.m.smailru.net with esmtpa (envelope-from ) id 1m2dja-0004sa-5P; Sun, 11 Jul 2021 20:59:18 +0300 Date: Sun, 11 Jul 2021 20:59:16 +0300 To: Vladislav Shpilevoy Cc: tarantool-patches@dev.tarantool.org Message-ID: <20210711175916.GB99369@tarantool.org> References: <28d370911c40124da91441be2f25cad49e4973b4.1625926838.git.imeevma@gmail.com> <20c6c37d-6364-8fdb-0aa5-c7c82407b143@tarantool.org> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline In-Reply-To: <20c6c37d-6364-8fdb-0aa5-c7c82407b143@tarantool.org> X-4EC0790: 10 X-7564579A: 646B95376F6C166E X-77F55803: 4F1203BC0FB41BD954DFF1DC42D673FB0BF54D2F3864CF3988C47C6E5746740D182A05F5380850403B24A76B7AE0EA089B38F8BCE3DBFE93BBB9883422C81979EEAB49D2546D7731 X-7FA49CB5: FF5795518A3D127A4AD6D5ED66289B5278DA827A17800CE71BDE6A359BD5B800EA1F7E6F0F101C67BD4B6F7A4D31EC0BCC500DACC3FED6E28638F802B75D45FF8AA50765F7900637F72512A705E00D288638F802B75D45FF36EB9D2243A4F8B5A6FCA7DBDB1FC311F39EFFDF887939037866D6147AF826D86BBEACAD8B0AE8BE25F365CA7C2C7EB8117882F4460429724CE54428C33FAD305F5C1EE8F4F765FCAA867293B0326636D2E47CDBA5A96583BD4B6F7A4D31EC0BC014FD901B82EE079FA2833FD35BB23D27C277FBC8AE2E8BF1175FABE1C0F9B6A471835C12D1D977C4224003CC8364762BB6847A3DEAEFB0F43C7A68FF6260569E8FC8737B5C2249EC8D19AE6D49635B68655334FD4449CB9ECD01F8117BC8BEAAAE862A0553A39223F8577A6DFFEA7CD1D040B6C1ECEA3F43847C11F186F3C59DAA53EE0834AAEE X-C1DE0DAB: 0D63561A33F958A5D6D6D60F91090FD9CDB13F5D2651C6A0BAE93F40AFBBE991D59269BC5F550898D99A6476B3ADF6B47008B74DF8BB9EF7333BD3B22AA88B938A852937E12ACA753753CEE10E4ED4A7410CA545F18667F91A7EA1CDA0B5A7A0 X-C8649E89: 4E36BF7865823D7055A7F0CF078B5EC49A30900B95165D34806D3522FB05EB39C6CD59FF4D3F06BD60E2C18CFA05C70BE158BE386ADE75EED6F500F5C94ACE6F1D7E09C32AA3244C78D26B458CBFB2BFDB965DCEE8F0FF8151E887DA02A9F7BF729B2BEF169E0186 X-D57D3AED: 3ZO7eAau8CL7WIMRKs4sN3D3tLDjz0dLbV79QFUyzQ2Ujvy7cMT6pYYqY16iZVKkSc3dCLJ7zSJH7+u4VD18S7Vl4ZUrpaVfd2+vE6kuoey4m4VkSEu530nj6fImhcD4MUrOEAnl0W826KZ9Q+tr5ycPtXkTV4k65bRjmOUUP8cvGozZ33TWg5HZplvhhXbhDGzqmQDTd6OAevLeAnq3Ra9uf7zvY2zzsIhlcp/Y7m53TZgf2aB4JOg4gkr2bioj/3sbGI30XheB1VSS5LM3QQ== X-Mailru-Sender: 689FA8AB762F7393C37E3C1AEC41BA5D07B0A8CBB67CF012B5029CD80AE68DA083D72C36FC87018B9F80AB2734326CD2FB559BB5D741EB96352A0ABBE4FDA4210A04DAD6CC59E33667EA787935ED9F1B X-Mras: Ok Subject: Re: [Tarantool-patches] [PATCH v2 4/4] sql: introduce mem_cmp_msgpack() 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: Mergen Imeev Errors-To: tarantool-patches-bounces@dev.tarantool.org Sender: "Tarantool-patches" Thank you for the review! My answers, diff and new patch below. On Sun, Jul 11, 2021 at 05:05:38PM +0200, Vladislav Shpilevoy wrote: > Thanks for the patch! > > See 4 comments below. > > On 10.07.2021 16:33, Mergen Imeev via Tarantool-patches wrote: > > This patch introduces the mem_cmp_scalar() function that compares MEM > > 1. scalar -> msgpack. > Thanks, fixed. > > diff --git a/src/box/sql/mem.c b/src/box/sql/mem.c > > index 576596c9f..471b69a18 100644 > > --- a/src/box/sql/mem.c > > +++ b/src/box/sql/mem.c > > @@ -2073,35 +2073,72 @@ mem_cmp_scalar(const struct Mem *a, const struct Mem *b, int *result, > > <...> > > > - > > -/* > > - * The input pBlob is guaranteed to be a Blob that is not marked > > - * with MEM_Zero. Return true if it could be a zero-blob. > > - */ > > -static int > > -isAllZero(const char *z, int n) > > +int > > +mem_cmp_msgpack(const struct Mem *a, const char *b, int *result, > > + const struct coll *coll) > > 2. Maybe better make the function return 'b' after decoding via > making it an out parameter. So as the caller could save mp_next() > call. > Agree. Done. Also, I could use here mp_decode_str()/mp_decode_bin() instead of mp_decode_strl()/mp_decode_binl() but decided to do this when I will change struct Mem according to discussion. Hope, I won't forget about this. > > { > > - int i; > > - for (i = 0; i < n; i++) { > > - if (z[i]) > > - return 0; > > + struct Mem mem; > > + switch (mp_typeof(*b)) { > > + case MP_NIL: > > + mem.type = MEM_TYPE_NULL; > > + break; > > + case MP_BOOL: > > + mem.type = MEM_TYPE_BOOL; > > + mem.u.b = mp_decode_bool(&b); > > + break; > > + case MP_UINT: > > + mem.type = MEM_TYPE_UINT; > > + mem.u.u = mp_decode_uint(&b); > > + break; > > + case MP_INT: > > + mem.type = MEM_TYPE_INT; > > + mem.u.i = mp_decode_int(&b); > > + break; > > + case MP_FLOAT: > > + mem.type = MEM_TYPE_DOUBLE; > > + mem.u.r = mp_decode_float(&b); > > + break; > > + case MP_DOUBLE: > > + mem.type = MEM_TYPE_DOUBLE; > > + mem.u.r = mp_decode_double(&b); > > + break; > > + case MP_STR: > > + mem.type = MEM_TYPE_STR; > > + mem.n = mp_decode_strl(&b); > > + mem.z = (char *)b; > > + mem.flags = MEM_Ephem; > > + break; > > + case MP_BIN: > > + mem.type = MEM_TYPE_BIN; > > + mem.n = mp_decode_binl(&b); > > + mem.z = (char *)b; > > 3. Shouldn't this also have MEM_Ephem? > Fixed here and below. > > + break; > > + case MP_ARRAY: > > + case MP_MAP: > > + *result = -1; > > + return 0; > > + case MP_EXT: { > > + int8_t type; > > + const char *buf = b; > > + uint32_t len = mp_decode_extl(&b, &type); > > + if (type == MP_UUID) { > > + assert(len == UUID_LEN); > > + mem.type = MEM_TYPE_UUID; > > + b = buf; > > 4. You can decode &buf below without changing b. > I changed a bit this part. > > + if (mp_decode_uuid(&b, &mem.u.uuid) == NULL) > > + return -1; > > + break; > > + } > > + b += len; > > + mem.type = MEM_TYPE_BIN; > > + mem.z = (char *)buf; > > + mem.n = b - buf; > > + break; > > } > > - return 1; > > + default: > > + unreachable(); > > + } > > + return mem_cmp_scalar(a, &mem, result, coll); > > } Diff: diff --git a/src/box/sql.c b/src/box/sql.c index 7f24bd778..a5afcfabb 100644 --- a/src/box/sql.c +++ b/src/box/sql.c @@ -768,13 +768,12 @@ tarantoolsqlIdxKeyCompare(struct BtCursor *cursor, struct key_part *part = &unpacked->key_def->parts[i]; struct Mem *mem = unpacked->aMem + i; struct coll *coll = part->coll; - mem_cmp_msgpack(mem, p, &rc, coll); + mem_cmp_msgpack(mem, &p, &rc, coll); if (rc != 0) { if (part->sort_order == SORT_ORDER_ASC) rc = -rc; goto out; } - mp_next(&p); } rc = unpacked->default_rc; out: diff --git a/src/box/sql/mem.c b/src/box/sql/mem.c index 5e7b1f28b..4062ff4b3 100644 --- a/src/box/sql/mem.c +++ b/src/box/sql/mem.c @@ -2078,65 +2078,71 @@ mem_cmp_scalar(const struct Mem *a, const struct Mem *b, int *result, } int -mem_cmp_msgpack(const struct Mem *a, const char *b, int *result, +mem_cmp_msgpack(const struct Mem *a, const char **b, int *result, const struct coll *coll) { struct Mem mem; - switch (mp_typeof(*b)) { + switch (mp_typeof(**b)) { case MP_NIL: mem.type = MEM_TYPE_NULL; + mp_decode_nil(b); break; case MP_BOOL: mem.type = MEM_TYPE_BOOL; - mem.u.b = mp_decode_bool(&b); + mem.u.b = mp_decode_bool(b); break; case MP_UINT: mem.type = MEM_TYPE_UINT; - mem.u.u = mp_decode_uint(&b); + mem.u.u = mp_decode_uint(b); break; case MP_INT: mem.type = MEM_TYPE_INT; - mem.u.i = mp_decode_int(&b); + mem.u.i = mp_decode_int(b); break; case MP_FLOAT: mem.type = MEM_TYPE_DOUBLE; - mem.u.r = mp_decode_float(&b); + mem.u.r = mp_decode_float(b); break; case MP_DOUBLE: mem.type = MEM_TYPE_DOUBLE; - mem.u.r = mp_decode_double(&b); + mem.u.r = mp_decode_double(b); break; case MP_STR: mem.type = MEM_TYPE_STR; - mem.n = mp_decode_strl(&b); - mem.z = (char *)b; + mem.n = mp_decode_strl(b); + mem.z = (char *)*b; + *b += mem.n; mem.flags = MEM_Ephem; break; case MP_BIN: mem.type = MEM_TYPE_BIN; - mem.n = mp_decode_binl(&b); - mem.z = (char *)b; + mem.n = mp_decode_binl(b); + mem.z = (char *)*b; + *b += mem.n; + mem.flags = MEM_Ephem; break; case MP_ARRAY: case MP_MAP: + mp_next(b); *result = -1; return 0; case MP_EXT: { int8_t type; - const char *buf = b; - uint32_t len = mp_decode_extl(&b, &type); + const char *buf = *b; + uint32_t len = mp_decode_extl(&buf, &type); if (type == MP_UUID) { assert(len == UUID_LEN); mem.type = MEM_TYPE_UUID; - b = buf; - if (mp_decode_uuid(&b, &mem.u.uuid) == NULL) + if (mp_decode_uuid(b, &mem.u.uuid) == NULL) return -1; break; } - b += len; + len += buf - *b; mem.type = MEM_TYPE_BIN; - mem.z = (char *)buf; - mem.n = b - buf; + mem.z = (char *)*b; + mem.n = len; + mem.flags = MEM_Ephem; + *b += len; break; } default: @@ -2584,13 +2590,12 @@ sqlVdbeRecordCompareMsgpack(const void *key1, struct key_part *part = &key2->key_def->parts[i]; struct Mem *mem = key2->aMem + i; struct coll *coll = part->coll; - mem_cmp_msgpack(mem, key1, &rc, coll); + mem_cmp_msgpack(mem, (const char **)&key1, &rc, coll); if (rc != 0) { if (part->sort_order != SORT_ORDER_ASC) return rc; return -rc; } - mp_next((const char **)&key1); } key2->eqSeen = 1; diff --git a/src/box/sql/mem.h b/src/box/sql/mem.h index 2439fd93b..c73536efb 100644 --- a/src/box/sql/mem.h +++ b/src/box/sql/mem.h @@ -706,11 +706,12 @@ mem_cmp_scalar(const struct Mem *a, const struct Mem *b, int *result, /** * Compare MEM and packed to msgpack value using SCALAR rules and return the - * result of comparison. Both values should be scalars. Original MEM and packed - * value are not changed. + * result of comparison. Both values should be scalars. Original MEM is not + * changed. If successful, the second argument will contain the address + * following the specified packed value. */ int -mem_cmp_msgpack(const struct Mem *a, const char *b, int *result, +mem_cmp_msgpack(const struct Mem *a, const char **b, int *result, const struct coll *coll); /** New patch: commit aa422cd2f19813503664e7292dbd01e7b0711a7d Author: Mergen Imeev Date: Fri Jul 9 11:59:34 2021 +0300 sql: introduce mem_cmp_msgpack() This patch introduces the mem_cmp_msgpack() function that compares MEM and packed to msgpack value using SCALAR rules. MEM and packed value must be scalars. Prior to this patch, there was a function that used SCALAR rules to compare MEM and packed value, but its design became overly complex as new types appeared. Closes #6164 diff --git a/src/box/sql.c b/src/box/sql.c index 790ca7f70..a5afcfabb 100644 --- a/src/box/sql.c +++ b/src/box/sql.c @@ -765,10 +765,12 @@ tarantoolsqlIdxKeyCompare(struct BtCursor *cursor, } } next_fieldno = fieldno + 1; - rc = sqlVdbeCompareMsgpack(&p, unpacked, i); + struct key_part *part = &unpacked->key_def->parts[i]; + struct Mem *mem = unpacked->aMem + i; + struct coll *coll = part->coll; + mem_cmp_msgpack(mem, &p, &rc, coll); if (rc != 0) { - if (unpacked->key_def->parts[i].sort_order != - SORT_ORDER_ASC) + if (part->sort_order == SORT_ORDER_ASC) rc = -rc; goto out; } diff --git a/src/box/sql/mem.c b/src/box/sql/mem.c index da27cd191..4062ff4b3 100644 --- a/src/box/sql/mem.c +++ b/src/box/sql/mem.c @@ -2077,35 +2077,78 @@ mem_cmp_scalar(const struct Mem *a, const struct Mem *b, int *result, return 0; } -/* - * Both *pMem1 and *pMem2 contain string values. Compare the two values - * using the collation sequence pColl. As usual, return a negative , zero - * or positive value if *pMem1 is less than, equal to or greater than - * *pMem2, respectively. Similar in spirit to "rc = (*pMem1) - (*pMem2);". - * - * Strungs assume to be UTF-8 encoded - */ -static int -vdbeCompareMemString(const Mem * pMem1, const Mem * pMem2, - const struct coll * pColl) -{ - return pColl->cmp(pMem1->z, (size_t)pMem1->n, - pMem2->z, (size_t)pMem2->n, pColl); -} - -/* - * The input pBlob is guaranteed to be a Blob that is not marked - * with MEM_Zero. Return true if it could be a zero-blob. - */ -static int -isAllZero(const char *z, int n) -{ - int i; - for (i = 0; i < n; i++) { - if (z[i]) - return 0; +int +mem_cmp_msgpack(const struct Mem *a, const char **b, int *result, + const struct coll *coll) +{ + struct Mem mem; + switch (mp_typeof(**b)) { + case MP_NIL: + mem.type = MEM_TYPE_NULL; + mp_decode_nil(b); + break; + case MP_BOOL: + mem.type = MEM_TYPE_BOOL; + mem.u.b = mp_decode_bool(b); + break; + case MP_UINT: + mem.type = MEM_TYPE_UINT; + mem.u.u = mp_decode_uint(b); + break; + case MP_INT: + mem.type = MEM_TYPE_INT; + mem.u.i = mp_decode_int(b); + break; + case MP_FLOAT: + mem.type = MEM_TYPE_DOUBLE; + mem.u.r = mp_decode_float(b); + break; + case MP_DOUBLE: + mem.type = MEM_TYPE_DOUBLE; + mem.u.r = mp_decode_double(b); + break; + case MP_STR: + mem.type = MEM_TYPE_STR; + mem.n = mp_decode_strl(b); + mem.z = (char *)*b; + *b += mem.n; + mem.flags = MEM_Ephem; + break; + case MP_BIN: + mem.type = MEM_TYPE_BIN; + mem.n = mp_decode_binl(b); + mem.z = (char *)*b; + *b += mem.n; + mem.flags = MEM_Ephem; + break; + case MP_ARRAY: + case MP_MAP: + mp_next(b); + *result = -1; + return 0; + case MP_EXT: { + int8_t type; + const char *buf = *b; + uint32_t len = mp_decode_extl(&buf, &type); + if (type == MP_UUID) { + assert(len == UUID_LEN); + mem.type = MEM_TYPE_UUID; + if (mp_decode_uuid(b, &mem.u.uuid) == NULL) + return -1; + break; + } + len += buf - *b; + mem.type = MEM_TYPE_BIN; + mem.z = (char *)*b; + mem.n = len; + mem.flags = MEM_Ephem; + *b += len; + break; } - return 1; + default: + unreachable(); + } + return mem_cmp_scalar(a, &mem, result, coll); } char * @@ -2534,183 +2577,6 @@ sql_vdbemem_finalize(struct Mem *mem, struct func *func) return ctx.is_aborted ? -1 : 0; } -int -sqlVdbeCompareMsgpack(const char **key1, - struct UnpackedRecord *unpacked, int key2_idx) -{ - const char *aKey1 = *key1; - Mem *pKey2 = unpacked->aMem + key2_idx; - Mem mem1; - int rc = 0; - switch (mp_typeof(*aKey1)) { - default:{ - /* FIXME */ - rc = -1; - break; - } - case MP_NIL:{ - rc = -(pKey2->type != MEM_TYPE_NULL); - mp_decode_nil(&aKey1); - break; - } - case MP_BOOL:{ - mem1.u.b = mp_decode_bool(&aKey1); - if (pKey2->type == MEM_TYPE_BOOL) { - if (mem1.u.b != pKey2->u.b) - rc = mem1.u.b ? 1 : -1; - } else { - rc = pKey2->type == MEM_TYPE_NULL ? 1 : -1; - } - break; - } - case MP_UINT:{ - mem1.u.u = mp_decode_uint(&aKey1); - if (pKey2->type == MEM_TYPE_INT) { - rc = +1; - } else if (pKey2->type == MEM_TYPE_UINT) { - if (mem1.u.u < pKey2->u.u) - rc = -1; - else if (mem1.u.u > pKey2->u.u) - rc = +1; - } else if (pKey2->type == MEM_TYPE_DOUBLE) { - rc = double_compare_uint64(pKey2->u.r, - mem1.u.u, -1); - } else if (pKey2->type == MEM_TYPE_NULL) { - rc = 1; - } else if (pKey2->type == MEM_TYPE_BOOL) { - rc = 1; - } else { - rc = -1; - } - break; - } - case MP_INT:{ - mem1.u.i = mp_decode_int(&aKey1); - if (pKey2->type == MEM_TYPE_UINT) { - rc = -1; - } else if (pKey2->type == MEM_TYPE_INT) { - if (mem1.u.i < pKey2->u.i) { - rc = -1; - } else if (mem1.u.i > pKey2->u.i) { - rc = +1; - } - } else if (pKey2->type == MEM_TYPE_DOUBLE) { - rc = double_compare_nint64(pKey2->u.r, mem1.u.i, - -1); - } else if (pKey2->type == MEM_TYPE_NULL) { - rc = 1; - } else if (pKey2->type == MEM_TYPE_BOOL) { - rc = 1; - } else { - rc = -1; - } - break; - } - case MP_FLOAT:{ - mem1.u.r = mp_decode_float(&aKey1); - goto do_float; - } - case MP_DOUBLE:{ - mem1.u.r = mp_decode_double(&aKey1); - do_float: - if (pKey2->type == MEM_TYPE_INT) { - rc = double_compare_nint64(mem1.u.r, pKey2->u.i, - 1); - } else if (pKey2->type == MEM_TYPE_UINT) { - rc = double_compare_uint64(mem1.u.r, - pKey2->u.u, 1); - } else if (pKey2->type == MEM_TYPE_DOUBLE) { - if (mem1.u.r < pKey2->u.r) { - rc = -1; - } else if (mem1.u.r > pKey2->u.r) { - rc = +1; - } - } else if (pKey2->type == MEM_TYPE_NULL) { - rc = 1; - } else if (pKey2->type == MEM_TYPE_BOOL) { - rc = 1; - } else { - rc = -1; - } - break; - } - case MP_STR:{ - if (pKey2->type == MEM_TYPE_STR) { - struct key_def *key_def = unpacked->key_def; - mem1.n = mp_decode_strl(&aKey1); - mem1.z = (char *)aKey1; - aKey1 += mem1.n; - struct coll *coll = - key_def->parts[key2_idx].coll; - if (coll != NULL) { - mem1.type = MEM_TYPE_STR; - mem1.flags = 0; - rc = vdbeCompareMemString(&mem1, pKey2, - coll); - } else { - goto do_bin_cmp; - } - } else { - rc = pKey2->type == MEM_TYPE_BIN ? -1 : +1; - } - break; - } - case MP_BIN:{ - mem1.n = mp_decode_binl(&aKey1); - mem1.z = (char *)aKey1; - aKey1 += mem1.n; - do_blob: - if (pKey2->type == MEM_TYPE_BIN) { - if (pKey2->flags & MEM_Zero) { - if (!isAllZero - ((const char *)mem1.z, mem1.n)) { - rc = 1; - } else { - rc = mem1.n - pKey2->u.nZero; - } - } else { - int nCmp; - do_bin_cmp: - nCmp = MIN(mem1.n, pKey2->n); - rc = memcmp(mem1.z, pKey2->z, nCmp); - if (rc == 0) - rc = mem1.n - pKey2->n; - } - } else { - rc = 1; - } - break; - } - case MP_ARRAY: - case MP_MAP: { - mem1.z = (char *)aKey1; - mp_next(&aKey1); - mem1.n = aKey1 - (char *)mem1.z; - goto do_blob; - } - case MP_EXT: { - int8_t type; - const char *buf = aKey1; - uint32_t len = mp_decode_extl(&aKey1, &type); - if (type == MP_UUID) { - assert(len == UUID_LEN); - mem1.type = MEM_TYPE_UUID; - aKey1 = buf; - if (mp_decode_uuid(&aKey1, &mem1.u.uuid) == NULL || - mem_cmp_uuid(&mem1, pKey2, &rc) != 0) - rc = 1; - break; - } - aKey1 += len; - mem1.z = (char *)buf; - mem1.n = aKey1 - buf; - goto do_blob; - } - } - *key1 = aKey1; - return rc; -} - int sqlVdbeRecordCompareMsgpack(const void *key1, struct UnpackedRecord *key2) @@ -2721,13 +2587,14 @@ sqlVdbeRecordCompareMsgpack(const void *key1, n = MIN(n, key2->nField); for (i = 0; i != n; i++) { - rc = sqlVdbeCompareMsgpack((const char**)&key1, key2, i); + struct key_part *part = &key2->key_def->parts[i]; + struct Mem *mem = key2->aMem + i; + struct coll *coll = part->coll; + mem_cmp_msgpack(mem, (const char **)&key1, &rc, coll); if (rc != 0) { - if (key2->key_def->parts[i].sort_order != - SORT_ORDER_ASC) { - rc = -rc; - } - return rc; + if (part->sort_order != SORT_ORDER_ASC) + return rc; + return -rc; } } diff --git a/src/box/sql/mem.h b/src/box/sql/mem.h index bbb99c4d2..c73536efb 100644 --- a/src/box/sql/mem.h +++ b/src/box/sql/mem.h @@ -704,6 +704,16 @@ int mem_cmp_scalar(const struct Mem *a, const struct Mem *b, int *result, const struct coll *coll); +/** + * Compare MEM and packed to msgpack value using SCALAR rules and return the + * result of comparison. Both values should be scalars. Original MEM is not + * changed. If successful, the second argument will contain the address + * following the specified packed value. + */ +int +mem_cmp_msgpack(const struct Mem *a, const char **b, int *result, + const struct coll *coll); + /** * Convert the given MEM to INTEGER. This function and the function below define * the rules that are used to convert values of all other types to INTEGER. In @@ -981,20 +991,6 @@ int sqlVdbeMemTooBig(Mem *); int sql_vdbemem_finalize(struct Mem *mem, struct func *func); -/** MEM and msgpack functions. */ - -/** - * Perform comparison of two keys: one is packed and one is not. - * - * @param key1 Pointer to pointer to first key. - * @param unpacked Pointer to unpacked tuple. - * @param key2_idx index of key in umpacked record to compare. - * - * @retval +1 if key1 > pUnpacked[iKey2], -1 ptherwise. - */ -int sqlVdbeCompareMsgpack(const char **key1, - struct UnpackedRecord *unpacked, int key2_idx); - /** * Perform comparison of two tuples: unpacked (key1) and packed (key2) * diff --git a/test/sql-tap/gh-6164-uuid-follow-ups.test.lua b/test/sql-tap/gh-6164-uuid-follow-ups.test.lua index 6b4a811c3..dd041c0b4 100755 --- a/test/sql-tap/gh-6164-uuid-follow-ups.test.lua +++ b/test/sql-tap/gh-6164-uuid-follow-ups.test.lua @@ -1,6 +1,6 @@ #!/usr/bin/env tarantool local test = require("sqltester") -test:plan(8) +test:plan(9) -- Make sure that function quote() can work with uuid. test:do_execsql_test( @@ -76,6 +76,18 @@ test:do_execsql_test( 2 }) +box.execute([[DELETE FROM t;]]) + +box.execute([[INSERT INTO t VALUES (1, X'00'), (2, ?);]], {uuid1}) + +test:do_execsql_test( + "gh-6164-9", + [[ + SELECT i FROM t ORDER BY s; + ]], { + 1, 2 + }) + box.execute([[DROP TABLE t;]]) test:finish_test()