int compare(const LevelDBSlice& a, const LevelDBSlice& b, bool indexKeys)
{
const char* ptrA = a.begin();
const char* ptrB = b.begin();
const char* endA = a.end();
const char* endB = b.end();
KeyPrefix prefixA;
KeyPrefix prefixB;
ptrA = KeyPrefix::decode(ptrA, endA, &prefixA);
ptrB = KeyPrefix::decode(ptrB, endB, &prefixB);
ASSERT(ptrA);
ASSERT(ptrB);
if (int x = prefixA.compare(prefixB))
return x;
if (prefixA.type() == KeyPrefix::GlobalMetaData) {
ASSERT(ptrA != endA);
ASSERT(ptrB != endB);
unsigned char typeByteA = *ptrA++;
unsigned char typeByteB = *ptrB++;
if (int x = typeByteA - typeByteB)
return x;
if (typeByteA <= 1)
return 0;
if (typeByteA == DatabaseFreeListTypeByte)
return decodeAndCompare<DatabaseFreeListKey>(a, b);
if (typeByteA == DatabaseNameTypeByte)
return decodeAndCompare<DatabaseNameKey>(a, b);
}
if (prefixA.type() == KeyPrefix::DatabaseMetaData) {
ASSERT(ptrA != endA);
ASSERT(ptrB != endB);
unsigned char typeByteA = *ptrA++;
unsigned char typeByteB = *ptrB++;
if (int x = typeByteA - typeByteB)
return x;
if (typeByteA <= 3)
return 0;
if (typeByteA == ObjectStoreMetaDataTypeByte)
return decodeAndCompare<ObjectStoreMetaDataKey>(a, b);
if (typeByteA == IndexMetaDataTypeByte)
return decodeAndCompare<IndexMetaDataKey>(a, b);
if (typeByteA == ObjectStoreFreeListTypeByte)
return decodeAndCompare<ObjectStoreFreeListKey>(a, b);
if (typeByteA == IndexFreeListTypeByte)
return decodeAndCompare<IndexFreeListKey>(a, b);
if (typeByteA == ObjectStoreNamesTypeByte)
return decodeAndCompare<ObjectStoreNamesKey>(a, b);
if (typeByteA == IndexNamesKeyTypeByte)
return decodeAndCompare<IndexNamesKey>(a, b);
return 0;
ASSERT_NOT_REACHED();
}
if (prefixA.type() == KeyPrefix::ObjectStoreData) {
if (ptrA == endA && ptrB == endB)
return 0;
if (ptrA == endA)
return -1;
if (ptrB == endB)
return 1; // FIXME: This case of non-existing user keys should not have to be handled this way.
return decodeAndCompare<ObjectStoreDataKey>(a, b);
}
if (prefixA.type() == KeyPrefix::ExistsEntry) {
if (ptrA == endA && ptrB == endB)
return 0;
if (ptrA == endA)
return -1;
if (ptrB == endB)
return 1; // FIXME: This case of non-existing user keys should not have to be handled this way.
return decodeAndCompare<ExistsEntryKey>(a, b);
}
if (prefixA.type() == KeyPrefix::IndexData) {
if (ptrA == endA && ptrB == endB)
return 0;
if (ptrA == endA)
return -1;
if (ptrB == endB)
return 1; // FIXME: This case of non-existing user keys should not have to be handled this way.
IndexDataKey indexDataKeyA;
IndexDataKey indexDataKeyB;
ptrA = IndexDataKey::decode(a.begin(), endA, &indexDataKeyA);
ptrB = IndexDataKey::decode(b.begin(), endB, &indexDataKeyB);
ASSERT(ptrA);
ASSERT(ptrB);
bool ignoreDuplicates = indexKeys;
return indexDataKeyA.compare(indexDataKeyB, ignoreDuplicates);
}
ASSERT_NOT_REACHED();
return 0;
}
static leveldb::Slice makeSlice(const LevelDBSlice& s)
{
return leveldb::Slice(s.begin(), s.end() - s.begin());
}
static void initVector(const LevelDBSlice& slice, Vector<char>* vector)
{
vector->clear();
vector->append(slice.begin(), slice.end() - slice.begin());
}
