[tarantool-patches] [PATCH] sql: remove unused VDBE routine

[Nikita Pettik <korablev@tarantool.org>]

---
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; i<r.nField; i++) assert(memIsValid(&r.aMem[i])); }
 #endif
 	res = 0;  /* Not needed.  Only used to silence a warning. */
-	rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
+	rc =  tarantoolSqlite3IdxKeyCompare(pC->uc.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