Merge branch 'master' into fix/travis_failing_tests_ignored

Author: pervazea

Jenkinsfile

@@ -59,6 +59,12 @@ pipeline {
                         sh 'python ./script/validators/source_validator.py'
                         sh 'mkdir build'
                         sh 'cd build && cmake -DCMAKE_BUILD_TYPE=Release -DCOVERALLS=False .. && make -j4'
+                        sh 'cd build && make check -j4 || true'
+                        // sh 'cd build && cp -pr test /job/'
+                        sh 'cd build && make benchmark -j4'
+                        sh 'cd build && make install'
+                        sh 'cd build && bash ../script/testing/psql/psql_test.sh'
+                        sh 'cd build && python ../script/validators/jdbc_validator.py'
                     }
                 }
 

script/testing/psql/psql_test.sh

@@ -15,7 +15,7 @@ PELOTON_DIR="$CODE_SOURCE_DIR/../../.."
 PELOTON_PID=""
 PELOTON_PORT="57721"
 PELOTON_HOST="localhost"
-PELOTON_USER="postgres"
+PELOTON_USER="default_database"
 PELOTON_PASS="postgres"
 PELOTON_ARGS='sslmode=disable'
 

src/catalog/catalog.cpp

@@ -271,7 +271,6 @@ ResultType Catalog::CreateTable(const std::string &database_name,
         table_oid, column.GetName(), column_id, column.GetOffset(),
         column.GetType(), column.IsInlined(), column.GetConstraints(),
         pool_.get(), txn);
-    column_id++;
 
     // Create index on unique single column
     if (column.IsUnique()) {
@@ -282,6 +281,7 @@ ResultType Catalog::CreateTable(const std::string &database_name,
       LOG_DEBUG("Added a UNIQUE index on %s in %s.", col_name.c_str(),
                 table_name.c_str());
     }
+    column_id++;
   }
   CreatePrimaryIndex(database_object->GetDatabaseOid(), table_oid, txn);
   return ResultType::SUCCESS;

src/executor/index_scan_executor.cpp

