merged to upstream

GustavoAngulo · GustavoAngulo · commit 082ec5be750d · 2018-03-22T01:00:13.000-04:00
diff --git a/script/installation/packages.sh b/script/installation/packages.sh
@@ -17,6 +17,7 @@
 ##  * OSX
 ## =================================================================
 
+set -o errexit
 
 # Determine OS platform
 UNAME=$(uname | tr "[:upper:]" "[:lower:]")
@@ -104,14 +105,12 @@ if [ "$DISTRO" = "UBUNTU" ]; then
             echo -e "\n# Added by Peloton 'packages.sh' script on $(date)\ndeb $LLVM_PKG_URL $LLVM_PKG_TARGET" | sudo tee -a /etc/apt/sources.list > /dev/null
         fi
         sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 15CF4D18AF4F7421
-        sudo apt-get update -qq
         CMAKE_NAME="cmake3"
-        FORCE_Y="--force-yes"
     else
         CMAKE_NAME="cmake"
-        FORCE_Y=""
     fi
 
+    sudo apt-get update
     FORCE_Y=""
     PKG_CMAKE="cmake"
     PKG_LLVM="llvm-3.7"
@@ -134,7 +133,7 @@ if [ "$DISTRO" = "UBUNTU" ]; then
     fi
     TFCApiFile="libtensorflow-${TF_TYPE}-linux-x86_64-${TF_VERSION}.tar.gz"
     LinkerConfigCmd="sudo ldconfig"
-    sudo apt-get -qq $FORCE_Y --ignore-missing -y install \
+    sudo apt-get -q $FORCE_Y --ignore-missing -y install \
         $PKG_CMAKE \
         $PKG_LLVM \
         $PKG_CLANG \
@@ -171,7 +170,7 @@ if [ "$DISTRO" = "UBUNTU" ]; then
 ## DEBIAN
 ## ------------------------------------------------
 elif [ "$DISTRO" = "DEBIAN OS" ]; then
-    sudo apt-get -qq --ignore-missing -y install \
+    sudo apt-get -q --ignore-missing -y install \
         git \
         g++ \
         clang \
@@ -312,6 +311,7 @@ elif [[ "$DISTRO" == *"REDHAT"* ]] && [[ "${DISTRO_VER%.*}" == "7" ]]; then
 ## DARWIN (OSX)
 ## ------------------------------------------------
 elif [ "$DISTRO" = "DARWIN" ]; then
+    set +o errexit
     if test ! $(which brew); then
       echo "Installing homebrew..."
       ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
