Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Move RocksDBEntryType to separate file

This commit is contained in:
Jan Christoph Uhde 2017-03-22 13:38:03 +01:00
parent 66423f97dc
commit d93d154053
4 changed files with 118 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
arangod/RocksDBEngine/RocksDBComparator.cpp
View File

@ -42,30 +42,30 @@ int RocksDBComparator::Compare(rocksdb::Slice const& lhs,
return result; return result;
} }
RocksDBEntry::Type type = static_cast<RocksDBEntry::Type>(lhs[0]); RocksDBEntryType type = static_cast<RocksDBEntryType>(lhs[0]);
switch (type) { switch (type) {
case RocksDBEntry::Type::Database: { case RocksDBEntryType::Database: {
return compareDatabases(lhs, rhs); return compareDatabases(lhs, rhs);
} }
case RocksDBEntry::Type::Collection: { case RocksDBEntryType::Collection: {
return compareCollections(lhs, rhs); return compareCollections(lhs, rhs);
} }
case RocksDBEntry::Type::Index: { case RocksDBEntryType::Index: {
return compareIndices(lhs, rhs); return compareIndices(lhs, rhs);
} }
case RocksDBEntry::Type::Document: { case RocksDBEntryType::Document: {
return compareDocuments(lhs, rhs); return compareDocuments(lhs, rhs);
} }
case RocksDBEntry::Type::IndexValue: { case RocksDBEntryType::IndexValue: {
return compareIndexValues(lhs, rhs); return compareIndexValues(lhs, rhs);
} }
case RocksDBEntry::Type::UniqueIndexValue: { case RocksDBEntryType::UniqueIndexValue: {
return compareUniqueIndexValues(lhs, rhs); return compareUniqueIndexValues(lhs, rhs);
} }
case RocksDBEntry::Type::View: { case RocksDBEntryType::View: {
return compareViews(lhs, rhs); return compareViews(lhs, rhs);
} }
case RocksDBEntry::Type::CrossReference: { case RocksDBEntryType::CrossReference: {
return compareCrossReferences(lhs, rhs); return compareCrossReferences(lhs, rhs);
} }
default: { return compareLexicographic(lhs, rhs); } default: { return compareLexicographic(lhs, rhs); }
@ -159,13 +159,13 @@ int RocksDBComparator::compareCrossReferences(rocksdb::Slice const& lhs,
return result; return result;
} }
RocksDBEntry::Type subtype = static_cast<RocksDBEntry::Type>(lhs[offset]); RocksDBEntryType subtype = static_cast<RocksDBEntryType>(lhs[offset]);
switch (subtype) { switch (subtype) {
case RocksDBEntry::Type::Collection: case RocksDBEntryType::Collection:
return compareCrossReferenceCollections(lhs, rhs); return compareCrossReferenceCollections(lhs, rhs);
case RocksDBEntry::Type::Index: case RocksDBEntryType::Index:
return compareCrossReferenceIndices(lhs, rhs); return compareCrossReferenceIndices(lhs, rhs);
case RocksDBEntry::Type::View: case RocksDBEntryType::View:
return compareCrossReferenceViews(lhs, rhs); return compareCrossReferenceViews(lhs, rhs);
default: default:
return compareLexicographic(lhs, rhs); return compareLexicographic(lhs, rhs);

110
arangod/RocksDBEngine/RocksDBEntry.cpp
View File

@ -29,61 +29,61 @@ using namespace arangodb;
using namespace arangodb::velocypack; using namespace arangodb::velocypack;
RocksDBEntry RocksDBEntry::Database(uint64_t id, VPackSlice const& data) { RocksDBEntry RocksDBEntry::Database(uint64_t id, VPackSlice const& data) {
return RocksDBEntry(Type::Database, id, 0, data); return RocksDBEntry(RocksDBEntryType::Database, id, 0, data);
} }
RocksDBEntry RocksDBEntry::Collection(uint64_t id, VPackSlice const& data) { RocksDBEntry RocksDBEntry::Collection(uint64_t id, VPackSlice const& data) {
return RocksDBEntry(Type::Collection, id, 0, data); return RocksDBEntry(RocksDBEntryType::Collection, id, 0, data);
} }
RocksDBEntry RocksDBEntry::Index(uint64_t id, VPackSlice const& data) { RocksDBEntry RocksDBEntry::Index(uint64_t id, VPackSlice const& data) {
return RocksDBEntry(Type::Index, id, 0, data); return RocksDBEntry(RocksDBEntryType::Index, id, 0, data);
} }
RocksDBEntry RocksDBEntry::Document(uint64_t collectionId, uint64_t revisionId, RocksDBEntry RocksDBEntry::Document(uint64_t collectionId, uint64_t revisionId,
VPackSlice const& data) { VPackSlice const& data) {
return RocksDBEntry(Type::Document, collectionId, revisionId, data); return RocksDBEntry(RocksDBEntryType::Document, collectionId, revisionId, data);
} }
RocksDBEntry RocksDBEntry::IndexValue(uint64_t indexId, uint64_t revisionId, RocksDBEntry RocksDBEntry::IndexValue(uint64_t indexId, uint64_t revisionId,
VPackSlice const& indexValues) { VPackSlice const& indexValues) {
return RocksDBEntry(Type::IndexValue, indexId, revisionId, indexValues); return RocksDBEntry(RocksDBEntryType::IndexValue, indexId, revisionId, indexValues);
} }
RocksDBEntry RocksDBEntry::UniqueIndexValue(uint64_t indexId, RocksDBEntry RocksDBEntry::UniqueIndexValue(uint64_t indexId,
uint64_t revisionId, uint64_t revisionId,
VPackSlice const& indexValues) { VPackSlice const& indexValues) {
return RocksDBEntry(Type::UniqueIndexValue, indexId, revisionId, indexValues); return RocksDBEntry(RocksDBEntryType::UniqueIndexValue, indexId, revisionId, indexValues);
} }
RocksDBEntry RocksDBEntry::View(uint64_t id, VPackSlice const& data) { RocksDBEntry RocksDBEntry::View(uint64_t id, VPackSlice const& data) {
return RocksDBEntry(Type::View, id, 0, data); return RocksDBEntry(RocksDBEntryType::View, id, 0, data);
} }
RocksDBEntry RocksDBEntry::CrossReferenceCollection(uint64_t databaseId, RocksDBEntry RocksDBEntry::CrossReferenceCollection(uint64_t databaseId,
uint64_t collectionId) { uint64_t collectionId) {
return RocksDBEntry(Type::CrossReference, Type::Collection, databaseId, return RocksDBEntry(RocksDBEntryType::CrossReference, RocksDBEntryType::Collection, databaseId,
collectionId); collectionId);
} }
RocksDBEntry RocksDBEntry::CrossReferenceIndex(uint64_t databaseId, RocksDBEntry RocksDBEntry::CrossReferenceIndex(uint64_t databaseId,
uint64_t collectionId, uint64_t collectionId,
uint64_t indexId) { uint64_t indexId) {
return RocksDBEntry(Type::CrossReference, Type::Index, databaseId, return RocksDBEntry(RocksDBEntryType::CrossReference, RocksDBEntryType::Index, databaseId,
collectionId, indexId); collectionId, indexId);
} }
RocksDBEntry RocksDBEntry::CrossReferenceView(uint64_t databaseId, RocksDBEntry RocksDBEntry::CrossReferenceView(uint64_t databaseId,
uint64_t viewId) { uint64_t viewId) {
return RocksDBEntry(Type::CrossReference, Type::View, databaseId, viewId); return RocksDBEntry(RocksDBEntryType::CrossReference, RocksDBEntryType::View, databaseId, viewId);
} }
RocksDBEntry::Type RocksDBEntry::type() const { return _type; } RocksDBEntryType RocksDBEntry::type() const { return _type; }
uint64_t RocksDBEntry::databaseId() const { uint64_t RocksDBEntry::databaseId() const {
switch (_type) { switch (_type) {
case Type::Database: case RocksDBEntryType::Database:
case Type::CrossReference: { case RocksDBEntryType::CrossReference: {
return *reinterpret_cast<uint64_t const*>(_keyBuffer.data() + return *reinterpret_cast<uint64_t const*>(_keyBuffer.data() +
sizeof(char)); sizeof(char));
} }
@ -95,16 +95,16 @@ uint64_t RocksDBEntry::databaseId() const {
uint64_t RocksDBEntry::collectionId() const { uint64_t RocksDBEntry::collectionId() const {
switch (_type) { switch (_type) {
case Type::Collection: case RocksDBEntryType::Collection:
case Type::Document: { case RocksDBEntryType::Document: {
return *reinterpret_cast<uint64_t const*>(_keyBuffer.data() + return *reinterpret_cast<uint64_t const*>(_keyBuffer.data() +
sizeof(char)); sizeof(char));
} }
case Type::CrossReference: { case RocksDBEntryType::CrossReference: {
Type subtype = RocksDBEntryType subtype =
*reinterpret_cast<Type const*>(_keyBuffer.data() + sizeof(char)); *reinterpret_cast<RocksDBEntryType const*>(_keyBuffer.data() + sizeof(char));
if ((subtype == Type::Collection) || (subtype == Type::Index)) { if ((subtype == RocksDBEntryType::Collection) || (subtype == RocksDBEntryType::Index)) {
return *reinterpret_cast<uint64_t const*>( return *reinterpret_cast<uint64_t const*>(
_keyBuffer.data() + (2 * sizeof(char)) + sizeof(uint64_t)); _keyBuffer.data() + (2 * sizeof(char)) + sizeof(uint64_t));
} else { } else {
@ -119,17 +119,17 @@ uint64_t RocksDBEntry::collectionId() const {
uint64_t RocksDBEntry::indexId() const { uint64_t RocksDBEntry::indexId() const {
switch (_type) { switch (_type) {
case Type::Index: case RocksDBEntryType::Index:
case Type::IndexValue: case RocksDBEntryType::IndexValue:
case Type::UniqueIndexValue: { case RocksDBEntryType::UniqueIndexValue: {
return *reinterpret_cast<uint64_t const*>(_keyBuffer.data() + return *reinterpret_cast<uint64_t const*>(_keyBuffer.data() +
sizeof(char)); sizeof(char));
} }
case Type::CrossReference: { case RocksDBEntryType::CrossReference: {
Type subtype = RocksDBEntryType subtype =
*reinterpret_cast<Type const*>(_keyBuffer.data() + sizeof(char)); *reinterpret_cast<RocksDBEntryType const*>(_keyBuffer.data() + sizeof(char));
if (subtype == Type::Index) { if (subtype == RocksDBEntryType::Index) {
return *reinterpret_cast<uint64_t const*>( return *reinterpret_cast<uint64_t const*>(
_keyBuffer.data() + (2 * sizeof(char)) + (2 * sizeof(uint64_t))); _keyBuffer.data() + (2 * sizeof(char)) + (2 * sizeof(uint64_t)));
} else { } else {
@ -144,15 +144,15 @@ uint64_t RocksDBEntry::indexId() const {
uint64_t RocksDBEntry::viewId() const { uint64_t RocksDBEntry::viewId() const {
switch (_type) { switch (_type) {
case Type::View: { case RocksDBEntryType::View: {
return *reinterpret_cast<uint64_t const*>(_keyBuffer.data() + return *reinterpret_cast<uint64_t const*>(_keyBuffer.data() +
sizeof(char)); sizeof(char));
} }
case Type::CrossReference: { case RocksDBEntryType::CrossReference: {
Type subtype = RocksDBEntryType subtype =
*reinterpret_cast<Type const*>(_keyBuffer.data() + sizeof(char)); *reinterpret_cast<RocksDBEntryType const*>(_keyBuffer.data() + sizeof(char));
if (subtype == Type::View) { if (subtype == RocksDBEntryType::View) {
return *reinterpret_cast<uint64_t const*>( return *reinterpret_cast<uint64_t const*>(
_keyBuffer.data() + (2 * sizeof(char)) + sizeof(uint64_t)); _keyBuffer.data() + (2 * sizeof(char)) + sizeof(uint64_t));
} else { } else {
@ -167,17 +167,17 @@ uint64_t RocksDBEntry::viewId() const {
uint64_t RocksDBEntry::revisionId() const { uint64_t RocksDBEntry::revisionId() const {
switch (_type) { switch (_type) {
case Type::Document: { case RocksDBEntryType::Document: {
return *reinterpret_cast<uint64_t const*>( return *reinterpret_cast<uint64_t const*>(
_keyBuffer.data() + sizeof(char) + sizeof(uint64_t)); _keyBuffer.data() + sizeof(char) + sizeof(uint64_t));
} }
case Type::IndexValue: { case RocksDBEntryType::IndexValue: {
return *reinterpret_cast<uint64_t const*>( return *reinterpret_cast<uint64_t const*>(
_keyBuffer.data() + (_keyBuffer.size() - sizeof(uint64_t))); _keyBuffer.data() + (_keyBuffer.size() - sizeof(uint64_t)));
} }
case Type::UniqueIndexValue: { case RocksDBEntryType::UniqueIndexValue: {
return *reinterpret_cast<uint64_t const*>(_valueBuffer.data()); return *reinterpret_cast<uint64_t const*>(_valueBuffer.data());
} }
@ -188,8 +188,8 @@ uint64_t RocksDBEntry::revisionId() const {
VPackSlice const RocksDBEntry::indexedValues() const { VPackSlice const RocksDBEntry::indexedValues() const {
switch (_type) { switch (_type) {
case Type::IndexValue: case RocksDBEntryType::IndexValue:
case Type::UniqueIndexValue: { case RocksDBEntryType::UniqueIndexValue: {
return VPackSlice(*reinterpret_cast<VPackSlice const*>( return VPackSlice(*reinterpret_cast<VPackSlice const*>(
_keyBuffer.data() + sizeof(char) + sizeof(uint64_t))); _keyBuffer.data() + sizeof(char) + sizeof(uint64_t)));
} }
@ -201,11 +201,11 @@ VPackSlice const RocksDBEntry::indexedValues() const {
VPackSlice const RocksDBEntry::data() const { VPackSlice const RocksDBEntry::data() const {
switch (_type) { switch (_type) {
case Type::Database: case RocksDBEntryType::Database:
case Type::Collection: case RocksDBEntryType::Collection:
case Type::Index: case RocksDBEntryType::Index:
case Type::Document: case RocksDBEntryType::Document:
case Type::View: { case RocksDBEntryType::View: {
return VPackSlice( return VPackSlice(
*reinterpret_cast<VPackSlice const*>(_valueBuffer.data())); *reinterpret_cast<VPackSlice const*>(_valueBuffer.data()));
} }
@ -221,14 +221,14 @@ std::string const& RocksDBEntry::value() const { return _valueBuffer; }
std::string& RocksDBEntry::valueBuffer() { return _valueBuffer; } std::string& RocksDBEntry::valueBuffer() { return _valueBuffer; }
RocksDBEntry::RocksDBEntry(RocksDBEntry::Type type, RocksDBEntry::Type subtype, RocksDBEntry::RocksDBEntry(RocksDBEntryType type, RocksDBEntryType subtype,
uint64_t first, uint64_t second, uint64_t third) uint64_t first, uint64_t second, uint64_t third)
: _type(type), _keyBuffer(), _valueBuffer() { : _type(type), _keyBuffer(), _valueBuffer() {
TRI_ASSERT(_type == Type::CrossReference); TRI_ASSERT(_type == RocksDBEntryType::CrossReference);
switch (subtype) { switch (subtype) {
case Type::Collection: case RocksDBEntryType::Collection:
case Type::View: { case RocksDBEntryType::View: {
size_t length = (2 * sizeof(char)) + (2 * sizeof(uint64_t)); size_t length = (2 * sizeof(char)) + (2 * sizeof(uint64_t));
_keyBuffer.reserve(length); _keyBuffer.reserve(length);
_keyBuffer.push_back(static_cast<char>(_type)); _keyBuffer.push_back(static_cast<char>(_type));
@ -239,7 +239,7 @@ RocksDBEntry::RocksDBEntry(RocksDBEntry::Type type, RocksDBEntry::Type subtype,
break; break;
} }
case Type::Index: { case RocksDBEntryType::Index: {
size_t length = (2 * sizeof(char)) + (3 * sizeof(uint64_t)); size_t length = (2 * sizeof(char)) + (3 * sizeof(uint64_t));
_keyBuffer.reserve(length); _keyBuffer.reserve(length);
_keyBuffer.push_back(static_cast<char>(_type)); _keyBuffer.push_back(static_cast<char>(_type));
@ -256,15 +256,15 @@ RocksDBEntry::RocksDBEntry(RocksDBEntry::Type type, RocksDBEntry::Type subtype,
} }
} }
RocksDBEntry::RocksDBEntry(RocksDBEntry::Type type, uint64_t first, RocksDBEntry::RocksDBEntry(RocksDBEntryType type, uint64_t first,
uint64_t second, VPackSlice const& slice) uint64_t second, VPackSlice const& slice)
: _type(type), _keyBuffer(), _valueBuffer() { : _type(type), _keyBuffer(), _valueBuffer() {
TRI_ASSERT(_type != Type::CrossReference); TRI_ASSERT(_type != RocksDBEntryType::CrossReference);
switch (_type) { switch (_type) {
case Type::Database: case RocksDBEntryType::Database:
case Type::Collection: case RocksDBEntryType::Collection:
case Type::Index: case RocksDBEntryType::Index:
case Type::View: { case RocksDBEntryType::View: {
size_t length = sizeof(char) + sizeof(uint64_t); size_t length = sizeof(char) + sizeof(uint64_t);
_keyBuffer.reserve(length); _keyBuffer.reserve(length);
_keyBuffer.push_back(static_cast<char>(_type)); _keyBuffer.push_back(static_cast<char>(_type));
@ -277,7 +277,7 @@ RocksDBEntry::RocksDBEntry(RocksDBEntry::Type type, uint64_t first,
break; break;
} }
case Type::Document: { case RocksDBEntryType::Document: {
size_t length = sizeof(char) + (2 * sizeof(uint64_t)); size_t length = sizeof(char) + (2 * sizeof(uint64_t));
_keyBuffer.reserve(length); _keyBuffer.reserve(length);
_keyBuffer.push_back(static_cast<char>(_type)); _keyBuffer.push_back(static_cast<char>(_type));
@ -291,7 +291,7 @@ RocksDBEntry::RocksDBEntry(RocksDBEntry::Type type, uint64_t first,
break; break;
} }
case Type::IndexValue: { case RocksDBEntryType::IndexValue: {
size_t length = sizeof(char) + static_cast<size_t>(slice.byteSize()) + size_t length = sizeof(char) + static_cast<size_t>(slice.byteSize()) +
(2 * sizeof(uint64_t)); (2 * sizeof(uint64_t));
_keyBuffer.reserve(length); _keyBuffer.reserve(length);
@ -304,7 +304,7 @@ RocksDBEntry::RocksDBEntry(RocksDBEntry::Type type, uint64_t first,
break; break;
} }
case Type::UniqueIndexValue: { case RocksDBEntryType::UniqueIndexValue: {
size_t length = sizeof(char) + static_cast<size_t>(slice.byteSize()) + size_t length = sizeof(char) + static_cast<size_t>(slice.byteSize()) +
sizeof(uint64_t); sizeof(uint64_t);
_keyBuffer.reserve(length); _keyBuffer.reserve(length);

21
arangod/RocksDBEngine/RocksDBEntry.h
View File

@ -25,6 +25,8 @@
#ifndef ARANGO_ROCKSDB_ROCKSDB_ENTRY_H #ifndef ARANGO_ROCKSDB_ROCKSDB_ENTRY_H
#define ARANGO_ROCKSDB_ROCKSDB_ENTRY_H 1 #define ARANGO_ROCKSDB_ROCKSDB_ENTRY_H 1
#include "RocksDBTypes.h"
#include "Basics/Common.h" #include "Basics/Common.h"
#include <velocypack/Slice.h> #include <velocypack/Slice.h>
@ -33,17 +35,6 @@
namespace arangodb { namespace arangodb {
class RocksDBEntry { class RocksDBEntry {
public:
enum class Type : uint8_t {
Database = '0',
Collection = '1',
Index = '2',
Document = '3',
IndexValue = '4',
UniqueIndexValue = '5',
View = '6',
CrossReference = '9'
};
public: public:
RocksDBEntry() = delete; RocksDBEntry() = delete;
@ -67,7 +58,7 @@ class RocksDBEntry {
static RocksDBEntry CrossReferenceView(uint64_t databaseId, uint64_t viewId); static RocksDBEntry CrossReferenceView(uint64_t databaseId, uint64_t viewId);
public: public:
Type type() const; RocksDBEntryType type() const;
uint64_t databaseId() const; uint64_t databaseId() const;
uint64_t collectionId() const; uint64_t collectionId() const;
@ -83,13 +74,13 @@ class RocksDBEntry {
std::string& valueBuffer(); std::string& valueBuffer();
private: private:
RocksDBEntry(Type type, Type subtype, uint64_t first, uint64_t second = 0, RocksDBEntry(RocksDBEntryType type, RocksDBEntryType subtype, uint64_t first, uint64_t second = 0,
uint64_t third = 0); uint64_t third = 0);
RocksDBEntry(Type type, uint64_t first, uint64_t second = 0, RocksDBEntry(RocksDBEntryType type, uint64_t first, uint64_t second = 0,
VPackSlice const& slice = VPackSlice()); VPackSlice const& slice = VPackSlice());
private: private:
const Type _type; const RocksDBEntryType _type;
std::string _keyBuffer; std::string _keyBuffer;
std::string _valueBuffer; std::string _valueBuffer;
}; };

44
arangod/RocksDBEngine/RocksDBTypes.h Normal file
View File

@ -0,0 +1,44 @@
////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2017 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
/// http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Daniel H. Larkin
/// @author Jan Christoph Uhde
////////////////////////////////////////////////////////////////////////////////
#ifndef ARANGO_ROCKSDB_ROCKSDB_TYPES_H
#define ARANGO_ROCKSDB_ROCKSDB_TYPES_H 1
#include <cstdint>
namespace arangodb {
enum class RocksDBEntryType : std::uint8_t {
Database = '0',
Collection = '1',
Index = '2',
Document = '3',
IndexValue = '4',
UniqueIndexValue = '5',
View = '6',
CrossReference = '9'
};
}
#endif