Sema.hpp

Go to the documentation of this file.

#pragma once
 
#include <mutable/catalog/Catalog.hpp>
#include <mutable/catalog/DatabaseCommand.hpp>
#include <mutable/parse/AST.hpp>
#include <mutable/util/Diagnostic.hpp>
#include <sstream>
#include <unordered_map>
#include <vector>
 
 
namespace m {
 
namespace ast {
 
struct M_EXPORT Sema : ASTVisitor
{
    struct SemaContext
    {
        ThreadSafePooledOptionalString alias;
 
        Stmt &stmt;
        enum stage_t {
            S_From,
            S_Where,
            S_GroupBy,
            S_Having,
            S_Select,
            S_OrderBy,
            S_Limit,
        } stage = S_From; 
 
        bool needs_grouping = false;
 
        struct result_t
        {
            std::reference_wrapper<Expr> expr_;
            unsigned order;
            ThreadSafePooledOptionalString alias;
 
            result_t(Expr &expr, unsigned order) : expr_(expr), order(order) { }
            result_t(Expr &expr, unsigned order, ThreadSafePooledOptionalString alias)
                : expr_(expr), order(order), alias(std::move(alias))
            { }
 
            Expr & expr() { return expr_.get(); }
            const Expr & expr() const { return expr_.get(); }
        };
 
        using named_expr_table = std::unordered_multimap<ThreadSafePooledString,
                                                         std::pair<std::reference_wrapper<Expr>, unsigned>>;
        using source_type = std::variant<std::monostate, std::reference_wrapper<const Table>, named_expr_table>;
        using source_table = std::unordered_map<ThreadSafePooledString, std::pair<source_type, unsigned>>;
        source_table sources;
        std::unordered_multimap<ThreadSafePooledString, result_t> results;
        std::unordered_multimap<ThreadSafePooledString, std::reference_wrapper<Expr>> grouping_keys;
 
        SemaContext(Stmt &stmt) : stmt(stmt) { }
    };
 
    private:
    struct RequireContext
    {
        private:
        Sema &sema_;
        bool needs_context_ = false;
 
        public:
        RequireContext(Sema *sema, Stmt &stmt)
            : sema_(*M_notnull(sema))
            , needs_context_(sema_.contexts_.empty())
        {
            if (needs_context_)
                sema_.push_context(stmt);
        }
 
        ~RequireContext() {
            if (needs_context_)
                sema_.pop_context();
        }
    };
 
    public:
    Diagnostic &diag;
    private:
    using context_stack_t = std::vector<SemaContext*>;
    context_stack_t contexts_;
    std::ostringstream oss;
    std::unique_ptr<DatabaseCommand> command_;
 
    public:
    Sema(Diagnostic &diag) : diag(diag) { }
 
    std::unique_ptr<DatabaseCommand> analyze(std::unique_ptr<ast::Command> ast);
 
    using ASTExprVisitor::operator();
    using ASTClauseVisitor::operator();
    using ASTCommandVisitor::operator();
#define DECLARE(CLASS) void operator()(CLASS&) override;
    M_AST_EXPR_LIST(DECLARE)
    M_AST_CLAUSE_LIST(DECLARE)
    M_AST_COMMAND_LIST(DECLARE)
#undef DECLARE
 
    private:
    SemaContext & push_context(Stmt &stmt, ThreadSafePooledOptionalString alias = {}) {
        auto &ref = contexts_.emplace_back(new SemaContext(stmt));
        ref->alias = std::move(alias);
        return *ref;
    }
    SemaContext pop_context() {
        auto ctx = *contexts_.back();
        delete contexts_.back();
        contexts_.pop_back();
        return ctx;
    }
    SemaContext & get_context() {
        M_insist(not contexts_.empty());
        return *contexts_.back();
    }
    const SemaContext & get_context() const {
        M_insist(not contexts_.empty());
        return *contexts_.back();
    }
 
    bool is_nested() const;
 
 
    /*------------------------------------------------------------------------------------------------------------------
     * Sema Designator Helpers
     *----------------------------------------------------------------------------------------------------------------*/
 
    std::unique_ptr<Designator> create_designator(ThreadSafePooledString name, Token tok, const Expr &target);
 
    std::unique_ptr<Designator> create_designator(const Expr &name, const Expr &target, bool drop_table_name = false);
 
    std::unique_ptr<Designator> create_designator(Position pos, ThreadSafePooledString table_name,
                                                  ThreadSafePooledString attr_name,
                                                  typename Designator::target_type target, const Type *type)
    {
        auto &C = Catalog::Get();
        Token dot(pos, C.pool("."), TK_DOT);
        Token table(pos, std::move(table_name), TK_IDENTIFIER);
        Token attr(pos, std::move(attr_name), TK_IDENTIFIER);
        auto d = std::make_unique<Designator>(std::move(dot), std::move(table), std::move(attr));
        d->type_ = type;
        d->target_ = target;
        return d;
    }
 
    void replace_by_fresh_designator_to(std::unique_ptr<Expr> &to_replace, const Expr &target);
 
 
    /*------------------------------------------------------------------------------------------------------------------
     * Other Sema Helpers
     *----------------------------------------------------------------------------------------------------------------*/
 
    bool is_composable_of(const ast::Expr &expr, const std::vector<std::reference_wrapper<ast::Expr>> components);
 
    void compose_of(std::unique_ptr<ast::Expr> &ptr, const std::vector<std::reference_wrapper<ast::Expr>> components);
 
    ThreadSafePooledOptionalString make_unique_id_from_binding_path(context_stack_t::reverse_iterator current_ctx,
                                                                    context_stack_t::reverse_iterator binding_ctx);
};
 
}
 
}