Support for EXPLAIN statement

Author: pranavk

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/parser/explain_statement.h

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// explain_statement.h
+//
+// Identification: src/include/parser/explain_statement.h
+//
+// Copyright (c) 2018, Pranav Kant
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "common/logger.h"
+#include "common/sql_node_visitor.h"
+#include "expression/abstract_expression.h"
+#include "parser/sql_statement.h"
+#include "parser/table_ref.h"
+
+namespace peloton {
+namespace parser {
+
+/**
+ * @class ExplainStatement
+ * @brief Represents "EXPLAIN <query>"
+ */
+class ExplainStatement : public SQLStatement {
+ public:
+  ExplainStatement()
+      : SQLStatement(StatementType::EXPLAIN) {}
+  virtual ~ExplainStatement() {}
+
+  virtual void Accept(SqlNodeVisitor* /*v*/) override { }
+
+  std::unique_ptr<parser::SQLStatement> real_sql_stmt;
+};
+
+}  // namespace parser
+}  // namespace peloton

src/include/parser/parsenodes.h

@@ -326,6 +326,21 @@ 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

@@ -26,11 +26,14 @@
 #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 "network/marshal.h"
+#include "util/string_util.h"
 
 #define SSL_MESSAGE_VERNO 80877103
 #define PROTO_MAJOR_VERSION(x) (x >> 16)
@@ -219,6 +222,33 @@ ProcessResult PostgresProtocolHandler::ExecQueryMessage(
       ExecQueryMessageGetResult(status);
       return ProcessResult::COMPLETE;
     };
+    case QueryType::QUERY_EXPLAIN: {
+      parser::ExplainStatement *explain_stmt =
+          static_cast<parser::ExplainStatement *>(sql_stmt.get());
+      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), error_message);
+      ResultType status = ResultType::UNKNOWN;
+      if (stmt) {
+        traffic_cop_->SetStatement(stmt);
+        std::vector<std::string> plan_info = StringUtil::Split(
+            planner::PlanUtil::GetInfo(stmt->GetPlanTree().get()), '\n');
+        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 {
+        traffic_cop_->SetErrorMessage(error_message);
+        status = ResultType::FAILURE;
+      }
+      ExecQueryMessageGetResult(status);
+      return ProcessResult::COMPLETE;
+    }
     default: {
       std::string stmt_name = "unamed";
       std::unique_ptr<parser::SQLStatementList> unnamed_sql_stmt_list(

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));