diff --git a/src/binder/binder_context.cpp b/src/binder/binder_context.cpp
@@ -37,10 +37,8 @@ void BinderContext::AddRegularTable(const std::string db_name,
                                     const std::string table_alias,
                                     concurrency::TransactionContext *txn) {
   // using catalog object to retrieve meta-data
-  // PL_ASSERT(txn->catalog_cache.GetDatabaseObject(db_name) != nullptr);
   auto table_object =
     catalog::Catalog::GetInstance()->GetTableObject(db_name, table_name, txn);
-    // txn->catalog_cache.GetDatabaseObject(db_name)->GetTableObject(table_name, true);
 
   if (regular_table_alias_map_.find(table_alias) !=
           regular_table_alias_map_.end() ||
diff --git a/src/include/optimizer/cost_calculator.h b/src/include/optimizer/cost_calculator.h
@@ -21,7 +21,8 @@ class Memo;
 // Derive cost for a physical group expressionh
 class CostCalculator : public OperatorVisitor {
  public:
-  double CalculateCost(GroupExpression *gexpr, Memo *memo);
+  double CalculateCost(GroupExpression *gexpr, Memo *memo,
+                       concurrency::TransactionContext *txn);
 
   void Visit(const DummyScan *) override;
   void Visit(const PhysicalSeqScan *) override;
@@ -53,6 +54,7 @@ class CostCalculator : public OperatorVisitor {
 
   GroupExpression *gexpr_;
   Memo *memo_;
+  concurrency::TransactionContext *txn_;
   double output_cost_ = 0;
 };
 
diff --git a/src/include/optimizer/optimizer_metadata.h b/src/include/optimizer/optimizer_metadata.h
@@ -29,7 +29,7 @@ class OptimizerMetadata {
   Memo memo;
   RuleSet rule_set;
   OptimizerTaskPool *task_pool;
-  catalog::CatalogCache* catalog_cache;
+  concurrency::TransactionContext* txn;
 
   void SetTaskPool(OptimizerTaskPool *task_pool) {
     this->task_pool = task_pool;
diff --git a/src/include/optimizer/stats/stats_storage.h b/src/include/optimizer/stats/stats_storage.h
@@ -62,17 +62,21 @@ class StatsStorage {
                                                   oid_t table_id,
                                                   oid_t column_id);
 
-  std::shared_ptr<TableStats> GetTableStats(oid_t database_id, oid_t table_id);
+  std::shared_ptr<TableStats> GetTableStats(
+      oid_t database_id, oid_t table_id, concurrency::TransactionContext *txn);
 
-  std::shared_ptr<TableStats> GetTableStats(oid_t database_id, oid_t table_id,
-                                            std::vector<oid_t> column_ids);
+  std::shared_ptr<TableStats> GetTableStats(
+      oid_t database_id, oid_t table_id, std::vector<oid_t> column_ids,
+      concurrency::TransactionContext *txn);
 
   /* Functions for triggerring stats collection */
 
-  ResultType AnalyzeStatsForAllTables(concurrency::TransactionContext *txn = nullptr);
+  ResultType AnalyzeStatsForAllTables(
+      concurrency::TransactionContext *txn = nullptr);
 
-  ResultType AnalyzeStatsForTable(storage::DataTable *table,
-                                  concurrency::TransactionContext *txn = nullptr);
+  ResultType AnalyzeStatsForTable(
+      storage::DataTable *table,
+      concurrency::TransactionContext *txn = nullptr);
 
   ResultType AnalayzeStatsForColumns(storage::DataTable *table,
                                      std::vector<std::string> column_names);
diff --git a/src/include/optimizer/stats_calculator.h b/src/include/optimizer/stats_calculator.h
@@ -27,7 +27,7 @@ class TableStats;
 class StatsCalculator : public OperatorVisitor {
  public:
   void CalculateStats(GroupExpression *gexpr, ExprSet required_cols,
-                      Memo *memo);
+                      Memo *memo, concurrency::TransactionContext* txn);
 
   void Visit(const LogicalGet *) override;
   void Visit(const LogicalQueryDerivedGet *) override;
@@ -75,6 +75,7 @@ class StatsCalculator : public OperatorVisitor {
   GroupExpression *gexpr_;
   ExprSet required_cols_;
   Memo *memo_;
+  concurrency::TransactionContext* txn_;
 };
 
 }  // namespace optimizer
diff --git a/src/include/type/value_factory.h b/src/include/type/value_factory.h
@@ -214,10 +214,12 @@ class ValueFactory {
           std::string str = value.ToString();
           int64_t bigint = 0;
           try {
-            bigint = std::stoll(str);
+            bigint = stoll(str);
           } catch (std::out_of_range &e) {
             throw Exception(ExceptionType::OUT_OF_RANGE,
                             "Numeric value out of range.");
+          } catch(std::invalid_argument &e) {
+            throw Exception("Invalid input syntax for bigint: \'" + str + "\'");
           }
           if (bigint > PELOTON_INT64_MAX || bigint < PELOTON_INT64_MIN)
             throw Exception(ExceptionType::OUT_OF_RANGE,
@@ -262,11 +264,14 @@ class ValueFactory {
           std::string str = value.ToString();
           int32_t integer = 0;
           try {
-            integer = std::stoi(str);
+            integer = stoi(str);
           } catch (std::out_of_range &e) {
             throw Exception(ExceptionType::OUT_OF_RANGE,
                             "Numeric value out of range.");
+          } catch (std::invalid_argument &e) {
+            throw Exception("Invalid input syntax for integer: \'" + str + "\'");
           }
+
           if (integer > PELOTON_INT32_MAX || integer < PELOTON_INT32_MIN)
             throw Exception(ExceptionType::OUT_OF_RANGE,
                             "Numeric value out of range.");
@@ -317,10 +322,12 @@ class ValueFactory {
           std::string str = value.ToString();
           int16_t smallint = 0;
           try {
-            smallint = std::stoi(str);
+            smallint = stoi(str);
           } catch (std::out_of_range &e) {
             throw Exception(ExceptionType::OUT_OF_RANGE,
                             "Numeric value out of range.");
+          } catch(std::invalid_argument &e) {
+            throw Exception("Invalid input syntax for smallint: \'" + str + "\'");
           }
           if (smallint < PELOTON_INT16_MIN)
             throw Exception(ExceptionType::OUT_OF_RANGE,
@@ -375,10 +382,12 @@ class ValueFactory {
           std::string str = value.ToString();
           int8_t tinyint = 0;
           try {
-            tinyint = std::stoi(str);
+            tinyint = stoi(str);
           } catch (std::out_of_range &e) {
             throw Exception(ExceptionType::OUT_OF_RANGE,
                             "Numeric value out of range.");
+          } catch(std::invalid_argument &e) {
+            throw Exception("Invalid input syntax for tinyint: \'" + str + "\'");
           }
           if (tinyint < PELOTON_INT8_MIN)
             throw Exception(ExceptionType::OUT_OF_RANGE,
@@ -413,10 +422,12 @@ class ValueFactory {
           std::string str = value.ToString();
           double res = 0;
           try {
-            res = std::stod(str);
+            res = stod(str);
           } catch (std::out_of_range &e) {
             throw Exception(ExceptionType::OUT_OF_RANGE,
                             "Numeric value out of range.");
+          } catch(std::invalid_argument &e) {
+            throw Exception("Invalid input syntax for decimal: \'" + str + "\'");
           }
           if (res > PELOTON_DECIMAL_MAX || res < PELOTON_DECIMAL_MIN)
             throw Exception(ExceptionType::OUT_OF_RANGE,
diff --git a/src/optimizer/cost_calculator.cpp b/src/optimizer/cost_calculator.cpp
@@ -24,9 +24,11 @@
 namespace peloton {
 namespace optimizer {
 
-double CostCalculator::CalculateCost(GroupExpression *gexpr, Memo *memo) {
+double CostCalculator::CalculateCost(GroupExpression *gexpr, Memo *memo,
+                                     concurrency::TransactionContext *txn) {
   gexpr_ = gexpr;
   memo_ = memo;
+  txn_ = txn;
   gexpr_->Op().Accept(this);
   return output_cost_;
 }
@@ -36,8 +38,8 @@ void CostCalculator::Visit(UNUSED_ATTRIBUTE const DummyScan *op) {
 }
 void CostCalculator::Visit(const PhysicalSeqScan *op) {
   auto table_stats = std::dynamic_pointer_cast<TableStats>(
-      StatsStorage::GetInstance()->GetTableStats(op->table_->GetDatabaseOid(),
-                                                 op->table_->GetTableOid()));
+      StatsStorage::GetInstance()->GetTableStats(
+          op->table_->GetDatabaseOid(), op->table_->GetTableOid(), txn_));
   if (table_stats->GetColumnCount() == 0) {
     output_cost_ = 1.f;
     return;
@@ -46,8 +48,8 @@ void CostCalculator::Visit(const PhysicalSeqScan *op) {
 }
 void CostCalculator::Visit(UNUSED_ATTRIBUTE const PhysicalIndexScan *op) {
   auto table_stats = std::dynamic_pointer_cast<TableStats>(
-      StatsStorage::GetInstance()->GetTableStats(op->table_->GetDatabaseOid(),
-                                                 op->table_->GetTableOid()));
+      StatsStorage::GetInstance()->GetTableStats(
+          op->table_->GetDatabaseOid(), op->table_->GetTableOid(), txn_));
   if (table_stats->GetColumnCount() == 0 || table_stats->num_rows == 0) {
     output_cost_ = 0.f;
     return;
diff --git a/src/optimizer/optimizer.cpp b/src/optimizer/optimizer.cpp
@@ -110,14 +110,14 @@ shared_ptr<planner::AbstractPlan> Optimizer::BuildPelotonPlanTree(
       make_shared<binder::BindNodeVisitor>(txn, default_database_name);
   bind_node_visitor->BindNameToNode(parse_tree);
 
-  metadata_.catalog_cache = &txn->catalog_cache;
   // Handle ddl statement
   bool is_ddl_stmt;
   auto ddl_plan = HandleDDLStatement(parse_tree, is_ddl_stmt, txn);
   if (is_ddl_stmt) {
     return move(ddl_plan);
   }
 
+  metadata_.txn = txn;
   // Generate initial operator tree from query tree
   shared_ptr<GroupExpression> gexpr = InsertQueryTree(parse_tree, txn);
   GroupID root_id = gexpr->GetGroupID();
diff --git a/src/optimizer/optimizer_task.cpp b/src/optimizer/optimizer_task.cpp
@@ -249,7 +249,8 @@ void DeriveStats::execute() {
   }
 
   StatsCalculator calculator;
-  calculator.CalculateStats(gexpr_, required_cols_, &context_->metadata->memo);
+  calculator.CalculateStats(gexpr_, required_cols_, &context_->metadata->memo,
+                            context_->metadata->txn);
   gexpr_->SetDerivedStats();
 }
 //===--------------------------------------------------------------------===//
@@ -291,8 +292,8 @@ void OptimizeInputs::execute() {
       // 1. Collect stats needed and cache them in the group
       // 2. Calculate cost based on children's stats
       CostCalculator cost_calculator;
-      cur_total_cost_ +=
-          cost_calculator.CalculateCost(group_expr_, &context_->metadata->memo);
+      cur_total_cost_ += cost_calculator.CalculateCost(
+          group_expr_, &context_->metadata->memo, context_->metadata->txn);
     }
 
     for (; cur_child_idx_ < (int)group_expr_->GetChildrenGroupsSize();
@@ -367,7 +368,8 @@ void OptimizeInputs::execute() {
               std::make_shared<PropertySet>(extended_output_properties);
           CostCalculator cost_calculator;
           cur_total_cost_ += cost_calculator.CalculateCost(
-              memo_enforced_expr, &context_->metadata->memo);
+              memo_enforced_expr, &context_->metadata->memo,
+              context_->metadata->txn);
 
           // Update hash tables for group and group expression
           memo_enforced_expr->SetLocalHashTable(
diff --git a/src/optimizer/stats/stats_storage.cpp b/src/optimizer/stats/stats_storage.cpp
@@ -104,7 +104,8 @@ void StatsStorage::InsertOrUpdateColumnStats(
     oid_t database_id, oid_t table_id, oid_t column_id, int num_rows,
     double cardinality, double frac_null, std::string most_common_vals,
     std::string most_common_freqs, std::string histogram_bounds,
-    std::string column_name, bool has_index, concurrency::TransactionContext *txn) {
+    std::string column_name, bool has_index,
+    concurrency::TransactionContext *txn) {
   LOG_TRACE("InsertOrUpdateColumnStats, %d, %lf, %lf, %s, %s, %s", num_rows,
             cardinality, frac_null, most_common_vals.c_str(),
             most_common_freqs.c_str(), histogram_bounds.c_str());
@@ -215,15 +216,12 @@ std::shared_ptr<ColumnStats> StatsStorage::ConvertVectorToColumnStats(
  *
  * The return value is the shared_ptr of TableStats wrapper.
  */
-std::shared_ptr<TableStats> StatsStorage::GetTableStats(oid_t database_id,
-                                                        oid_t table_id) {
+std::shared_ptr<TableStats> StatsStorage::GetTableStats(
+    oid_t database_id, oid_t table_id, concurrency::TransactionContext *txn) {
   auto column_stats_catalog = catalog::ColumnStatsCatalog::GetInstance(nullptr);
-  auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
-  auto txn = txn_manager.BeginTransaction();
   std::map<oid_t, std::unique_ptr<std::vector<type::Value>>> column_stats_map;
   column_stats_catalog->GetTableStats(database_id, table_id, txn,
                                       column_stats_map);
-  txn_manager.CommitTransaction(txn);
 
   std::vector<std::shared_ptr<ColumnStats>> column_stats_ptrs;
   for (auto it = column_stats_map.begin(); it != column_stats_map.end(); ++it) {
@@ -242,10 +240,9 @@ std::shared_ptr<TableStats> StatsStorage::GetTableStats(oid_t database_id,
  * The return value is the shared_ptr of TableStats wrapper.
  */
 std::shared_ptr<TableStats> StatsStorage::GetTableStats(
-    oid_t database_id, oid_t table_id, std::vector<oid_t> column_ids) {
+    oid_t database_id, oid_t table_id, std::vector<oid_t> column_ids,
+    concurrency::TransactionContext *txn) {
   auto column_stats_catalog = catalog::ColumnStatsCatalog::GetInstance(nullptr);
-  auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
-  auto txn = txn_manager.BeginTransaction();
   std::map<oid_t, std::unique_ptr<std::vector<type::Value>>> column_stats_map;
   column_stats_catalog->GetTableStats(database_id, table_id, txn,
                                       column_stats_map);
@@ -299,8 +296,8 @@ ResultType StatsStorage::AnalyzeStatsForAllTables(
  * AnalyzeStatsForTable - This function analyzes the stats for one table and
  * sotre the stats in column_stats_catalog.
  */
-ResultType StatsStorage::AnalyzeStatsForTable(storage::DataTable *table,
-                                              concurrency::TransactionContext *txn) {
+ResultType StatsStorage::AnalyzeStatsForTable(
+    storage::DataTable *table, concurrency::TransactionContext *txn) {
   if (txn == nullptr) {
     LOG_TRACE("Do not have transaction to analyze the table stats: %s",
               table->GetName().c_str());
diff --git a/src/optimizer/stats_calculator.cpp b/src/optimizer/stats_calculator.cpp
@@ -27,10 +27,12 @@ namespace peloton {
 namespace optimizer {
 
 void StatsCalculator::CalculateStats(GroupExpression *gexpr,
-                                     ExprSet required_cols, Memo *memo) {
+                                     ExprSet required_cols, Memo *memo,
+                                     concurrency::TransactionContext *txn) {
   gexpr_ = gexpr;
   memo_ = memo;
   required_cols_ = required_cols;
+  txn_ = txn;
   gexpr->Op().Accept(this);
 }
 
@@ -41,7 +43,7 @@ void StatsCalculator::Visit(const LogicalGet *op) {
   }
   auto table_stats = std::dynamic_pointer_cast<TableStats>(
       StatsStorage::GetInstance()->GetTableStats(op->table->GetDatabaseOid(),
-                                                 op->table->GetTableOid()));
+                                                 op->table->GetTableOid(), txn_));
   // First, get the required stats of the base table
   std::unordered_map<std::string, std::shared_ptr<ColumnStats>> required_stats;
   for (auto &col : required_cols_) {
diff --git a/test/optimizer/selectivity_test.cpp b/test/optimizer/selectivity_test.cpp
diff --git a/test/optimizer/stats_storage_test.cpp b/test/optimizer/stats_storage_test.cpp
diff --git a/test/sql/insert_sql_test.cpp b/test/sql/insert_sql_test.cpp
