Merge branch 'master' into fedora-llvm

Author: apavlo

CMakeLists.txt

@@ -97,7 +97,20 @@ endif()
 # ---[ Warnings
 peloton_warnings_disable(CMAKE_CXX_FLAGS -Wno-strict-aliasing -Wno-implicit-fallthrough)
 
-# Turn on sanitizers if necessary.
+# ---[ Check if we should use the GNU Gold linker
+set(USE_GOLD true CACHE BOOL "Use the GNU Gold linker if available")
+if (USE_GOLD)
+    execute_process(COMMAND ${CMAKE_C_COMPILER} -fuse-ld=gold -Wl,--version ERROR_QUIET OUTPUT_VARIABLE LD_VERSION)
+    if ("${LD_VERSION}" MATCHES "GNU gold")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fuse-ld=gold -Wl,--disable-new-dtags")
+        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fuse-ld=gold -Wl,--disable-new-dtags")
+    else ()
+        message(WARNING "GNU gold linker isn't available, using the default system linker.")
+        set(USE_LD_GOLD OFF)
+    endif ()
+endif()
+
+# ---[ Turn on sanitizers if necessary.
 if(USE_SANITIZER)
     if (USE_SANITIZER STREQUAL "Address")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
@@ -117,9 +130,6 @@ if(USE_SANITIZER)
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize-address-use-after-scope")
         endif()
     endif()
-    if (CMAKE_COMPILER_IS_GNUCC)
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fuse-ld=gold")
-    endif()
 endif()
 
 # -- [ Coverage

cmake/Targets.cmake

