first try of function translator

src/codegen/expression/function_translator.cpp

@@ -0,0 +1,20 @@
+#include "codegen/expression/function_translator.h"
+
+#include "expression/function_expression.h"
+
+namespace peloton {
+namespace codegen {
+
+// Constructor
+FunctionTranslator::FunctionTranslator(
+    const expression::FunctionExpression &exp, CompilationContext &ctx)
+    : ExpressionTranslator(exp, ctx) {}
+
+codegen::Value FunctionTranslator::DeriveValue(
+    CodeGen &codegen, RowBatch::Row &row) const {
+  const auto &func_expr = GetExpressionAs<expression::FunctionExpression>();
+  func_expr->
+}
+
+}  // namespace codegen
+}  // namespace peloton

src/codegen/query_compiler.cpp

@@ -127,7 +127,6 @@ bool QueryCompiler::IsExpressionSupported(
     const expression::AbstractExpression &expr) {
   switch (expr.GetExpressionType()) {
     case ExpressionType::STAR:
-    case ExpressionType::FUNCTION:
     case ExpressionType::VALUE_PARAMETER:
       return false;
     default:

src/codegen/translator_factory.cpp

@@ -26,6 +26,7 @@
 #include "codegen/operator/projection_translator.h"
 #include "codegen/operator/table_scan_translator.h"
 #include "codegen/expression/tuple_value_translator.h"
+#include "codegen/expression/function_translator.h"
 #include "expression/case_expression.h"
 #include "expression/comparison_expression.h"
 #include "expression/conjunction_expression.h"
@@ -161,6 +162,11 @@ std::unique_ptr<ExpressionTranslator> TranslatorFactory::CreateTranslator(
       translator = new CaseTranslator(case_exp, context);
       break;
     }
+    case ExpressionType::FUNCTION: {
+      auto &func_exp = static_cast<const expression::FunctionExpression &>(exp);
+      translator = new FunctionTranslator(func_exp, context);
+      break;
+    }
     default: {
       throw Exception{"We don't have a translator for expression type: " +
                       ExpressionTypeToString(exp.GetExpressionType())};

src/include/codegen/expression/function_translator.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "codegen/expression/expression_translator.h"
+
+namespace peloton {
+
+namespace expression {
+class FunctionExpression;
+}  // namespace expression
+
+namespace codegen {
+
+//===----------------------------------------------------------------------===//
+// A translator for function expression
+//===----------------------------------------------------------------------===//
+class FunctionTranslator : public ExpressionTranslator {
+ public:
+  // Constructor
+  FunctionTranslator(const expression::FunctionExpression &func_expr,
+                       CompilationContext &context);
+
+  // Return the result of the function call
+  codegen::Value DeriveValue(CodeGen &codegen,
+                             RowBatch::Row &row) const override;
+};
+
+}  // namespace codegen
+}  // namespace peloton