ART index wrapper

Author: pmenon

src/common/init.cpp

@@ -22,6 +22,7 @@
 #include "common/thread_pool.h"
 #include "concurrency/transaction_manager_factory.h"
 #include "gc/gc_manager_factory.h"
+#include "index/index.h"
 #include "settings/settings_manager.h"
 #include "threadpool/mono_queue_pool.h"
 

src/gc/transaction_level_gc_manager.cpp

@@ -18,6 +18,7 @@
 #include "concurrency/epoch_manager_factory.h"
 #include "concurrency/transaction_manager_factory.h"
 #include "settings/settings_manager.h"
+#include "index/index.h"
 #include "storage/database.h"
 #include "storage/tile_group.h"
 #include "storage/tuple.h"

src/include/index/art_index.h

@@ -0,0 +1,146 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// art_index.h
+//
+// Identification: src/include/index/art_index.h
+//
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "adaptive_radix_tree/Tree.h"
+#include "index/index.h"
+
+namespace peloton {
+namespace index {
+
+//===----------------------------------------------------------------------===//
+//
+// An Adaptive Radix Tree (ART) based index.
+//
+//===----------------------------------------------------------------------===//
+class ArtIndex : public Index {
+  friend class IndexFactory;
+
+ public:
+  explicit ArtIndex(IndexMetadata *metadata);
+
+  // Forward declare iterator class for later
+  class Iterator;
+
+  /// Insert the given key-value pair into the index
+  bool InsertEntry(const storage::Tuple *key, ItemPointer *value) override;
+
+  /// Delete the given key-value pair from the index
+  bool DeleteEntry(const storage::Tuple *key, ItemPointer *value) override;
+
+  /// Insert the given key-value pair into the index, but only if the predicate
+  /// returns false for every instance of the given key in the index
+  bool CondInsertEntry(const storage::Tuple *key, ItemPointer *value,
+                       std::function<bool(const void *)> predicate) override;
+
+  /// Scan the range of keys between [start,end] inclusive, placing results in
+  /// the provided result vector
+  void ScanRange(const storage::Tuple *start, const storage::Tuple *end,
+                 std::vector<ItemPointer *> &result);
+
+  /// Perform a scan, using the predicate, and place the results into the
+  /// provided result vector
+  void Scan(const std::vector<type::Value> &values,
+            const std::vector<oid_t> &key_column_ids,
+            const std::vector<ExpressionType> &expr_types,
+            ScanDirectionType scan_direction,
+            std::vector<ItemPointer *> &result,
+            const ConjunctionScanPredicate *scan_predicate) override;
+
+  /// Perform a limited scan
+  void ScanLimit(const std::vector<type::Value> &values,
+                 const std::vector<oid_t> &key_column_ids,
+                 const std::vector<ExpressionType> &expr_types,
+                 ScanDirectionType scan_direction,
+                 std::vector<ItemPointer *> &result,
+                 const ConjunctionScanPredicate *scan_predicate, uint64_t limit,
+                 uint64_t offset) override;
+
+  /// Scan the entire index, placing results in the provided result vector
+  void ScanAllKeys(std::vector<ItemPointer *> &result) override;
+
+  /// Scan all values for the given key, placing results in the provided vector
+  void ScanKey(const storage::Tuple *key,
+               std::vector<ItemPointer *> &result) override;
+
+  /// Return the index type
+  std::string GetTypeName() const override {
+    return IndexTypeToString(GetIndexMethodType());
+  }
+
+  // TODO(pmenon): Implement me
+  size_t GetMemoryFootprint() override { return 0; }
+
+  /// Does the index need GC
+  // TODO(pmenon): Implement me
+  bool NeedGC() override { return false; }
+
+  /// Perform any necessary GC on the index
+  // TODO(pmenon): Implement me
+  void PerformGC() override {}
+
+  /// These two functions are for testing so we can inject custom key loading
+  /// functions without bringing up a full-blown database/table.
+  void SetLoadKeyFunc(art::Tree::LoadKeyFunction load_func, void *ctx);
+
+  /// Construct an ART key from a Peloton key
+  void ConstructArtKey(const AbstractTuple &tuple, art::Key &key) const {
+    key_constructor_.ConstructKey(tuple, key);
+  }
+
+ private:
+  void ScanRange(const art::Key &start, const art::Key &end,
+                 std::vector<ItemPointer *> &result);
+
+  //===--------------------------------------------------------------------===//
+  //
+  // Helper class to construct an art::Key from a Peloton key.
+  //
+  //===--------------------------------------------------------------------===//
+  class KeyConstructor {
+   public:
+    explicit KeyConstructor(const catalog::Schema &key_schema)
+        : key_schema_(key_schema) {}
+
+    /// Given an input Peloton key, construct an equivalent art::Key
+    void ConstructKey(const AbstractTuple &input_key, art::Key &tree_key) const;
+
+    /// Generate the minimum and maximum key
+    void ConstructMinMaxKey(art::Key &min_key, art::Key &max_key) const;
+
+   private:
+    template <typename NativeType>
+    static NativeType FlipSign(NativeType val);
+
+    // Write the provided integral data type into the buffer
+    template <typename NativeType>
+    static void WriteValue(uint8_t *data, NativeType val);
+
+    // Write a specified number of ASCII characters into the output buffer
+    static void WriteAsciiString(uint8_t *data, const char *val, uint32_t len);
+
+   private:
+    // The index's key schema
+    const catalog::Schema &key_schema_;
+  };
+
+ private:
+  // ART
+  art::Tree container_;
+
+  // Key constructor
+  KeyConstructor key_constructor_;
+};
+
+}  // namespace index
+}  // namespace peloton

