GDV-87: Add support to print expressions (apache#63)

Author: vvellanki

cpp/src/gandiva/codegen/CMakeLists.txt

@@ -33,6 +33,7 @@ set(SRC_FILES annotator.cc
       llvm_types.cc
       projector.cc
       status.cc
+      expression.cc
       tree_expr_builder.cc
       ${BC_FILE_PATH_CC})
 

cpp/src/gandiva/codegen/expression.cc

@@ -0,0 +1,22 @@
+// Copyright (C) 2017-2018 Dremio Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "gandiva/expression.h"
+#include "codegen/node.h"
+
+namespace gandiva {
+
+std::string Expression::ToString() { return root()->ToString(); }
+
+}  // namespace gandiva

cpp/src/gandiva/codegen/expression.h

@@ -30,6 +30,8 @@ class Expression {
 
   const FieldPtr &result() const { return result_; }
 
+  std::string ToString();
+
  private:
   const NodePtr root_;
   const FieldPtr result_;

cpp/src/gandiva/codegen/node.h

@@ -38,6 +38,8 @@ class Node {
   /// Derived classes should simply invoke the Visit api of the visitor.
   virtual Status Accept(NodeVisitor &visitor) const = 0;
 
+  virtual std::string ToString() = 0;
+
  protected:
   DataTypePtr return_type_;
 };
@@ -54,6 +56,16 @@ class LiteralNode : public Node {
 
   bool is_null() const { return is_null_; }
 
+  std::string ToString() override {
+    if (is_null()) {
+      return std::string("null");
+    }
+
+    std::stringstream ss;
+    ss << holder();
+    return ss.str();
+  }
+
  private:
   LiteralHolder holder_;
   bool is_null_;
@@ -68,6 +80,8 @@ class FieldNode : public Node {
 
   const FieldPtr &field() const { return field_; }
 
+  std::string ToString() override { return field()->type()->name(); }
+
  private:
   FieldPtr field_;
 };
@@ -84,6 +98,22 @@ class FunctionNode : public Node {
   const FuncDescriptorPtr &descriptor() const { return descriptor_; }
   const NodeVector &children() const { return children_; }
 
+  std::string ToString() override {
+    std::stringstream ss;
+    ss << descriptor()->return_type()->name() << " " << descriptor()->name() << "(";
+    bool skip_comma = true;
+    for (auto child : children()) {
+      if (skip_comma) {
+        ss << child->ToString();
+        skip_comma = false;
+      } else {
+        ss << ", " << child->ToString();
+      }
+    }
+    ss << ")";
+    return ss.str();
+  }
+
   /// Make a function node with params types specified by 'children', and
   /// having return type ret_type.
   static NodePtr MakeFunction(const std::string &name, const NodeVector &children,
@@ -121,6 +151,14 @@ class IfNode : public Node {
   const NodePtr &then_node() const { return then_node_; }
   const NodePtr &else_node() const { return else_node_; }
 
+  std::string ToString() override {
+    std::stringstream ss;
+    ss << "if (" << condition()->ToString() << ") { ";
+    ss << then_node()->ToString() << " } else { ";
+    ss << else_node()->ToString() << " }";
+    return ss.str();
+  }
+
  private:
   NodePtr condition_;
   NodePtr then_node_;
@@ -141,6 +179,18 @@ class BooleanNode : public Node {
 
   const NodeVector &children() const { return children_; }
 
+  std::string ToString() override {
+    std::stringstream ss;
+    ss << children_.at(0)->ToString();
+    if (expr_type() == BooleanNode::AND) {
+      ss << " && ";
+    } else {
+      ss << " || ";
+    }
+    ss << children_.at(1)->ToString();
+    return ss.str();
+  }
+
  private:
   ExprType expr_type_;
   NodeVector children_;

cpp/src/gandiva/codegen/tree_expr_builder.cc

@@ -112,10 +112,16 @@ NodePtr TreeExprBuilder::MakeOr(const NodeVector &children) {
   return std::make_shared<BooleanNode>(BooleanNode::OR, children);
 }
 
+// set this to true to print expressions for debugging purposes
+static bool print_expr = false;
+
 ExpressionPtr TreeExprBuilder::MakeExpression(NodePtr root_node, FieldPtr result_field) {
   if (result_field == nullptr) {
     return nullptr;
   }
+  if (print_expr) {
+    std::cout << "Expression: " << root_node->ToString() << "\n";
+  }
   return ExpressionPtr(new Expression(root_node, result_field));
 }
 

cpp/src/gandiva/integ/CMakeLists.txt

@@ -24,4 +24,5 @@ foreach(lib_type "shared" "static")
   add_gandiva_integ_test(binary_test.cc gandiva_${lib_type})
   add_gandiva_integ_test(date_time_test.cc gandiva_${lib_type})
   add_gandiva_integ_test(micro_benchmarks.cc gandiva_${lib_type})
+  add_gandiva_integ_test(to_string_test.cc gandiva_${lib_type})
 endforeach(lib_type)

cpp/src/gandiva/integ/to_string_test.cc

@@ -0,0 +1,80 @@
+// Copyright (C) 2017-2018 Dremio Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <gtest/gtest.h>
+#include <math.h>
+#include <time.h>
+#include "arrow/memory_pool.h"
+#include "gandiva/projector.h"
+#include "gandiva/tree_expr_builder.h"
+#include "integ/test_util.h"
+
+namespace gandiva {
+
+using arrow::boolean;
+using arrow::float64;
+using arrow::int32;
+using arrow::int64;
+
+class TestToString : public ::testing::Test {
+ public:
+  void SetUp() { pool_ = arrow::default_memory_pool(); }
+
+ protected:
+  arrow::MemoryPool* pool_;
+};
+
+#define CHECK_EXPR_TO_STRING(e, str) EXPECT_STREQ(e->ToString().c_str(), str)
+
+TEST_F(TestToString, TestAll) {
+  auto literal_node = TreeExprBuilder::MakeLiteral((uint64_t)100);
+  auto literal_expr =
+      TreeExprBuilder::MakeExpression(literal_node, arrow::field("r", int64()));
+  CHECK_EXPR_TO_STRING(literal_expr, "100");
+
+  auto f0 = arrow::field("f0", float64());
+  auto f0_node = TreeExprBuilder::MakeField(f0);
+  auto f0_expr = TreeExprBuilder::MakeExpression(f0_node, f0);
+  CHECK_EXPR_TO_STRING(f0_expr, "double");
+
+  auto f1 = arrow::field("f1", int64());
+  auto f2 = arrow::field("f2", int64());
+  auto f1_node = TreeExprBuilder::MakeField(f1);
+  auto f2_node = TreeExprBuilder::MakeField(f2);
+  auto add_node = TreeExprBuilder::MakeFunction("add", {f1_node, f2_node}, int64());
+  auto add_expr = TreeExprBuilder::MakeExpression(add_node, f1);
+  CHECK_EXPR_TO_STRING(add_expr, "int64 add(int64, int64)");
+
+  auto cond_node = TreeExprBuilder::MakeFunction(
+      "lesser_than", {f0_node, TreeExprBuilder::MakeLiteral((float)0)}, boolean());
+  auto then_node = TreeExprBuilder::MakeField(f1);
+  auto else_node = TreeExprBuilder::MakeField(f2);
+
+  auto if_node = TreeExprBuilder::MakeIf(cond_node, then_node, else_node, int64());
+  auto if_expr = TreeExprBuilder::MakeExpression(if_node, f1);
+  CHECK_EXPR_TO_STRING(if_expr,
+                       "if (bool lesser_than(double, 0)) { int64 } else { int64 }");
+
+  auto f1_gt_100 =
+      TreeExprBuilder::MakeFunction("greater_than", {f1_node, literal_node}, boolean());
+  auto f2_equals_100 =
+      TreeExprBuilder::MakeFunction("equals", {f2_node, literal_node}, boolean());
+  auto and_node = TreeExprBuilder::MakeAnd({f1_gt_100, f2_equals_100});
+  auto and_expr =
+      TreeExprBuilder::MakeExpression(and_node, arrow::field("f0", boolean()));
+  CHECK_EXPR_TO_STRING(and_expr,
+                       "bool greater_than(int64, 100) && bool equals(int64, 100)");
+}
+
+}  // namespace gandiva