Merge pull request #1108 from pranavk/explain_gh

Support for EXPLAIN statement

Author: pervazea

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/network/postgres_protocol_handler.cpp

@@ -23,14 +23,17 @@
 #include "network/postgres_protocol_handler.h"
 #include "network/peloton_server.h"
 #include "parser/postgresparser.h"
+#include "parser/statements.h"
 #include "planner/abstract_plan.h"
 #include "planner/delete_plan.h"
 #include "planner/insert_plan.h"
+#include "planner/plan_util.h"
 #include "planner/update_plan.h"
 #include "settings/settings_manager.h"
 #include "traffic_cop/traffic_cop.h"
 #include "type/value.h"
 #include "type/value_factory.h"
+#include "util/string_util.h"
 
 #define SSL_MESSAGE_VERNO 80877103
 #define PROTO_MAJOR_VERSION(x) (x >> 16)
@@ -219,6 +222,12 @@ ProcessResult PostgresProtocolHandler::ExecQueryMessage(
       ExecQueryMessageGetResult(status);
       return ProcessResult::COMPLETE;
     };
+    case QueryType::QUERY_EXPLAIN: {
+      auto status = ExecQueryExplain(
+          query, static_cast<parser::ExplainStatement &>(*sql_stmt));
+      ExecQueryMessageGetResult(status);
+      return ProcessResult::COMPLETE;
+    }
     default: {
       std::string stmt_name = "unamed";
       std::unique_ptr<parser::SQLStatementList> unnamed_sql_stmt_list(
@@ -248,6 +257,30 @@ ProcessResult PostgresProtocolHandler::ExecQueryMessage(
   }
 }
 
+ResultType PostgresProtocolHandler::ExecQueryExplain(
+    const std::string &query, parser::ExplainStatement &explain_stmt) {
+  std::unique_ptr<parser::SQLStatementList> unnamed_sql_stmt_list(
+      new parser::SQLStatementList());
+  unnamed_sql_stmt_list->PassInStatement(std::move(explain_stmt.real_sql_stmt));
+  auto stmt = traffic_cop_->PrepareStatement(
+      "explain", query, std::move(unnamed_sql_stmt_list));
+  ResultType status = ResultType::UNKNOWN;
+  if (stmt != nullptr) {
+    traffic_cop_->SetStatement(stmt);
+    std::vector<std::string> plan_info = StringUtil::Split(
+        planner::PlanUtil::GetInfo(stmt->GetPlanTree().get()), '\n');
+    const std::vector<FieldInfo> tuple_descriptor = {
+        traffic_cop_->GetColumnFieldForValueType("Query plan",
+                                                 type::TypeId::VARCHAR)};
+    stmt->SetTupleDescriptor(tuple_descriptor);
+    traffic_cop_->SetResult(plan_info);
+    status = ResultType::SUCCESS;
+  } else {
+    status = ResultType::FAILURE;
+  }
+  return status;
+}
+
 void PostgresProtocolHandler::ExecQueryMessageGetResult(ResultType status) {
   std::vector<FieldInfo> tuple_descriptor;
   if (status == ResultType::SUCCESS) {
@@ -826,7 +859,7 @@ void PostgresProtocolHandler::ExecExecuteMessageGetResult(ResultType status) {
       return;
     }
   }
-}  // namespace network
+}
 
 void PostgresProtocolHandler::GetResult() {
   traffic_cop_->ExecuteStatementPlanGetResult();

src/parser/postgresparser.cpp

@@ -1686,6 +1686,12 @@ parser::SelectStatement *PostgresParser::SelectTransform(SelectStmt *root) {
   return result;
 }
 
+parser::SQLStatement *PostgresParser::ExplainTransform(ExplainStmt *root) {
+  parser::ExplainStatement *result = new parser::ExplainStatement();
+  result->real_sql_stmt.reset(NodeTransform(root->query));
+  return result;
+}
+
 // This function takes in a Postgres DeleteStmt parsenode
 // and transfers into a Peloton DeleteStatement parsenode.
 // Please refer to parser/parsenode.h for the definition of
@@ -1787,6 +1793,9 @@ parser::SQLStatement *PostgresParser::NodeTransform(Node *stmt) {
     case T_VariableSetStmt:
       result = VariableSetTransform((VariableSetStmt*)stmt);
       break;
+    case T_ExplainStmt:
+      result = ExplainTransform(reinterpret_cast<ExplainStmt *>(stmt));
+      break;
     default: {
       throw NotImplementedException(StringUtil::Format(
           "Statement of type %d not supported yet...\n", stmt->type));