src/include/index/index.h

@@ -32,11 +32,11 @@ class AbstractTuple;
 
 namespace catalog {
 class Schema;
-}
+}  // namespace catalog
 
 namespace storage {
 class Tuple;
-}
+}  // namespace storage
 
 namespace index {
 
@@ -69,78 +69,56 @@ class IndexMetadata : public Printable {
 
   const std::string &GetName() const { return name_; }
 
-  inline oid_t GetOid() { return index_oid; }
+  oid_t GetOid() { return index_oid; }
 
-  inline oid_t GetTableOid() { return table_oid; }
+  oid_t GetTableOid() { return table_oid; }
 
-  inline oid_t GetDatabaseOid() { return database_oid; }
+  oid_t GetDatabaseOid() { return database_oid; }
 
-  inline IndexType GetIndexType() { return index_type_; }
+  IndexType GetIndexType() { return index_type_; }
 
   IndexConstraintType GetIndexConstraintType() {
     return index_constraint_type_;
   }
 
-  /*
-   * Returns a schema object pointer that represents
-   * the schema of indexed columns, from leading column
-   * to the least important columns
-   */
-  inline const catalog::Schema *GetKeySchema() const { return key_schema; }
+  // Returns a schema object pointer that represents the schema of indexed
+  // columns, from leading column to the least important columns.
+  const catalog::Schema *GetKeySchema() const { return key_schema; }
 
-  /*
-   * Returns a schema object pointer that represents
-   * the schema of the underlying table
-   */
-  inline const catalog::Schema *GetTupleSchema() const { return tuple_schema; }
+  // Returns a schema object that represents the schema of the underlying table
+  const catalog::Schema *GetTupleSchema() const { return tuple_schema; }
 
   // Return the number of columns inside index key (not in tuple key)
-  //
-  // Note that this must be defined inside the cpp source file
-  // because it uses the member of catalog::Schema which is not known here
   oid_t GetColumnCount() const;
 
   bool HasUniqueKeys() const { return unique_keys; }
 
-  /*
-   * GetKeyAttrs() - Returns the mapping relation between indexed columns
-   *                 and base table columns
-   *
-   * The return value is a const vector reference
-   *
-   * The entry whose value is j on index i means the i-th column in the
-   * key is mapped to the j-th column in the base table tuple
-   */
-  inline const std::vector<oid_t> &GetKeyAttrs() const { return key_attrs; }
+  // Returns the mapping relation between indexed columns and base table columns
+  // The entry whose value is j on index i means the i-th column in the key is
+  // mapped to the j-th column in the base table tuple
+  const std::vector<oid_t> &GetKeyAttrs() const { return key_attrs; }
 
-  /*
-   * GetTupleToIndexMapping() - Returns the mapping relation between tuple key
-   *                            column and index key columns
-   */
-  inline const std::vector<oid_t> &GetTupleToIndexMapping() const {
+  // Returns the mapping relation between tuple key column and index key columns
+  const std::vector<oid_t> &GetTupleToIndexMapping() const {
     return tuple_attrs;
   }
 
-  inline double GetUtility() const { return utility_ratio; }
+  double GetUtility() const { return utility_ratio; }
 
-  inline void SetUtility(double p_utility_ratio) {
-    utility_ratio = p_utility_ratio;
-  }
+  void SetUtility(double p_utility_ratio) { utility_ratio = p_utility_ratio; }
 
-  inline bool GetVisibility() const { return (visible_); }
+  bool GetVisibility() const { return (visible_); }
 
-  inline void SetVisibility(bool visibile) { visible_ = visibile; }
+  void SetVisibility(bool visible) { visible_ = visible; }
 
-  /*
-   * GetInfo() - Get a string representation for debugging
-   */
-  const std::string GetInfo() const;
+  // Get a string representation for debugging
+  const std::string GetInfo() const override;
 
   //===--------------------------------------------------------------------===//
   // STATIC HELPERS
   //===--------------------------------------------------------------------===//
 
-  static inline void SetDefaultVisibleFlag(bool flag) {
+  static void SetDefaultVisibleFlag(bool flag) {
     LOG_DEBUG("Set IndexMetadata visible flag to '%s'",
               (flag ? "true" : "false"));
     index_default_visibility = flag;
@@ -336,9 +314,9 @@ class Index : public Printable {
   virtual void ScanKey(const storage::Tuple *key,
                        std::vector<ItemPointer *> &result) = 0;
 
-  ///////////////////////////////////////////////////////////////////
-  // Garbage Collection
-  ///////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////
+  /// Garbage Collection
+  //////////////////////////////////////////////////////////////////////////////
 
   // This gives a hint on whether GC is needed on the index
   // For those that do not need GC this always return false
@@ -348,17 +326,9 @@ class Index : public Printable {
   // For those that do not need GC this should return immediately
   virtual void PerformGC() = 0;
 
-  // The following two are used to perform GC in a
-  // fast manner
-  // Because if we register for epoch for every operation then
-  // essentially we are synchronizing on each operation which does
-  // not scale at all
-  // virtual void *JoinEpoch() = 0;
-  // virtual void LeaveEpoch(void *) = 0;
-
-  //===--------------------------------------------------------------------===//
-  // STATS
-  //===--------------------------------------------------------------------===//
+  //////////////////////////////////////////////////////////////////////////////
+  /// Stats
+  //////////////////////////////////////////////////////////////////////////////
 
   void IncreaseNumberOfTuplesBy(const size_t amount);
 
@@ -372,9 +342,9 @@ class Index : public Printable {
 
   void ResetDirty();
 
-  //===--------------------------------------------------------------------===//
-  // Utilities
-  //===--------------------------------------------------------------------===//
+  //////////////////////////////////////////////////////////////////////////////
+  /// Utilities
+  //////////////////////////////////////////////////////////////////////////////
 
   virtual std::string GetTypeName() const = 0;
 
@@ -393,6 +363,8 @@ class Index : public Printable {
     return metadata->GetKeySchema();
   }
 
+  IndexType GetIndexMethodType() const { return metadata->GetIndexType(); }
+
   IndexConstraintType GetIndexType() const {
     return metadata->GetIndexConstraintType();
   }
@@ -420,8 +392,6 @@ class Index : public Printable {
 
   virtual void IncrementIndexedTileGroupOffset() {
     indexed_tile_group_offset++;
-
-    return;
   }
 
  protected:

src/include/storage/data_table.h

@@ -21,8 +21,6 @@
 #include "common/item_pointer.h"
 #include "common/platform.h"
 #include "common/container/lock_free_array.h"
-#include "executor/executor_context.h"
-#include "index/index.h"
 #include "storage/abstract_table.h"
 #include "storage/indirection_array.h"
 #include "trigger/trigger.h"
@@ -37,23 +35,23 @@ namespace peloton {
 
 namespace brain {
 class Sample;
-}
+}  // namespace brain
 
 namespace catalog {
 class ForeignKey;
-}
+}  // namespace catalog
 
 namespace index {
 class Index;
-}
+}  // namespace index
 
 namespace logging {
 class LogManager;
-}
+}  // namespace logging
 
 namespace concurrency {
 class TransactionContext;
-}
+}  // namespace concurrency
 
 namespace storage {