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 60B0D23E30 for ; Mon, 14 May 2018 07:57:39 -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 8mcEG-vXYPXi for ; Mon, 14 May 2018 07:57:39 -0400 (EDT) Received: from smtp40.i.mail.ru (smtp40.i.mail.ru [94.100.177.100]) (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 DD6EC23E1F for ; Mon, 14 May 2018 07:57:38 -0400 (EDT) From: Nikita Pettik Subject: [tarantool-patches] [PATCH] sql: remove unused VDBE routine Date: Mon, 14 May 2018 14:57:34 +0300 Message-Id: <20180514115734.20761-1-korablev@tarantool.org> 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, Nikita Pettik --- This patch simply removes useless/obsolete routine from VDBE and auxiliary functions. Branch: https://github.com/tarantool/tarantool/commits/np/vdbe-cleanup src/box/sql/vdbe.c | 21 +-- src/box/sql/vdbe.h | 3 - src/box/sql/vdbeInt.h | 4 - src/box/sql/vdbeaux.c | 492 -------------------------------------------------- 4 files changed, 2 insertions(+), 518 deletions(-) diff --git a/src/box/sql/vdbe.c b/src/box/sql/vdbe.c index 2adc17ed2..62d1f04f5 100644 --- a/src/box/sql/vdbe.c +++ b/src/box/sql/vdbe.c @@ -2524,10 +2524,6 @@ case OP_Column: { pC = p->apCsr[pOp->p1]; p2 = pOp->p2; - /* If the cursor cache is stale, bring it up-to-date */ - rc = sqlite3VdbeCursorMoveto(&pC, &p2); - if (rc) goto abort_due_to_error; - assert(pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor)); pDest = &aMem[pOp->p3]; memAboutToChange(p, pDest); @@ -3572,7 +3568,6 @@ case OP_SeekGT: { /* jump, in3 */ assert(res!=0); goto seek_not_found; } - pC->deferredMoveto = 0; pC->cacheStatus = CACHE_STALE; #ifdef SQLITE_TEST sql_search_count++; @@ -3738,7 +3733,6 @@ case OP_Found: { /* jump, in3 */ pC->seekResult = res; alreadyExists = (res==0); pC->nullRow = 1-alreadyExists; - pC->deferredMoveto = 0; pC->cacheStatus = CACHE_STALE; if (pOp->opcode==OP_Found) { VdbeBranchTaken(alreadyExists!=0,2); @@ -3887,7 +3881,6 @@ case OP_Delete: { assert(pC!=0); assert(pC->eCurType==CURTYPE_TARANTOOL); assert(pC->uc.pCursor!=0); - assert(pC->deferredMoveto==0); assert(pBtCur->eState == CURSOR_VALID); if (pBtCur->curFlags & BTCF_TaCursor) { @@ -4015,13 +4008,9 @@ case OP_RowData: { * OP_Rewind/Op_Next with no intervening instructions * that might invalidate the cursor. * If this where not the case, on of the following assert()s - * would fail. Should this ever change (because of changes in the code - * generator) then the fix would be to insert a call to - * sqlite3VdbeCursorMoveto(). + * would fail. */ - assert(pC->deferredMoveto==0); assert(sqlite3CursorIsValid(pCrsr)); - assert(pCrsr->eState == CURSOR_VALID); assert(pCrsr->curFlags & BTCF_TaCursor || pCrsr->curFlags & BTCF_TEphemCursor); @@ -4101,7 +4090,6 @@ case OP_Last: { /* jump */ if (pOp->p3==0 || !sqlite3CursorIsValidNN(pCrsr)) { rc = tarantoolSqlite3Last(pCrsr, &res); pC->nullRow = (u8)res; - pC->deferredMoveto = 0; pC->cacheStatus = CACHE_STALE; if (rc) goto abort_due_to_error; if (pOp->p2>0) { @@ -4178,7 +4166,6 @@ case OP_Rewind: { /* jump */ pCrsr = pC->uc.pCursor; assert(pCrsr); rc = tarantoolSqlite3First(pCrsr, &res); - pC->deferredMoveto = 0; pC->cacheStatus = CACHE_STALE; } if (rc) goto abort_due_to_error; @@ -4277,7 +4264,6 @@ case OP_Next: /* jump */ pC = p->apCsr[pOp->p1]; res = pOp->p3; assert(pC!=0); - assert(pC->deferredMoveto==0); assert(pC->eCurType==CURTYPE_TARANTOOL); assert(res==0 || res==1); testcase( res==1); @@ -4373,7 +4359,6 @@ case OP_IdxInsert: { /* in2 */ } else { unreachable(); } - assert(pC->deferredMoveto==0); pC->cacheStatus = CACHE_STALE; } @@ -4507,7 +4492,6 @@ case OP_IdxDelete: { } if (rc) goto abort_due_to_error; } - assert(pC->deferredMoveto==0); pC->cacheStatus = CACHE_STALE; pC->seekResult = 0; break; @@ -4570,7 +4554,6 @@ case OP_IdxGE: { /* jump */ assert(pC!=0); assert(pC->eCurType==CURTYPE_TARANTOOL); assert(pC->uc.pCursor!=0); - assert(pC->deferredMoveto==0); assert(pOp->p5==0 || pOp->p5==1); assert(pOp->p4type==P4_INT32); r.pKeyInfo = pC->pKeyInfo; @@ -4587,7 +4570,7 @@ case OP_IdxGE: { /* jump */ { int i; for(i=0; iuc.pCursor, &r, &res); assert((OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1)); if ((pOp->opcode&1)==(OP_IdxLT&1)) { assert(pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT); diff --git a/src/box/sql/vdbe.h b/src/box/sql/vdbe.h index c31983f21..bcc6009f3 100644 --- a/src/box/sql/vdbe.h +++ b/src/box/sql/vdbe.h @@ -281,13 +281,10 @@ int sqlite3MemCompare(const Mem *, const Mem *, const struct coll *); void sqlite3VdbeRecordUnpackMsgpack(KeyInfo *, int, const void *, UnpackedRecord *); -int sqlite3VdbeRecordCompare(int, const void *, UnpackedRecord *); -int sqlite3VdbeRecordCompareWithSkip(int, const void *, UnpackedRecord *, int); UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(KeyInfo *); int sql_vdbe_mem_alloc_region(Mem *, uint32_t); typedef int (*RecordCompare) (int, const void *, UnpackedRecord *); -RecordCompare sqlite3VdbeFindCompare(UnpackedRecord *); #ifndef SQLITE_OMIT_TRIGGER void sqlite3VdbeLinkSubProgram(Vdbe *, SubProgram *); diff --git a/src/box/sql/vdbeInt.h b/src/box/sql/vdbeInt.h index 3a907cd93..190889bac 100644 --- a/src/box/sql/vdbeInt.h +++ b/src/box/sql/vdbeInt.h @@ -82,7 +82,6 @@ typedef struct VdbeCursor VdbeCursor; struct VdbeCursor { u8 eCurType; /* One of the CURTYPE_* values above */ u8 nullRow; /* True if pointing to a row with no data */ - u8 deferredMoveto; /* A call to sqlite3CursorMoveto() is needed */ #ifdef SQLITE_DEBUG u8 seekOp; /* Most recent seek operation on this cursor */ #endif @@ -446,19 +445,16 @@ struct PreUpdate { void sqlite3VdbeError(Vdbe *, const char *, ...); void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor *); void sqliteVdbePopStack(Vdbe *, int); -int sqlite3VdbeCursorMoveto(VdbeCursor **, int *); int sqlite3VdbeCursorRestore(VdbeCursor *); #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) void sqlite3VdbePrintOp(FILE *, int, Op *); #endif u32 sqlite3VdbeSerialTypeLen(u32); -u8 sqlite3VdbeOneByteSerialTypeLen(u8); u32 sqlite3VdbeSerialType(Mem *, int, u32 *); u32 sqlite3VdbeSerialPut(unsigned char *, Mem *, u32); u32 sqlite3VdbeSerialGet(const unsigned char *, u32, Mem *); void sqlite3VdbeDeleteAuxData(sqlite3 *, AuxData **, int, int); -int sqlite3VdbeIdxKeyCompare(sqlite3 *, VdbeCursor *, UnpackedRecord *, int *); int sqlite3VdbeExec(Vdbe *); int sqlite3VdbeList(Vdbe *); int diff --git a/src/box/sql/vdbeaux.c b/src/box/sql/vdbeaux.c index ead96592d..660b8ba6b 100644 --- a/src/box/sql/vdbeaux.c +++ b/src/box/sql/vdbeaux.c @@ -3036,59 +3036,6 @@ sqlite3VdbeDelete(Vdbe * p) sqlite3DbFree(db, p); } -/* - * The cursor "p" has a pending seek operation that has not yet been - * carried out. Seek the cursor now. If an error occurs, return - * the appropriate error code. - */ -static int SQLITE_NOINLINE -handleDeferredMoveto(VdbeCursor * p) -{ - int res, rc; -#ifdef SQLITE_TEST - extern int sql_search_count; -#endif - assert(p->deferredMoveto); - assert(p->eCurType == CURTYPE_TARANTOOL); - rc = sqlite3CursorMovetoUnpacked(p->uc.pCursor, 0, &res); - if (rc) - return rc; - if (res != 0) - return SQLITE_CORRUPT_BKPT; -#ifdef SQLITE_TEST - sql_search_count++; -#endif - p->deferredMoveto = 0; - p->cacheStatus = CACHE_STALE; - return SQLITE_OK; -} - -/* - * Make sure the cursor p is ready to read or write the row to which it - * was last positioned. Return an error code if an OOM fault or I/O error - * prevents us from positioning the cursor to its correct position. - * - * If a MoveTo operation is pending on the given cursor, then do that - * MoveTo now. If no move is pending, check to see if the row has been - * deleted out from under the cursor and if it has, mark the row as - * a NULL row. - * - * If the cursor is already pointing to the correct row and that row has - * not been deleted out from under the cursor, then this routine is a no-op. - */ -int -sqlite3VdbeCursorMoveto(VdbeCursor ** pp, int *piCol) -{ - (void)piCol; - VdbeCursor *p = *pp; - if (p->eCurType == CURTYPE_TARANTOOL) { - if (p->deferredMoveto) { - return handleDeferredMoveto(p); - } - } - return SQLITE_OK; -} - /* * The following functions: * @@ -3233,13 +3180,6 @@ sqlite3VdbeSerialTypeLen(u32 serial_type) } } -u8 -sqlite3VdbeOneByteSerialTypeLen(u8 serial_type) -{ - assert(serial_type < 128); - return sqlite3SmallTypeSizes[serial_type]; -} - /* * If we are on an architecture with mixed-endian floating * points (ex: ARM7) then swap the lower 4 bytes with the @@ -3547,121 +3487,6 @@ sql_vdbe_mem_alloc_region(Mem *vdbe_mem, uint32_t size) return SQLITE_OK; } -#if SQLITE_DEBUG -/* - * This function compares two index or table record keys in the same way - * as the sqlite3VdbeRecordCompare() routine. Unlike VdbeRecordCompare(), - * this function deserializes and compares values using the - * sqlite3VdbeSerialGet() and sqlite3MemCompare() functions. It is used - * in assert() statements to ensure that the optimized code in - * sqlite3VdbeRecordCompare() returns results with these two primitives. - * - * Return true if the result of comparison is equivalent to desiredResult. - * Return false if there is a disagreement. - */ -static int -vdbeRecordCompareDebug(int nKey1, const void *pKey1, /* Left key */ - const UnpackedRecord * pPKey2, /* Right key */ - int desiredResult) /* Correct answer */ -{ - u32 d1; /* Offset into aKey[] of next data element */ - u32 idx1; /* Offset into aKey[] of next header element */ - u32 szHdr1; /* Number of bytes in header */ - int i = 0; - int rc = 0; - const unsigned char *aKey1 = (const unsigned char *)pKey1; - KeyInfo *pKeyInfo; - Mem mem1; - - pKeyInfo = pPKey2->pKeyInfo; - if (pKeyInfo->db == 0) - return 1; - mem1.db = pKeyInfo->db; - /* mem1.flags = 0; // Will be initialized by sqlite3VdbeSerialGet() */ - VVA_ONLY(mem1.szMalloc = 0; - ) - - /* Only needed by assert() statements */ - /* Compilers may complain that mem1.u.i is potentially uninitialized. - * We could initialize it, as shown here, to silence those complaints. - * But in fact, mem1.u.i will never actually be used uninitialized, and doing - * the unnecessary initialization has a measurable negative performance - * impact, since this routine is a very high runner. And so, we choose - * to ignore the compiler warnings and leave this variable uninitialized. - */ - /* mem1.u.i = 0; // not needed, here to silence compiler warning */ - idx1 = getVarint32(aKey1, szHdr1); - if (szHdr1 > 98307) - return SQLITE_CORRUPT; - d1 = szHdr1; - assert(pKeyInfo->nField + pKeyInfo->nXField >= pPKey2->nField - || CORRUPT_DB); - assert(pKeyInfo->aSortOrder != 0); - assert(pKeyInfo->nField > 0); - assert(idx1 <= szHdr1 || CORRUPT_DB); - do { - u32 serial_type1; - - /* Read the serial types for the next element in each key. */ - idx1 += getVarint32(aKey1 + idx1, serial_type1); - - /* Verify that there is enough key space remaining to avoid - * a buffer overread. The "d1+serial_type1+2" subexpression will - * always be greater than or equal to the amount of required key space. - * Use that approximation to avoid the more expensive call to - * sqlite3VdbeSerialTypeLen() in the common case. - */ - if (d1 + serial_type1 + 2 > (u32) nKey1 - && d1 + sqlite3VdbeSerialTypeLen(serial_type1) > - (u32) nKey1) { - break; - } - - /* Extract the values to be compared. - */ - d1 += sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1); - - /* Do the comparison - */ - rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i], - pKeyInfo->aColl[i]); - if (rc != 0) { - assert(mem1.szMalloc == 0); /* See comment below */ - if (pKeyInfo->aSortOrder[i]) { - rc = -rc; /* Invert the result for DESC sort order. */ - } - goto debugCompareEnd; - } - i++; - } while (idx1 < szHdr1 && i < pPKey2->nField); - - /* No memory allocation is ever used on mem1. Prove this using - * the following assert(). If the assert() fails, it indicates a - * memory leak and a need to call sqlite3VdbeMemRelease(&mem1). - */ - assert(mem1.szMalloc == 0); - - /* rc==0 here means that one of the keys ran out of fields and - * all the fields up to that point were equal. Return the default_rc - * value. - */ - rc = pPKey2->default_rc; - - debugCompareEnd: - if (desiredResult == 0 && rc == 0) - return 1; - if (desiredResult < 0 && rc < 0) - return 1; - if (desiredResult > 0 && rc > 0) - return 1; - if (CORRUPT_DB) - return 1; - if (pKeyInfo->db->mallocFailed) - return 1; - return 0; -} -#endif - /* * Both *pMem1 and *pMem2 contain string values. Compare the two values * using the collation sequence pColl. As usual, return a negative , zero @@ -3868,323 +3693,6 @@ sqlite3MemCompare(const Mem * pMem1, const Mem * pMem2, const struct coll * pCol return sqlite3BlobCompare(pMem1, pMem2); } -/* - * The first argument passed to this function is a serial-type that - * corresponds to an integer - all values between 1 and 9 inclusive - * except 7. The second points to a buffer containing an integer value - * serialized according to serial_type. This function deserializes - * and returns the value. - */ -static i64 -vdbeRecordDecodeInt(u32 serial_type, const u8 * aKey) -{ - u32 y; - assert(CORRUPT_DB - || (serial_type >= 1 && serial_type <= 9 && serial_type != 7)); - switch (serial_type) { - case 0: - case 1: - testcase(aKey[0] & 0x80); - return ONE_BYTE_INT(aKey); - case 2: - testcase(aKey[0] & 0x80); - return TWO_BYTE_INT(aKey); - case 3: - testcase(aKey[0] & 0x80); - return THREE_BYTE_INT(aKey); - case 4:{ - testcase(aKey[0] & 0x80); - y = FOUR_BYTE_UINT(aKey); - return (i64) * (int *)&y; - } - case 5:{ - testcase(aKey[0] & 0x80); - return FOUR_BYTE_UINT(aKey + 2) + - (((i64) 1) << 32) * TWO_BYTE_INT(aKey); - } - case 6:{ - u64 x = FOUR_BYTE_UINT(aKey); - testcase(aKey[0] & 0x80); - x = (x << 32) | FOUR_BYTE_UINT(aKey + 4); - return (i64) * (i64 *) & x; - } - } - - return (serial_type - 8); -} - -/* - * This function compares the two table rows or index records - * specified by {nKey1, pKey1} and pPKey2. It returns a negative, zero - * or positive integer if key1 is less than, equal to or - * greater than key2. The {nKey1, pKey1} key must be a blob - * created by the OP_MakeRecord opcode of the VDBE. The pPKey2 - * key must be a parsed key such as obtained from - * sqlite3VdbeParseRecord. - * - * If argument bSkip is non-zero, it is assumed that the caller has already - * determined that the first fields of the keys are equal. - * - * Key1 and Key2 do not have to contain the same number of fields. If all - * fields that appear in both keys are equal, then pPKey2->default_rc is - * returned. - * - * If database corruption is discovered, set pPKey2->errCode to - * SQLITE_CORRUPT and return 0. If an OOM error is encountered, - * pPKey2->errCode is set to SQLITE_NOMEM and, if it is not NULL, the - * malloc-failed flag set on database handle (pPKey2->pKeyInfo->db). - */ -int -sqlite3VdbeRecordCompareWithSkip(int nKey1, const void *pKey1, /* Left key */ - UnpackedRecord * pPKey2, /* Right key */ - int bSkip) /* If true, skip the first field */ -{ - u32 d1; /* Offset into aKey[] of next data element */ - int i; /* Index of next field to compare */ - u32 szHdr1; /* Size of record header in bytes */ - u32 idx1; /* Offset of first type in header */ - int rc = 0; /* Return value */ - Mem *pRhs = pPKey2->aMem; /* Next field of pPKey2 to compare */ - KeyInfo *pKeyInfo = pPKey2->pKeyInfo; - const unsigned char *aKey1 = (const unsigned char *)pKey1; - Mem mem1; - - /* If bSkip is true, then the caller has already determined that the first - * two elements in the keys are equal. Fix the various stack variables so - * that this routine begins comparing at the second field. - */ - if (bSkip) { - u32 s1; - idx1 = 1 + getVarint32(&aKey1[1], s1); - szHdr1 = aKey1[0]; - d1 = szHdr1 + sqlite3VdbeSerialTypeLen(s1); - i = 1; - pRhs++; - } else { - idx1 = getVarint32(aKey1, szHdr1); - d1 = szHdr1; - if (d1 > (unsigned)nKey1) { - pPKey2->errCode = (u8) SQLITE_CORRUPT_BKPT; - return 0; /* Corruption */ - } - i = 0; - } - - VVA_ONLY(mem1.szMalloc = 0; - ) /* Only needed by assert() statements */ - assert(pPKey2->pKeyInfo->nField + pPKey2->pKeyInfo->nXField >= - pPKey2->nField || CORRUPT_DB); - assert(pPKey2->pKeyInfo->aSortOrder != 0); - assert(pPKey2->pKeyInfo->nField > 0); - assert(idx1 <= szHdr1 || CORRUPT_DB); - do { - u32 serial_type; - - /* RHS is an integer */ - if (pRhs->flags & MEM_Int) { - serial_type = aKey1[idx1]; - testcase(serial_type == 12); - if (serial_type >= 10) { - rc = +1; - } else if (serial_type == 0) { - rc = -1; - } else if (serial_type == 7) { - sqlite3VdbeSerialGet(&aKey1[d1], serial_type, - &mem1); - rc = -sqlite3IntFloatCompare(pRhs->u.i, - mem1.u.r); - } else { - i64 lhs = - vdbeRecordDecodeInt(serial_type, - &aKey1[d1]); - i64 rhs = pRhs->u.i; - if (lhs < rhs) { - rc = -1; - } else if (lhs > rhs) { - rc = +1; - } - } - } - - /* RHS is real */ - else if (pRhs->flags & MEM_Real) { - serial_type = aKey1[idx1]; - if (serial_type >= 10) { - /* Serial types 12 or greater are strings and blobs (greater than - * numbers). Types 10 and 11 are currently "reserved for future - * use", so it doesn't really matter what the results of comparing - * them to numberic values are. - */ - rc = +1; - } else if (serial_type == 0) { - rc = -1; - } else { - sqlite3VdbeSerialGet(&aKey1[d1], serial_type, - &mem1); - if (serial_type == 7) { - if (mem1.u.r < pRhs->u.r) { - rc = -1; - } else if (mem1.u.r > pRhs->u.r) { - rc = +1; - } - } else { - rc = sqlite3IntFloatCompare(mem1.u.i, - pRhs->u.r); - } - } - } - - /* RHS is a string */ - else if (pRhs->flags & MEM_Str) { - getVarint32(&aKey1[idx1], serial_type); - testcase(serial_type == 12); - if (serial_type < 12) { - rc = -1; - } else if (!(serial_type & 0x01)) { - rc = +1; - } else { - mem1.n = (serial_type - 12) / 2; - testcase((d1 + mem1.n) == (unsigned)nKey1); - testcase((d1 + mem1.n + 1) == (unsigned)nKey1); - if ((d1 + mem1.n) > (unsigned)nKey1) { - pPKey2->errCode = - (u8) SQLITE_CORRUPT_BKPT; - return 0; /* Corruption */ - } else if (pKeyInfo->aColl[i]) { - mem1.db = pKeyInfo->db; - mem1.flags = MEM_Str; - mem1.z = (char *)&aKey1[d1]; - rc = vdbeCompareMemString(&mem1, pRhs, - pKeyInfo-> - aColl[i], - &pPKey2-> - errCode); - } else { - int nCmp = MIN(mem1.n, pRhs->n); - rc = memcmp(&aKey1[d1], pRhs->z, nCmp); - if (rc == 0) - rc = mem1.n - pRhs->n; - } - } - } - - /* RHS is a blob */ - else if (pRhs->flags & MEM_Blob) { - assert((pRhs->flags & MEM_Zero) == 0 || pRhs->n == 0); - getVarint32(&aKey1[idx1], serial_type); - testcase(serial_type == 12); - if (serial_type < 12 || (serial_type & 0x01)) { - rc = -1; - } else { - int nStr = (serial_type - 12) / 2; - testcase((d1 + nStr) == (unsigned)nKey1); - testcase((d1 + nStr + 1) == (unsigned)nKey1); - if ((d1 + nStr) > (unsigned)nKey1) { - pPKey2->errCode = - (u8) SQLITE_CORRUPT_BKPT; - return 0; /* Corruption */ - } else if (pRhs->flags & MEM_Zero) { - if (!isAllZero - ((const char *)&aKey1[d1], nStr)) { - rc = 1; - } else { - rc = nStr - pRhs->u.nZero; - } - } else { - int nCmp = MIN(nStr, pRhs->n); - rc = memcmp(&aKey1[d1], pRhs->z, nCmp); - if (rc == 0) - rc = nStr - pRhs->n; - } - } - } - - /* RHS is null */ - else { - serial_type = aKey1[idx1]; - rc = (serial_type != 0); - } - - if (rc != 0) { - if (pKeyInfo->aSortOrder[i]) { - rc = -rc; - } - assert(vdbeRecordCompareDebug - (nKey1, pKey1, pPKey2, rc)); - assert(mem1.szMalloc == 0); /* See comment below */ - return rc; - } - - i++; - pRhs++; - d1 += sqlite3VdbeSerialTypeLen(serial_type); - idx1 += sqlite3VarintLen(serial_type); - } while (idx1 < (unsigned)szHdr1 && i < pPKey2->nField - && d1 <= (unsigned)nKey1); - - /* No memory allocation is ever used on mem1. Prove this using - * the following assert(). If the assert() fails, it indicates a - * memory leak and a need to call sqlite3VdbeMemRelease(&mem1). - */ - assert(mem1.szMalloc == 0); - - /* rc==0 here means that one or both of the keys ran out of fields and - * all the fields up to that point were equal. Return the default_rc - * value. - */ - assert(CORRUPT_DB - || vdbeRecordCompareDebug(nKey1, pKey1, pPKey2, - pPKey2->default_rc) - || pKeyInfo->db->mallocFailed); - pPKey2->eqSeen = 1; - return pPKey2->default_rc; -} - -int -sqlite3VdbeRecordCompare(int nKey1, const void *pKey1, /* Left key */ - UnpackedRecord * pPKey2) /* Right key */ -{ - return sqlite3VdbeRecordCompareWithSkip(nKey1, pKey1, pPKey2, 0); -} - -/* - * Return a pointer to an sqlite3VdbeRecordCompare() compatible function - * suitable for comparing serialized records to the unpacked record passed - * as the only argument. - */ -RecordCompare -sqlite3VdbeFindCompare(UnpackedRecord * p) -{ - (void)p; - return sqlite3VdbeRecordCompareMsgpack; -} - -/* - * Compare the key of the index entry that cursor pC is pointing to against - * the key string in pUnpacked. Write into *pRes a number - * that is negative, zero, or positive if pC is less than, equal to, - * or greater than pUnpacked. Return SQLITE_OK on success. - */ -int -sqlite3VdbeIdxKeyCompare(sqlite3 * db, /* Database connection */ - VdbeCursor * pC, /* The cursor to compare against */ - UnpackedRecord * pUnpacked, /* Unpacked version of key */ - int *res) /* Write the comparison result here */ -{ - (void)db; - BtCursor *pCur; - - assert(pC->eCurType == CURTYPE_TARANTOOL); - pCur = pC->uc.pCursor; - assert(sqlite3CursorIsValid(pCur)); - if (pCur->curFlags & BTCF_TaCursor || - pCur->curFlags & BTCF_TEphemCursor) { - return tarantoolSqlite3IdxKeyCompare(pCur, pUnpacked, res); - } - unreachable(); - return SQLITE_OK; -} - /* * This routine sets the value to be returned by subsequent calls to * sqlite3_changes() on the database handle 'db'. -- 2.15.1