@@ -88,6 +88,9 @@ function(peloton_pickup_peloton_sources root)
   # jsoncpp
   file(GLOB_RECURSE jsoncpp_srcs ${root}/third_party/jsoncpp/*.cpp)
 
+  # ART
+  file(GLOB_RECURSE art_srcs ${root}/third_party/adaptive_radix_tree/*.cpp)
+
   # date
   file(GLOB_RECURSE jsoncpp_srcs ${root}/third_party/date/*.cpp)
   set(date_hdrs ${root}/third_party/date/)
@@ -99,7 +102,7 @@ function(peloton_pickup_peloton_sources root)
 
   # add proto to make them editable in IDEs too
   file(GLOB_RECURSE proto_files ${root}/src/peloton/*.proto)
-  list(APPEND srcs ${proto_files} ${murmur_srcs} ${libcount_srcs} ${libcds_srcs} ${jsoncpp_srcs})
+  list(APPEND srcs ${proto_files} ${murmur_srcs} ${libcount_srcs} ${art_srcs} ${jsoncpp_srcs})
 
   # propogate to parent scope
   set(srcs ${srcs} PARENT_SCOPE)

script/installation/create_certicates.sh renamed to script/installation/create_certificates.sh

@@ -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"
 

script/installation/create_certicates_test.sh renamed to script/installation/create_certificates_test.sh

@@ -6,7 +6,7 @@
 //
 // Identification: src/common/internal_types.cpp
 //
-// Copyright (c) 2015-2017, Carnegie Mellon University Database Group
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
 //
 //===----------------------------------------------------------------------===//
 
@@ -18,7 +18,6 @@
 #include "common/internal_types.h"
 #include "common/logger.h"
 #include "common/macros.h"
-#include "type/value_factory.h"
 #include "parser/sql_statement.h"
 #include "parser/statements.h"
 #include "util/string_util.h"
@@ -529,101 +528,152 @@ std::ostream &operator<<(std::ostream &os, const StatementType &type) {
 // QueryType - String Utilities
 //===--------------------------------------------------------------------===//
 std::string QueryTypeToString(QueryType query_type) {
-  switch(query_type) {
-    case QueryType::QUERY_BEGIN:return "BEGIN";
-    case QueryType::QUERY_COMMIT:return "COMMIT";
-    case QueryType::QUERY_ROLLBACK:return "ROLLBACK";
-    case QueryType::QUERY_CREATE_DB:return "CREATE DATABASE";
-    case QueryType::QUERY_CREATE_INDEX: return "CREATE INDEX";
-    case QueryType::QUERY_CREATE_TABLE: return "CREATE TABLE";
-    case QueryType::QUERY_CREATE_TRIGGER: return "CREATE TRIGGER";
-    case QueryType::QUERY_CREATE_SCHEMA: return "CREATE SCHEMA";
-    case QueryType::QUERY_CREATE_VIEW: return "CREATE VIEW";
-    case QueryType::QUERY_DROP:return "DROP";
-    case QueryType::QUERY_INSERT:return "INSERT";
-    case QueryType::QUERY_SET: return "SET";
-    case QueryType::QUERY_SHOW: return "SHOW";
-    case QueryType::QUERY_UPDATE: return "UPDATE";
-    case QueryType::QUERY_ALTER: return "ALTER";
-    case QueryType::QUERY_DELETE: return "DELETE";
-    case QueryType::QUERY_COPY: return "COPY";
-    case QueryType::QUERY_ANALYZE: return "ANALYZE";
-    case QueryType::QUERY_RENAME: return "RENAME";
-    case QueryType::QUERY_PREPARE: return "PREPARE";
-    case QueryType::QUERY_EXECUTE: return "EXECUTE";
-    case QueryType::QUERY_SELECT: return "SELECT";
-    case QueryType::QUERY_OTHER: default: return "OTHER";
+  switch (query_type) {
+    case QueryType::QUERY_BEGIN:
+      return "BEGIN";
+    case QueryType::QUERY_COMMIT:
+      return "COMMIT";
+    case QueryType::QUERY_ROLLBACK:
+      return "ROLLBACK";
+    case QueryType::QUERY_CREATE_DB:
+      return "CREATE DATABASE";
+    case QueryType::QUERY_CREATE_INDEX:
+      return "CREATE INDEX";
+    case QueryType::QUERY_CREATE_TABLE:
+      return "CREATE TABLE";
+    case QueryType::QUERY_CREATE_TRIGGER:
+      return "CREATE TRIGGER";
+    case QueryType::QUERY_CREATE_SCHEMA:
+      return "CREATE SCHEMA";
+    case QueryType::QUERY_CREATE_VIEW:
+      return "CREATE VIEW";
+    case QueryType::QUERY_DROP:
+      return "DROP";
+    case QueryType::QUERY_INSERT:
+      return "INSERT";
+    case QueryType::QUERY_SET:
+      return "SET";
+    case QueryType::QUERY_SHOW:
+      return "SHOW";
+    case QueryType::QUERY_UPDATE:
+      return "UPDATE";
+    case QueryType::QUERY_ALTER:
+      return "ALTER";
+    case QueryType::QUERY_DELETE:
+      return "DELETE";
+    case QueryType::QUERY_COPY:
+      return "COPY";
+    case QueryType::QUERY_ANALYZE:
+      return "ANALYZE";
+    case QueryType::QUERY_RENAME:
+      return "RENAME";
+    case QueryType::QUERY_PREPARE:
+      return "PREPARE";
+    case QueryType::QUERY_EXECUTE:
+      return "EXECUTE";
+    case QueryType::QUERY_SELECT:
+      return "SELECT";
+    case QueryType::QUERY_OTHER:
+    default:
+      return "OTHER";
   }
 }
 
 QueryType StringToQueryType(const std::string &str) {
-  static std::unordered_map<std::string, QueryType> querytype_string_map {
-      {"BEGIN", QueryType::QUERY_BEGIN}, {"COMMIT", QueryType::QUERY_COMMIT},
-      {"ROLLBACK", QueryType::QUERY_ROLLBACK}, {"CREATE DATABASE", QueryType::QUERY_CREATE_DB},
-      {"CREATE INDEX", QueryType::QUERY_CREATE_INDEX}, {"CREATE TABLE", QueryType::QUERY_CREATE_TABLE},
-      {"DROP", QueryType::QUERY_DROP}, {"INSERT", QueryType::QUERY_INSERT},
-      {"SET", QueryType::QUERY_SET}, {"SHOW", QueryType::QUERY_SHOW},
-      {"SHOW", QueryType::QUERY_SHOW}, {"UPDATE", QueryType::QUERY_UPDATE},
-      {"ALTER", QueryType::QUERY_ALTER}, {"DELETE", QueryType::QUERY_DELETE},
-      {"COPY", QueryType::QUERY_COPY}, {"ANALYZE", QueryType::QUERY_ANALYZE},
-      {"RENAME", QueryType::QUERY_RENAME}, {"PREPARE", QueryType::QUERY_PREPARE},
-      {"EXECUTE", QueryType::QUERY_EXECUTE}, {"SELECT", QueryType::QUERY_SELECT},
-      {"CREATE TRIGGER", QueryType::QUERY_CREATE_TRIGGER}, {"CREATE SCHEMA", QueryType::QUERY_CREATE_SCHEMA},
-      {"CREATE VIEW", QueryType::QUERY_CREATE_VIEW}, {"OTHER", QueryType::QUERY_OTHER},
+  static std::unordered_map<std::string, QueryType> querytype_string_map{
+      {"BEGIN", QueryType::QUERY_BEGIN},
+      {"COMMIT", QueryType::QUERY_COMMIT},
+      {"ROLLBACK", QueryType::QUERY_ROLLBACK},
+      {"CREATE DATABASE", QueryType::QUERY_CREATE_DB},
+      {"CREATE INDEX", QueryType::QUERY_CREATE_INDEX},
+      {"CREATE TABLE", QueryType::QUERY_CREATE_TABLE},
+      {"DROP", QueryType::QUERY_DROP},
+      {"INSERT", QueryType::QUERY_INSERT},
+      {"SET", QueryType::QUERY_SET},
+      {"SHOW", QueryType::QUERY_SHOW},
+      {"SHOW", QueryType::QUERY_SHOW},
+      {"UPDATE", QueryType::QUERY_UPDATE},
+      {"ALTER", QueryType::QUERY_ALTER},
+      {"DELETE", QueryType::QUERY_DELETE},
+      {"COPY", QueryType::QUERY_COPY},
+      {"ANALYZE", QueryType::QUERY_ANALYZE},
+      {"RENAME", QueryType::QUERY_RENAME},
+      {"PREPARE", QueryType::QUERY_PREPARE},
+      {"EXECUTE", QueryType::QUERY_EXECUTE},
+      {"SELECT", QueryType::QUERY_SELECT},
+      {"CREATE TRIGGER", QueryType::QUERY_CREATE_TRIGGER},
+      {"CREATE SCHEMA", QueryType::QUERY_CREATE_SCHEMA},
+      {"CREATE VIEW", QueryType::QUERY_CREATE_VIEW},
+      {"OTHER", QueryType::QUERY_OTHER},
   };
-  std::unordered_map<std::string, QueryType>::iterator it  = querytype_string_map.find(str);
+  std::unordered_map<std::string, QueryType>::iterator it =
+      querytype_string_map.find(str);
   if (it != querytype_string_map.end()) {
-    return it -> second;
+    return it->second;
   } else {
     return QueryType::QUERY_INVALID;
   }
 }
 
-QueryType StatementTypeToQueryType(StatementType stmt_type, const parser::SQLStatement* sql_stmt) {
+QueryType StatementTypeToQueryType(StatementType stmt_type,
+                                   const parser::SQLStatement *sql_stmt) {
   LOG_TRACE("%s", StatementTypeToString(stmt_type).c_str());
-  static std::unordered_map<StatementType, QueryType, EnumHash<StatementType>> type_map {
-      {StatementType::EXECUTE, QueryType::QUERY_EXECUTE},
-      {StatementType::PREPARE, QueryType::QUERY_PREPARE},
-      {StatementType::INSERT, QueryType::QUERY_INSERT},
-      {StatementType::UPDATE, QueryType::QUERY_UPDATE},
-      {StatementType::DELETE, QueryType::QUERY_DELETE},
-      {StatementType::COPY, QueryType::QUERY_COPY},
-      {StatementType::ANALYZE, QueryType::QUERY_ANALYZE},
-      {StatementType::ALTER, QueryType::QUERY_ALTER},
-      {StatementType::DROP, QueryType::QUERY_DROP},
-      {StatementType::SELECT, QueryType::QUERY_SELECT},
-      {StatementType::VARIABLE_SET, QueryType::QUERY_SET},
-  };
+  static std::unordered_map<StatementType, QueryType, EnumHash<StatementType>>
+      type_map{
+          {StatementType::EXECUTE, QueryType::QUERY_EXECUTE},
+          {StatementType::PREPARE, QueryType::QUERY_PREPARE},
+          {StatementType::INSERT, QueryType::QUERY_INSERT},
+          {StatementType::UPDATE, QueryType::QUERY_UPDATE},
+          {StatementType::DELETE, QueryType::QUERY_DELETE},
+          {StatementType::COPY, QueryType::QUERY_COPY},
+          {StatementType::ANALYZE, QueryType::QUERY_ANALYZE},
+          {StatementType::ALTER, QueryType::QUERY_ALTER},
+          {StatementType::DROP, QueryType::QUERY_DROP},
+          {StatementType::SELECT, QueryType::QUERY_SELECT},
+          {StatementType::VARIABLE_SET, QueryType::QUERY_SET},
+      };
   QueryType query_type = QueryType::QUERY_OTHER;
-  std::unordered_map<StatementType, QueryType, EnumHash<StatementType>>::iterator it  = type_map.find(stmt_type);
+  std::unordered_map<StatementType, QueryType,
+                     EnumHash<StatementType>>::iterator it =
+      type_map.find(stmt_type);
   if (it != type_map.end()) {
-    query_type = it -> second;
+    query_type = it->second;
   } else {
-    switch(stmt_type) {
+    switch (stmt_type) {
       case StatementType::TRANSACTION: {
-        switch (static_cast<const parser::TransactionStatement*>(sql_stmt) ->type) {
-          case parser::TransactionStatement::CommandType::kBegin:query_type = QueryType::QUERY_BEGIN;
+        switch (
+            static_cast<const parser::TransactionStatement *>(sql_stmt)->type) {
+          case parser::TransactionStatement::CommandType::kBegin:
+            query_type = QueryType::QUERY_BEGIN;
             break;
-          case parser::TransactionStatement::CommandType::kCommit:query_type = QueryType::QUERY_COMMIT;
+          case parser::TransactionStatement::CommandType::kCommit:
+            query_type = QueryType::QUERY_COMMIT;
             break;
-          case parser::TransactionStatement::CommandType::kRollback:query_type = QueryType::QUERY_ROLLBACK;
+          case parser::TransactionStatement::CommandType::kRollback:
+            query_type = QueryType::QUERY_ROLLBACK;
             break;
         }
         break;
       }
       case StatementType::CREATE: {
-        switch (static_cast<const parser::CreateStatement*>(sql_stmt) ->type) {
-          case parser::CreateStatement::CreateType::kDatabase:query_type = QueryType::QUERY_CREATE_DB;
+        switch (static_cast<const parser::CreateStatement *>(sql_stmt)->type) {
+          case parser::CreateStatement::CreateType::kDatabase:
+            query_type = QueryType::QUERY_CREATE_DB;
             break;
-          case parser::CreateStatement::CreateType::kIndex:query_type = QueryType::QUERY_CREATE_INDEX;
+          case parser::CreateStatement::CreateType::kIndex:
+            query_type = QueryType::QUERY_CREATE_INDEX;
             break;
-          case parser::CreateStatement::CreateType::kTable:query_type = QueryType::QUERY_CREATE_TABLE;
+          case parser::CreateStatement::CreateType::kTable:
+            query_type = QueryType::QUERY_CREATE_TABLE;
             break;
-          case parser::CreateStatement::CreateType::kTrigger:query_type = QueryType::QUERY_CREATE_TRIGGER;
+          case parser::CreateStatement::CreateType::kTrigger:
+            query_type = QueryType::QUERY_CREATE_TRIGGER;
             break;
-          case parser::CreateStatement::CreateType::kSchema:query_type = QueryType::QUERY_CREATE_SCHEMA;
+          case parser::CreateStatement::CreateType::kSchema:
+            query_type = QueryType::QUERY_CREATE_SCHEMA;
             break;
-          case parser::CreateStatement::CreateType::kView:query_type = QueryType::QUERY_CREATE_VIEW;
+          case parser::CreateStatement::CreateType::kView:
+            query_type = QueryType::QUERY_CREATE_VIEW;
             break;
         }
         break;
@@ -708,9 +758,9 @@ std::string PostgresValueTypeToString(PostgresValueType type) {
       return "DECIMAL";
     }
     default: {
-      throw ConversionException(
-          StringUtil::Format("No string conversion for PostgresValueType value '%d'",
-                             static_cast<int>(type)));
+      throw ConversionException(StringUtil::Format(
+          "No string conversion for PostgresValueType value '%d'",
+          static_cast<int>(type)));
     }
   }
   return "INVALID";
@@ -766,7 +816,7 @@ PostgresValueType StringToPostgresValueType(const std::string &str) {
     return PostgresValueType::DECIMAL;
   } else {
     throw ConversionException(StringUtil::Format(
-    "No PostgresValueType conversion from string '%s'", upper_str.c_str()));
+        "No PostgresValueType conversion from string '%s'", upper_str.c_str()));
   }
   return PostgresValueType::INVALID;
 }
@@ -1087,13 +1137,15 @@ std::string IndexTypeToString(IndexType type) {
     case IndexType::SKIPLIST: {
       return "SKIPLIST";
     }
+    case IndexType::ART: {
+      return "ART";
+    }
     default: {
       throw ConversionException(
           StringUtil::Format("No string conversion for IndexType value '%d'",
                              static_cast<int>(type)));
     }
   }
-  return "INVALID";
 }
 
 IndexType StringToIndexType(const std::string &str) {
@@ -1108,6 +1160,8 @@ IndexType StringToIndexType(const std::string &str) {
     return IndexType::HASH;
   } else if (upper_str == "SKIPLIST") {
     return IndexType::SKIPLIST;
+  } else if (upper_str == "ART") {
+    return IndexType::ART;
   } else {
     throw ConversionException(StringUtil::Format(
         "No IndexType conversion from string '%s'", upper_str.c_str()));

src/common/init.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/common/internal_types.cpp

@@ -18,25 +18,30 @@
 
 namespace peloton {
 
-namespace catalog {
-class Schema;
-}
-
-//===--------------------------------------------------------------------===//
-// Tuple Interface
-//===--------------------------------------------------------------------===//
-
+//===----------------------------------------------------------------------===//
+// Generic tuple interface
+//===----------------------------------------------------------------------===//
 class AbstractTuple : public Printable {
  public:
-  virtual ~AbstractTuple(){};
+  virtual ~AbstractTuple() = default;
 
-  /** @brief Get the value at the given column id. */
+  /**
+   * @brief Get the value at the given column id
+   *
+   * @param column_id The ID/offset of the column whose value to return
+   */
   virtual type::Value GetValue(oid_t column_id) const = 0;
 
-  /** @brief Set the value at the given column id. */
+  /**
+   * @brief Set the value at the given column id
+   *
+   * @param column_id The ID/offset of the column in the tuple to set
+   * @param value The value to set the column to
+   **/
   virtual void SetValue(oid_t column_id, const type::Value &value) = 0;
 
-  /** @brief Get the raw location of the tuple's contents i.e. tuple.value_data.
+  /**
+   * @brief Get the raw location of the tuple's contents i.e. tuple.value_data.
    */
   virtual char *GetData() const = 0;
 };