[Interpreter] Add physical operators for the Interpreter.

The added physical operators implement a simple 1:1 mapping
between logical and physical operators. Thus, for executing
a query, the former visitor pattern can still be used.

Author: lucagretscher

src/backend/CMakeLists.txt

@@ -1,6 +1,7 @@
 set(
     BACKEND_SOURCES
     Interpreter.cpp
+    InterpreterOperator.cpp
     StackMachine.cpp
 )
 

src/backend/Interpreter.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "backend/InterpreterOperator.hpp"
 #include "backend/StackMachine.hpp"
 #include <cerrno>
 #include <ctime>
@@ -216,9 +217,11 @@ struct Interpreter : Backend, ConstOperatorVisitor
     public:
     Interpreter() = default;
 
-    void register_operators(PhysicalOptimizer &phys_opt) const override { /* nothing to be done */ }
+    void register_operators(PhysicalOptimizer &phys_opt) const override { register_interpreter_operators(phys_opt); }
 
-    void execute(const MatchBase &plan) const override { M_unreachable("currently not supported"); }
+    void execute(const MatchBase &plan) const override {
+        (*const_cast<Interpreter*>(this))(plan.get_matched_singleton()); // use former visitor pattern on logical operators
+    }
 
     using ConstOperatorVisitor::operator();
 #define DECLARE(CLASS) void operator()(Const<CLASS> &op) override;

src/backend/InterpreterOperator.cpp

@@ -0,0 +1,12 @@
+#include "backend/InterpreterOperator.hpp"
+
+
+using namespace m;
+
+
+void m::register_interpreter_operators(PhysicalOptimizer &phys_opt)
+{
+#define REGISTER(CLASS) phys_opt.register_operator<interpreter::CLASS>();
+M_OPERATOR_LIST(REGISTER)
+#undef REGISTER
+}

src/backend/InterpreterOperator.hpp

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <mutable/IR/PhysicalOptimizer.hpp>
+
+
+namespace m {
+
+/** This macro declares a simple 1:1 mapping between logical and physical operator for the `Interpreter`. */
+#define DECLARE(CLASS) \
+/* forward declarations */ \
+namespace interpreter { struct CLASS; } \
+template<> struct Match<interpreter::CLASS>; \
+\
+namespace interpreter { \
+\
+struct CLASS : PhysicalOperator<CLASS, m::CLASS> \
+{ \
+    static void execute(const Match<CLASS>&, setup_t, pipeline_t, teardown_t) { M_unreachable("not implemented"); } \
+    static double cost(const Match<CLASS>&) { return 1.0; } \
+    static ConditionSet \
+    adapt_post_conditions(const Match<CLASS>&, std::vector<std::reference_wrapper<const ConditionSet>>&&) { \
+        return ConditionSet(); /* has to be overwritten for operators with multiple children, i.e. `JoinOperator` */ \
+    } \
+}; \
+\
+} \
+\
+template<> \
+struct Match<interpreter::CLASS> : MatchBase \
+{ \
+    const CLASS &op; \
+    std::vector<std::reference_wrapper<const MatchBase>> children; \
+\
+    Match(const CLASS *op, std::vector<std::reference_wrapper<const MatchBase>> &&children) \
+        : op(*op) \
+        , children(std::move(children)) \
+    { } \
+\
+    void execute(setup_t, pipeline_t, teardown_t) const override { \
+        M_unreachable("must not be called since `Interpreter` uses former visitor pattern on logical operators for " \
+                      "execution"); \
+    } \
+\
+    const Operator & get_matched_singleton() const override { return op; } \
+\
+    protected: \
+    void print(std::ostream &out, unsigned level) const override { \
+        indent(out, level) << "interpreter::" << #CLASS << " (cumulative cost " << cost() << ')'; \
+        for (auto &child : children) \
+            child.get().print(out, level + 1); \
+    } \
+};
+M_OPERATOR_LIST(DECLARE)
+#undef DECLARE
+
+void register_interpreter_operators(PhysicalOptimizer &phys_opt);
+
+}