VM.h

Go to the documentation of this file.

#pragma once
 
#include "Api.h"
#include "CursorManager.h"
#include "Types.h"
 
#include <optional>
#include <string>
#include <unordered_set>
#include <vector>

 
namespace nt {

    struct PathArg {
        enum class Kind { Var, Const };
 
        Kind kind;
        std::string name; 
 
        static PathArg Var(std::string attr) {
            return {Kind::Var, std::move(attr)};
        }
        static PathArg Const(std::string val) {
            return {Kind::Const, std::move(val)};
        }
    };
 
    enum Operation {
        FOL_OPERATION_SCAN = 1,
        FOL_OPERATION_JOIN,
        FOL_OPERATION_TAKE,
        FOL_OPERATION_PROJECT,
        FOL_OPERATION_MATERIALIZE,
        FOL_OPERATION_RENAME,
        FOL_OPERATION_UNION
    };

    struct PlanNode {
        Operation op;
        PlanNode* left = nullptr;
        PlanNode* right = nullptr;

        CursorManager::cursor* scan_cursor = nullptr;

        std::vector<PathArg> scan_args;

        std::size_t take_limit = 0;
        std::size_t take_count = 0; 

        std::unordered_set<std::string> project_attrs;
        std::optional<Tuple> project_buffer;

        Tuple* join_left = nullptr;
        std::optional<Tuple> join_buffer;
        std::unordered_set<std::string> join_attrs;

        std::vector<Tuple> mat_buffer;
        std::size_t mat_pos = 0;
        bool mat_done = false;

        PlanNode* upstream = nullptr;
        std::unordered_map<std::string, std::string> attrs;

        std::vector<PlanNode*> nodes;
        std::vector<PlanNode*>::iterator current_node;
    };
 
    class VM {
      public:
        // TODO: CursorManager should be injected as a shared runtime instance,
        // matching the pattern flagged for HandlerManager and LifecycleManager.
        //
        // A single CursorManager instance supports multiple simultaneous cursors —
        // all iteration state lives in each cursor struct, not in the manager.
        // A JOIN plan, for example, holds two independent cursors (one per SCAN leaf)
        // and both are driven through the same CursorManager reference.
        explicit VM(CursorManager& cursors);

        Tuple* Next(PlanNode* node);
 
      private:
        CursorManager& cursors_;

        static std::vector<std::string> ResolveArgs(const std::vector<PathArg>& tmpl, Tuple* from);

        static void ResetInner(CursorManager::cursor* c, std::vector<std::string> args);

        void Rewind(PlanNode* node, Tuple* outer);

        static Tuple* MergeInto(PlanNode* node, Tuple* left, Tuple* right);
    };
} // namespace nt