@@ -199,7 +199,6 @@ bool IndexScanExecutor::ExecPrimaryIndexLookup() {
   auto current_txn = executor_context_->GetTransaction();
   auto &manager = catalog::Manager::GetInstance();
   std::vector<ItemPointer> visible_tuple_locations;
-  std::map<oid_t, std::vector<oid_t>> visible_tuples;
 
 #ifdef LOG_TRACE_ENABLED
   int num_tuples_examined = 0;
@@ -326,27 +325,53 @@ bool IndexScanExecutor::ExecPrimaryIndexLookup() {
   LOG_TRACE("%ld tuples after pruning boundaries",
             visible_tuple_locations.size());
 
+  // Add the tuple locations to the result vector in the order returned by
+  // the index scan. We might end up reading the same tile group multiple
+  // times. However, this is necessary to adhere to the ORDER BY clause
+  oid_t current_tile_group_oid = INVALID_OID;
+  std::vector<oid_t> tuples;
+
   for (auto &visible_tuple_location : visible_tuple_locations) {
-    visible_tuples[visible_tuple_location.block]
-        .push_back(visible_tuple_location.offset);
-  }
+    if (current_tile_group_oid == INVALID_OID) {
+      current_tile_group_oid = visible_tuple_location.block;
+    }
+    if (current_tile_group_oid == visible_tuple_location.block) {
+      tuples.push_back(visible_tuple_location.offset);
+    } else {
+      // Since the tile_group_oids differ, fill in the current tile group
+      // into the result vector
+      auto &manager = catalog::Manager::GetInstance();
+      auto tile_group = manager.GetTileGroup(current_tile_group_oid);
+      std::unique_ptr<LogicalTile> logical_tile(LogicalTileFactory::GetTile());
+      // Add relevant columns to logical tile
+      logical_tile->AddColumns(tile_group, full_column_ids_);
+      logical_tile->AddPositionList(std::move(tuples));
+      if (column_ids_.size() != 0) {
+        logical_tile->ProjectColumns(full_column_ids_, column_ids_);
+      }
+      result_.push_back(logical_tile.release());
 
-  // Construct a logical tile for each block
-  for (auto tuples : visible_tuples) {
-    auto &manager = catalog::Manager::GetInstance();
-    auto tile_group = manager.GetTileGroup(tuples.first);
+      // Change the current_tile_group_oid and add the current tuple
+      tuples.clear();
+      current_tile_group_oid = visible_tuple_location.block;
+      tuples.push_back(visible_tuple_location.offset);
+    }
+  }
 
+  // Add the remaining tuples to the result vector
+  if ((current_tile_group_oid != INVALID_OID) && (!tuples.empty())) {
+    auto tile_group = manager.GetTileGroup(current_tile_group_oid);
     std::unique_ptr<LogicalTile> logical_tile(LogicalTileFactory::GetTile());
     // Add relevant columns to logical tile
     logical_tile->AddColumns(tile_group, full_column_ids_);
-    logical_tile->AddPositionList(std::move(tuples.second));
+    logical_tile->AddPositionList(std::move(tuples));
     if (column_ids_.size() != 0) {
       logical_tile->ProjectColumns(full_column_ids_, column_ids_);
     }
-
     result_.push_back(logical_tile.release());
   }
 
+
   done_ = true;
 
   LOG_TRACE("Result tiles : %lu", result_.size());
@@ -408,7 +433,6 @@ bool IndexScanExecutor::ExecSecondaryIndexLookup() {
   auto current_txn = executor_context_->GetTransaction();
 
   std::vector<ItemPointer> visible_tuple_locations;
-  std::map<oid_t, std::vector<oid_t>> visible_tuples;
   auto &manager = catalog::Manager::GetInstance();
 
   // Quickie Hack
@@ -567,24 +591,49 @@ bool IndexScanExecutor::ExecSecondaryIndexLookup() {
   // Check whether the boundaries satisfy the required condition
   CheckOpenRangeWithReturnedTuples(visible_tuple_locations);
 
+  // Add the tuple locations to the result vector in the order returned by
+  // the index scan. We might end up reading the same tile group multiple
+  // times. However, this is necessary to adhere to the ORDER BY clause
+  oid_t current_tile_group_oid = INVALID_OID;
+  std::vector<oid_t> tuples;
+
   for (auto &visible_tuple_location : visible_tuple_locations) {
-    visible_tuples[visible_tuple_location.block]
-        .push_back(visible_tuple_location.offset);
-  }
+    if (current_tile_group_oid == INVALID_OID) {
+      current_tile_group_oid = visible_tuple_location.block;
+    }
+    if (current_tile_group_oid == visible_tuple_location.block) {
+      tuples.push_back(visible_tuple_location.offset);
+    } else {
+      // Since the tile_group_oids differ, fill in the current tile group
+      // into the result vector
+      auto &manager = catalog::Manager::GetInstance();
+      auto tile_group = manager.GetTileGroup(current_tile_group_oid);
+      std::unique_ptr<LogicalTile> logical_tile(LogicalTileFactory::GetTile());
+      // Add relevant columns to logical tile
+      logical_tile->AddColumns(tile_group, full_column_ids_);
+      logical_tile->AddPositionList(std::move(tuples));
+      if (column_ids_.size() != 0) {
+        logical_tile->ProjectColumns(full_column_ids_, column_ids_);
+      }
+      result_.push_back(logical_tile.release());
 
-  // Construct a logical tile for each block
-  for (auto tuples : visible_tuples) {
-    auto &manager = catalog::Manager::GetInstance();
-    auto tile_group = manager.GetTileGroup(tuples.first);
+      // Change the current_tile_group_oid and add the current tuple
+      tuples.clear();
+      current_tile_group_oid = visible_tuple_location.block;
+      tuples.push_back(visible_tuple_location.offset);
+    }
+  }
 
+  // Add the remaining tuples (if any) to the result vector
+  if ((current_tile_group_oid != INVALID_OID) && (!tuples.empty())) {
+    auto tile_group = manager.GetTileGroup(current_tile_group_oid);
     std::unique_ptr<LogicalTile> logical_tile(LogicalTileFactory::GetTile());
     // Add relevant columns to logical tile
     logical_tile->AddColumns(tile_group, full_column_ids_);
-    logical_tile->AddPositionList(std::move(tuples.second));
+    logical_tile->AddPositionList(std::move(tuples));
     if (column_ids_.size() != 0) {
       logical_tile->ProjectColumns(full_column_ids_, column_ids_);
     }
-
     result_.push_back(logical_tile.release());
   }
 
@@ -663,19 +712,6 @@ bool IndexScanExecutor::CheckKeyConditions(const ItemPointer &tuple_location) {
     // To make the procedure more uniform, we interpret IN as EQUAL
     // and NOT IN as NOT EQUAL, and react based on expression type below
     // accordingly
-    /*if (expr_type == ExpressionType::COMPARE_IN) {
-      bool bret = lhs.InList(rhs);
-
-      if (bret == true) {
-        diff = VALUE_COMPARE_EQUAL;
-      } else {
-        diff = VALUE_COMPARE_NO_EQUAL;
-      }
-    } else {
-      diff = lhs.Compare(rhs);
-    }
-
-    LOG_TRACE("Difference : %d ", diff);*/
     if (lhs.CompareEquals(rhs) == CmpBool::TRUE) {
       switch (expr_type) {
         case ExpressionType::COMPARE_EQUAL:

src/include/threadpool/mono_queue_pool.h

@@ -24,7 +24,7 @@ namespace threadpool {
  */
 class MonoQueuePool {
  public:
-  MonoQueuePool(int task_queue_size = 32, int worker_pool_size = 4)
+  MonoQueuePool(uint32_t task_queue_size, uint32_t worker_pool_size)
       : task_queue_(task_queue_size),
         worker_pool_(worker_pool_size, &task_queue_),
         is_running_(false) {}
@@ -53,19 +53,18 @@ class MonoQueuePool {
   }
 
   static MonoQueuePool &GetInstance() {
-    int task_queue_size = settings::SettingsManager::GetBool(
+    uint32_t task_queue_size = settings::SettingsManager::GetInt(
         settings::SettingId::monoqueue_task_queue_size);
-    int worker_pool_size = settings::SettingsManager::GetBool(
+    uint32_t worker_pool_size = settings::SettingsManager::GetInt(
         settings::SettingId::monoqueue_worker_pool_size);
-
     static MonoQueuePool mono_queue_pool(task_queue_size, worker_pool_size);
     return mono_queue_pool;
   }
 
   static MonoQueuePool &GetBrainInstance() {
-    int task_queue_size = settings::SettingsManager::GetBool(
+    uint32_t task_queue_size = settings::SettingsManager::GetInt(
         settings::SettingId::brain_task_queue_size);
-    int worker_pool_size = settings::SettingsManager::GetBool(
+    uint32_t worker_pool_size = settings::SettingsManager::GetInt(
         settings::SettingId::brain_worker_pool_size);
     static MonoQueuePool brain_queue_pool(task_queue_size, worker_pool_size);
     return brain_queue_pool;

src/storage/data_table.cpp

@@ -773,7 +773,6 @@ bool DataTable::CheckForeignKeyConstraints(
 
       // The foreign key constraints only refer to the primary key
       if (index->GetIndexType() == IndexConstraintType::PRIMARY_KEY) {
-        LOG_INFO("BEGIN checking referred table");
 
         std::vector<oid_t> key_attrs = foreign_key->GetSinkColumnIds();
         std::unique_ptr<catalog::Schema> foreign_key_schema(

test/optimizer/cost_test.cpp

@@ -42,7 +42,7 @@ namespace test {
 
 using namespace optimizer;
 
-const int N_ROW = 100;
+// const int N_ROW = 100;
 
 class CostTests : public PelotonTest {};
 

test/sql/insert_sql_test.cpp

@@ -523,5 +523,52 @@ TEST_F(InsertSQLTests, InsertIntoSelectColumn) {
   txn_manager.CommitTransaction(txn);
 }
 
+TEST_F(InsertSQLTests, UniqueColumn) {
+  auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
+  auto txn = txn_manager.BeginTransaction();
+  catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn);
+  txn_manager.CommitTransaction(txn);
+
+  std::string create_table("CREATE TABLE t (id INTEGER NOT NULL PRIMARY KEY,"
+                                        "st VARCHAR(15) NOT NULL UNIQUE);");
+  TestingSQLUtil::ExecuteSQLQuery(create_table);
+
+  ResultType result;
+  std::vector<std::string> ref_result;
+  std::string result_query = "select st from t;";
+
+  // Single row, should succeed
+  std::string ins_query_1("INSERT INTO t VALUES (1, 'abc');");
+  result = TestingSQLUtil::ExecuteSQLQuery(ins_query_1);
+  EXPECT_EQ(result, ResultType::SUCCESS);
+  ref_result.push_back("abc");
+  TestingSQLUtil::ExecuteSQLQueryAndCheckResult(result_query,
+                                                ref_result,
+                                                false);
+
+  // Second row, distinct from first, should succeed
+  std::string ins_query_2("INSERT INTO t VALUES (2, 'def');");
+  result = TestingSQLUtil::ExecuteSQLQuery(ins_query_2);
+  EXPECT_EQ(result, ResultType::SUCCESS);
+  ref_result.push_back("def");
+  TestingSQLUtil::ExecuteSQLQueryAndCheckResult(result_query,
+                                                ref_result,
+                                                false);
+
+  // Third row, non-unique value for string, should fail
+  std::string ins_query_3("INSERT INTO t VALUES (3, 'abc');");
+  result = TestingSQLUtil::ExecuteSQLQuery(ins_query_3);
+  EXPECT_EQ(result, ResultType::ABORTED);
+  // and the results returned should not include failed insert
+  TestingSQLUtil::ExecuteSQLQueryAndCheckResult(result_query,
+                                                ref_result,
+                                                false);
+
+  // free the database just created
+  txn = txn_manager.BeginTransaction();
+  catalog::Catalog::GetInstance()->DropDatabaseWithName(DEFAULT_DB_NAME, txn);
+  txn_manager.CommitTransaction(txn);
+}
+
 }  // namespace test
 }  // namespace peloton