Merge branch 'master' into settings_gh

Author: pervazea

script/testing/jdbc/README.md

@@ -1,10 +1,23 @@
 ## Simple JDBC test for Peloton
 
-The java program here provides simple JDBC operation tests for Peloton database. To run the test, simply type:
+The java program here provides simple JDBC operation tests for Peloton
+database.
 
-test_jdbc.sh <type>
+To run the test:
+1. Start peloton. Typically, locally, so hostname would be localhost
+and if default port would be 15721
 
-Where 'type' is either 'basic', 'stats', or 'copy'
+2. Compile and run the test:
+test_jdbc.sh <type> <hostname> <port>
+
+e.g. test_jdbc.sh PelotonBasicTest localhost 15721
+
+Where 'type' is one of:
+      PelotonBasicTest 
+      PelotonErrorTest
+      PelotonTypeTest
+      StocklevelTest
+      SSLTest
 
 The program performs the following tests:
 

src/common/internal_types.cpp

@@ -471,6 +471,9 @@ std::string StatementTypeToString(StatementType type) {
     case StatementType::VARIABLE_SET: {
       return "SET";
     }
+    case StatementType::EXPLAIN: {
+      return "EXPLAIN";
+    }
     default: {
       throw ConversionException(StringUtil::Format(
           "No string conversion for StatementType value '%d'",
@@ -572,6 +575,8 @@ std::string QueryTypeToString(QueryType query_type) {
       return "EXECUTE";
     case QueryType::QUERY_SELECT:
       return "SELECT";
+    case QueryType::QUERY_EXPLAIN: 
+      return "EXPLAIN";
     case QueryType::QUERY_OTHER:
     default:
       return "OTHER";
@@ -630,6 +635,7 @@ QueryType StatementTypeToQueryType(StatementType stmt_type,
           {StatementType::DROP, QueryType::QUERY_DROP},
           {StatementType::SELECT, QueryType::QUERY_SELECT},
           {StatementType::VARIABLE_SET, QueryType::QUERY_SET},
+          {StatementType::EXPLAIN, QueryType::QUERY_EXPLAIN}
       };
   QueryType query_type = QueryType::QUERY_OTHER;
   std::unordered_map<StatementType, QueryType,

src/include/common/internal_types.h

@@ -671,6 +671,7 @@ enum class StatementType {
   ANALYZE = 15,               // analyze type
   VARIABLE_SET = 16,          // variable set statement type
   CREATE_FUNC = 17,           // create func statement type
+  EXPLAIN = 18                // explain statement type
 };
 std::string StatementTypeToString(StatementType type);
 StatementType StringToStatementType(const std::string &str);
@@ -704,7 +705,8 @@ enum class QueryType {
   QUERY_INVALID = 20,
   QUERY_CREATE_TRIGGER = 21,
   QUERY_CREATE_SCHEMA = 22,
-  QUERY_CREATE_VIEW = 23
+  QUERY_CREATE_VIEW = 23,
+  QUERY_EXPLAIN = 24
 };
 std::string QueryTypeToString(QueryType query_type);
 QueryType StringToQueryType(std::string str);
@@ -1416,4 +1418,4 @@ enum class SSLLevel {
   SSL_VERIIFY = 2,
 };
 
-}  // namespace peloton
+}  // namespace peloton

src/include/common/sql_node_visitor.h

@@ -21,6 +21,7 @@ class CreateFunctionStatement;
 class InsertStatement;
 class DeleteStatement;
 class DropStatement;
+class ExplainStatement;
 class PrepareStatement;
 class ExecuteStatement;
 class TransactionStatement;
@@ -80,6 +81,7 @@ class SqlNodeVisitor {
   virtual void Visit(parser::UpdateStatement *) {}
   virtual void Visit(parser::CopyStatement *) {}
   virtual void Visit(parser::AnalyzeStatement *){};
+  virtual void Visit(parser::ExplainStatement *){};
 
   virtual void Visit(expression::ComparisonExpression *expr);
   virtual void Visit(expression::AggregateExpression *expr);
@@ -93,8 +95,6 @@ class SqlNodeVisitor {
   virtual void Visit(expression::StarExpression *expr);
   virtual void Visit(expression::TupleValueExpression *expr);
   virtual void Visit(expression::SubqueryExpression *expr);
-
-
 };
 
 }  // namespace peloton

src/include/network/postgres_protocol_handler.h

@@ -31,6 +31,10 @@
 
 namespace peloton {
 
+namespace parser {
+class ExplainStatement;
+}  // namespace parser
+
 namespace network {
 
 typedef std::vector<std::unique_ptr<OutputPacket>> ResponseBuffer;
@@ -161,6 +165,10 @@ class PostgresProtocolHandler : public ProtocolHandler {
   /* Execute a Simple query protocol message */
   ProcessResult ExecQueryMessage(InputPacket *pkt, const size_t thread_id);
 
+  /* Execute a EXPLAIN query message */
+  ResultType ExecQueryExplain(const std::string &query,
+                              parser::ExplainStatement &explain_stmt);
+
   /* Process the PARSE message of the extended query protocol */
   void ExecParseMessage(InputPacket *pkt);
 

src/include/parser/explain_statement.h

@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// explain_statement.h
+//
+// Identification: src/include/parser/explain_statement.h
+//
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "parser/sql_statement.h"
+
+namespace peloton {
+namespace parser {
+
+/**
+ * @class ExplainStatement
+ * @brief Represents "EXPLAIN <query>"
+ */
+class ExplainStatement : public SQLStatement {
+ public:
+  ExplainStatement() : SQLStatement(StatementType::EXPLAIN) {}
+  virtual ~ExplainStatement() {}
+
+  void Accept(SqlNodeVisitor *v) override { v->Visit(this); }
+
+  std::unique_ptr<parser::SQLStatement> real_sql_stmt;
+};
+
+}  // namespace parser
+}  // namespace peloton

src/include/parser/parsenodes.h

@@ -326,6 +326,19 @@ typedef struct SelectStmt {
   /* Eventually add fields for CORRESPONDING spec here */
 } SelectStmt;
 
+/*
+ * Explain Statement
+ *
+ * The "query" field is initially a raw parse tree, and is converted to a
+ * Query node during parse analysis.  Note that rewriting and planning
+ * of the query are always postponed until execution.
+ */
+typedef struct ExplainStmt {
+  NodeTag type;
+  Node *query;   /* the query (see comments above) */
+  List *options; /* list of DefElem nodes */
+} ExplainStmt;
+
 typedef struct TypeName {
   NodeTag type;
   List *names;       /* qualified name (list of Value strings) */

src/include/parser/postgresparser.h

@@ -217,6 +217,9 @@ class PostgresParser {
   // transform helper for select statements
   static parser::SelectStatement *SelectTransform(SelectStmt *root);
 
+  // transform helper for explain statements
+  static parser::SQLStatement *ExplainTransform(ExplainStmt *root);
+
   // transform helper for delete statements
   static parser::SQLStatement *DeleteTransform(DeleteStmt *root);
 

src/include/parser/statements.h

@@ -21,6 +21,7 @@
 #include "delete_statement.h"
 #include "drop_statement.h"
 #include "execute_statement.h"
+#include "explain_statement.h"
 #include "insert_statement.h"
 #include "prepare_statement.h"
 #include "select_statement.h"

src/include/planner/insert_plan.h

@@ -6,7 +6,7 @@
 //
 // Identification: src/include/planner/insert_plan.h
 //
-// Copyright (c) 2015-17, Carnegie Mellon University Database Group
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
 //
 //===----------------------------------------------------------------------===//
 
@@ -29,11 +29,12 @@ class InsertStatement;
 }
 
 namespace planner {
+
 class InsertPlan : public AbstractPlan {
  public:
   // Construct when SELECT comes in with it
   InsertPlan(storage::DataTable *table, oid_t bulk_insert_count = 1)
-    : target_table_(table), bulk_insert_count_(bulk_insert_count) {
+      : target_table_(table), bulk_insert_count_(bulk_insert_count) {
     LOG_TRACE("Creating an Insert Plan with SELECT as a child");
   }
 
@@ -42,35 +43,50 @@ class InsertPlan : public AbstractPlan {
   InsertPlan(storage::DataTable *table,
              std::unique_ptr<const planner::ProjectInfo> &&project_info,
              oid_t bulk_insert_count = 1)
-    : target_table_(table), project_info_(std::move(project_info)),
-      bulk_insert_count_(bulk_insert_count) {
+      : target_table_(table),
+        project_info_(std::move(project_info)),
+        bulk_insert_count_(bulk_insert_count) {
     LOG_TRACE("Creating an Insert Plan with a projection");
   }
 
   // Construct with a tuple
   // This can only be handled by the interpreted exeuctor
-  InsertPlan(storage::DataTable *table,
-             std::unique_ptr<storage::Tuple> &&tuple,
+  InsertPlan(storage::DataTable *table, std::unique_ptr<storage::Tuple> &&tuple,
              oid_t bulk_insert_count = 1)
-    : target_table_(table), bulk_insert_count_(bulk_insert_count) {
+      : target_table_(table), bulk_insert_count_(bulk_insert_count) {
     LOG_TRACE("Creating an Insert Plan for one tuple");
     tuples_.push_back(std::move(tuple));
   }
 
-  // Construct with specific values
+  /**
+   * @brief Create an insert plan with specific values
+   *
+   * @param[in] table          Table to insert into
+   * @param[in] columns        Columns to insert into
+   * @param[in] insert_values  Values
+   */
   InsertPlan(storage::DataTable *table, const std::vector<std::string> *columns,
-             const std::vector<std::vector<std::unique_ptr<
-                 expression::AbstractExpression>>> *insert_values);
+             const std::vector<
+                 std::vector<std::unique_ptr<expression::AbstractExpression>>> *
+                 insert_values);
 
   // Get a varlen pool - will construct the pool only if needed
   type::AbstractPool *GetPlanPool();
 
-  PlanNodeType GetPlanNodeType() const override { return PlanNodeType::INSERT; }
+  PlanNodeType GetPlanNodeType() const override {
+    return PlanNodeType::INSERT;
+  };
 
+  /**
+   * @brief Save values for jdbc prepared statement insert.
+   *    Only a single tuple is presented to this function.
+   *
+   * @param[in] values  Values for insertion
+   */
   void SetParameterValues(std::vector<type::Value> *values) override;
 
-  /* 
-   * Clear the parameter values of the current insert. The plan may be 
+  /*
+   * Clear the parameter values of the current insert. The plan may be
    * cached in the statement / plan cache and may be reused.
    */
   void ClearParameterValues() override { values_.clear(); }
@@ -115,17 +131,86 @@ class InsertPlan : public AbstractPlan {
     return !(*this == rhs);
   }
 
-  virtual void VisitParameters(codegen::QueryParametersMap &map,
+  virtual void VisitParameters(
+      codegen::QueryParametersMap &map,
       std::vector<peloton::type::Value> &values,
       const std::vector<peloton::type::Value> &values_from_user) override;
 
  private:
+  /**
+   * Lookup a column name in the schema columns
+   *
+   * @param[in]  col_name    column name, from insert statement
+   * @param[in]  tbl_columns table columns from the schema
+   * @param[out] index       index into schema columns, only if found
+   *
+   * @return      true if column was found, false otherwise
+   */
+  bool FindSchemaColIndex(std::string col_name,
+                          const std::vector<catalog::Column> &tbl_columns,
+                          uint32_t &index);
+
+  /**
+   * Process column specification supplied in the insert statement.
+   * Construct a map from insert columns to schema columns. Once
+   * we know which columns will receive constant inserts, further
+   * adjustment of the map will be needed.
+   *
+   * @param[in] columns        Column specification
+   */
+  void ProcessColumnSpec(const std::vector<std::string> *columns);
+
+  /**
+   * Process a single expression to be inserted.
+   *
+   * @param[in] expr       insert expression
+   * @param[in] schema_idx index into schema columns, where the expr
+   *                       will be inserted.
+   * @return  true if values imply a prepared statement
+   *          false if all values are constants. This does not rule
+   *             out the insert being a prepared statement.
+   */
+  bool ProcessValueExpr(expression::AbstractExpression *expr,
+                        uint32_t schema_idx);
+
+  /**
+   * Set default value into a schema column
+   *
+   * @param[in] idx  schema column index
+   */
+  void SetDefaultValue(uint32_t idx);
+
+ private:
+  // mapping from schema columns to insert columns
+  struct SchemaColsToInsertCols {
+    // this schema column is present in the insert columns
+    bool in_insert_cols;
+
+    // For a PS, insert saved value (from constant in insert values list), no
+    // param value.
+    bool set_value;
+
+    // index of this column in insert columns values
+    int val_idx;
+
+    // schema column type
+    type::TypeId type;
+
+    // set_value refers to this saved value
+    type::Value value;
+  };
+
   // Target table
   storage::DataTable *target_table_ = nullptr;
 
   // Values
   std::vector<type::Value> values_;
 
+  // mapping from schema columns to vector of insert columns
+  std::vector<SchemaColsToInsertCols> schema_to_insert_;
+  // mapping from insert columns to schema columns
+  std::vector<uint32_t> insert_to_schema_;
+
   // Projection Info
   std::unique_ptr<const planner::ProjectInfo> project_info_;
 
@@ -148,9 +233,7 @@ class InsertPlan : public AbstractPlan {
   // Pool for variable length types
   std::unique_ptr<type::AbstractPool> pool_;
 
- private:
   DISALLOW_COPY_AND_MOVE(InsertPlan);
 };
-
 }  // namespace planner
 }  // namespace peloton