AST.hpp

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <memory>
#include <mutable/catalog/Schema.hpp>
#include <mutable/lex/Token.hpp>
#include <mutable/mutable-config.hpp>
#include <variant>
#include <vector>
 
 
namespace m {
 
struct Type;
struct Function;
struct Attribute;
struct Table;
 
namespace ast {
 
struct ASTClauseVisitor;
struct ASTCommandVisitor;
struct ASTConstraintVisitor;
struct ASTExprVisitor;
struct ConstASTClauseVisitor;
struct ConstASTCommandVisitor;
struct ConstASTConstraintVisitor;
struct ConstASTExprVisitor;
struct Sema;
struct Stmt;
 
 
/*======================================================================================================================
* Expressions
*====================================================================================================================*/
 
struct M_EXPORT Expr
{
    friend struct Sema;
    friend struct GetCorrelationInfo;
 
    Token tok; 
 
    private:
    const Type *type_ = nullptr;
    bool is_correlated_ = false;
 
    public:
    explicit Expr(Token tok) : tok(std::move(tok)) { }
    Expr(Token tok, const Type *type) : tok(std::move(tok)), type_(type) { }
    virtual ~Expr() { }
 
    const Type * type() const { return M_notnull(type_); }
    void type(const Type *type) { M_insist(not type_); type_ = type; }
    bool has_type() const { return type_ != nullptr; }
 
    virtual bool is_constant() const = 0;
    virtual bool can_be_null() const = 0;
 
    virtual bool contains_free_variables() const = 0;
    virtual bool contains_bound_variables() const  = 0;
 
    virtual uint64_t hash() const = 0;
 
    virtual bool operator==(const Expr &other) const = 0;
    bool operator!=(const Expr &other) const { return not operator==(other); }
 
    virtual void accept(ASTExprVisitor &v) = 0;
    virtual void accept(ConstASTExprVisitor &v) const = 0;
 
    Schema get_required() const;
 
    void dot(std::ostream &out) const;
 
    friend std::ostream & M_EXPORT operator<<(std::ostream &out, const Expr &e);
 
M_LCOV_EXCL_START
    friend std::string to_string(const Expr &e) {
        std::ostringstream oss;
        oss << e;
        return oss.str();
    }
M_LCOV_EXCL_STOP
 
    void dump(std::ostream &out) const;
    void dump() const;
};
 
struct M_EXPORT ErrorExpr : Expr
{
    explicit ErrorExpr(Token tok) : Expr(std::move(tok)) { }
 
    bool is_constant() const override { return false; }
    bool can_be_null() const override { return false; }
    bool contains_free_variables() const override { return false; }
    bool contains_bound_variables() const override { return false; }
 
    uint64_t hash() const override { return 8546018603292329429UL; }
 
    bool operator==(const Expr &other) const override;
 
    void accept(ASTExprVisitor &v) override;
    void accept(ConstASTExprVisitor &v) const override;
};
 
struct M_EXPORT Designator : Expr
{
    friend struct Sema;
 
    using target_type = std::variant<std::monostate, const Expr*, const Attribute*>;
    Token table_name;
    Token attr_name;
    private:
    target_type target_; 
    unsigned binding_depth_ = 0; 
    ThreadSafePooledOptionalString unique_id_; 
 
    public:
    explicit Designator(Token attr_name)
        : Expr(attr_name)
        , table_name(Token::CreateArtificial())
        , attr_name(std::move(attr_name))
    { }
 
    Designator(Token dot, Token table_name, Token attr_name)
        : Expr(std::move(dot))
        , table_name(std::move(table_name))
        , attr_name(std::move(attr_name))
    { }
 
    Designator(Token dot, Token table_name, Token attr_name, const Type *type, target_type target)
        : Expr(std::move(dot), type)
        , table_name(std::move(table_name))
        , attr_name(std::move(attr_name))
        , target_(target)
    { }
 
    bool is_constant() const override {
        if (auto e = std::get_if<const Expr*>(&target_))
            return (*e)->is_constant();
        return false;
    }
    bool can_be_null() const override {
        return std::visit(overloaded {
            [](const Expr *e) -> bool { return e->can_be_null(); },
            [](const Attribute *a) -> bool { return not a->not_nullable; },
            [](std::monostate) -> bool { return true; }
        }, target_);
    }
 
    bool contains_free_variables() const override { return binding_depth_ != 0; }
    bool contains_bound_variables() const override { return binding_depth_ == 0; }
 
    unsigned binding_depth() const { return binding_depth_; }
 
    uint64_t hash() const override;
 
    bool operator==(const Expr &other) const override;
 
    void accept(ASTExprVisitor &v) override;
    void accept(ConstASTExprVisitor &v) const override;
 
    bool has_explicit_table_name() const { return bool(table_name); }
    bool is_identifier() const { return not has_table_name(); }
 
    bool has_table_name() const { return table_name.text.has_value(); }
    ThreadSafePooledString get_table_name() const {
        M_insist(has_table_name(),
               "if the table name was not explicitly provided, semantic analysis must deduce it first");
        return table_name.text.assert_not_none();
    }
 
    const target_type & target() const { return target_; }
 
    private:
    void set_binding_depth(unsigned depth) { binding_depth_ = depth; }
    void decrease_binding_depth() { M_insist(binding_depth_ > 0); --binding_depth_; }
};
 
struct M_EXPORT Constant : Expr
{
    Constant(Token tok) : Expr(std::move(tok)) {}
 
    bool is_constant() const override { return true; }
    bool can_be_null() const override { return is_null(); }
    bool contains_free_variables() const override { return false; }
    bool contains_bound_variables() const override { return false; }
 
    uint64_t hash() const override;
 
    bool operator==(const Expr &other) const override;
 
    void accept(ASTExprVisitor &v) override;
    void accept(ConstASTExprVisitor &v) const override;
 
    bool is_null() const { return tok.type == TK_Null; }
    bool is_bool() const { return tok.type == TK_True or tok.type == TK_False; }
    bool is_number() const { return is_integer() or is_float(); }
    bool is_integer() const { return tok.type == TK_OCT_INT or tok.type == TK_DEC_INT or tok.type == TK_HEX_FLOAT; }
    bool is_float() const { return tok.type == TK_DEC_FLOAT or tok.type == TK_HEX_FLOAT; }
    bool is_string() const { return tok.type == TK_STRING_LITERAL; }
    bool is_date() const { return tok.type == TK_DATE; }
    bool is_datetime() const { return tok.type == TK_DATE_TIME; }
};
 
struct M_EXPORT PostfixExpr : Expr
{
    PostfixExpr(Token tok) : Expr(std::move(tok)) {}
};
 
struct M_EXPORT FnApplicationExpr : PostfixExpr
{
    friend struct Sema;
 
    std::unique_ptr<Expr> fn;
    std::vector<std::unique_ptr<Expr>> args;
    private:
    const Function *func_ = nullptr;
 
    public:
    FnApplicationExpr(Token lpar, std::unique_ptr<Expr> fn, std::vector<std::unique_ptr<Expr>> args)
        : PostfixExpr(std::move(lpar))
        , fn(M_notnull(std::move(fn)))
        , args(std::move(args))
    {
#ifndef NDEBUG
        for (auto &arg : args) M_insist(bool(arg));
#endif
    }
 
    bool is_constant() const override { return false; }
    bool can_be_null() const override {
        if (not func_)
            return true;
        switch (func_->fnid) {
            default:
                M_unreachable("function kind not implemented");
 
            case m::Function::FN_UDF:
                return true;
 
            case Function::FN_COUNT:
            case Function::FN_ISNULL:
                return false;
 
            case Function::FN_MIN:
            case Function::FN_MAX:
            case Function::FN_SUM:
            case Function::FN_AVG:
            case Function::FN_INT:
                M_insist(args.size() == 1);
                return args[0]->can_be_null();
        }
    }
 
    /* A `FnApplicationExpr` is correlated iff at least one argument is correlated. */
    bool contains_free_variables() const override {
        // if (fn->contains_free_variables()) return true;
        for (auto &arg : args)
            if (arg->contains_free_variables())
                return true;
        return false;
    }
 
    bool contains_bound_variables() const override {
        if (fn->contains_bound_variables()) return true;
        for (auto &arg : args)
            if (arg->contains_bound_variables())
                return true;
        return false;
    }
 
    uint64_t hash() const override;
 
    bool operator==(const Expr &other) const override;
 
    bool has_function() const { return func_; }
    const Function &get_function() const {
        if (not func_)
            throw runtime_error("no function provided");
        return *func_;
    }
 
    void accept(ASTExprVisitor &v) override;
    void accept(ConstASTExprVisitor &v) const override;
};
 
struct M_EXPORT UnaryExpr : Expr
{
    std::unique_ptr<Expr> expr;
 
    UnaryExpr(Token op, std::unique_ptr<Expr> expr)
        : Expr(std::move(op))
        , expr(M_notnull(std::move(expr)))
    { }
 
    bool is_constant() const override { return expr->is_constant(); }
    bool can_be_null() const override { return expr->can_be_null(); }
    bool contains_free_variables() const override { return expr->contains_free_variables(); }
    bool contains_bound_variables() const override { return expr->contains_bound_variables(); }
    Token op() const { return tok; }
 
    uint64_t hash() const override;
 
    bool operator==(const Expr &other) const override;
 
    void accept(ASTExprVisitor &v) override;
    void accept(ConstASTExprVisitor &v) const override;
};
 
struct M_EXPORT BinaryExpr : Expr
{
    std::unique_ptr<Expr> lhs;
    std::unique_ptr<Expr> rhs;
    const Numeric *common_operand_type = nullptr;
 
    BinaryExpr(Token op, std::unique_ptr<Expr> lhs, std::unique_ptr<Expr> rhs)
        : Expr(std::move(op))
        , lhs(M_notnull(std::move(lhs)))
        , rhs(M_notnull(std::move(rhs)))
    { }
 
    bool is_constant() const override { return lhs->is_constant() and rhs->is_constant(); }
    bool can_be_null() const override {
        if (tok.type == TK_And or tok.type == TK_Or) { // special case handling for ternary logic of `AND` and `OR`
            /* TODO: use `is_constant()` and check whether one side *evaluates* to dominating element */
            const auto dominating_element = tok.type == TK_And ? TK_False : TK_True;
            const auto lhs_const = cast<Constant>(lhs.get());
            const auto rhs_const = cast<Constant>(rhs.get());
            const bool lhs_dominates = lhs_const and lhs_const->tok.type == dominating_element;
            const bool rhs_dominates = rhs_const and rhs_const->tok.type == dominating_element;
            return not lhs_dominates and not rhs_dominates and (lhs->can_be_null() or rhs->can_be_null());
        }
        return lhs->can_be_null() or rhs->can_be_null();
    }
 
    bool contains_free_variables() const override
    { return lhs->contains_free_variables() or rhs->contains_free_variables(); }
    bool contains_bound_variables() const override
    { return lhs->contains_bound_variables() or rhs->contains_bound_variables(); }
    Token op() const { return tok; }
 
    uint64_t hash() const override;
 
    bool operator==(const Expr &other) const override;
 
    void accept(ASTExprVisitor &v) override;
    void accept(ConstASTExprVisitor &v) const override;
};
 
struct M_EXPORT QueryExpr : Expr
{
    std::unique_ptr<Stmt> query;
 
    private:
    ThreadSafePooledString alias_; 
 
    public:
    QueryExpr(Token op, std::unique_ptr<Stmt> query)
        : Expr(std::move(op))
        , query(M_notnull(std::move(query)))
        , alias_(make_unique_alias())
    { }
 
    bool is_constant() const override;
    bool can_be_null() const override;
 
    bool contains_free_variables() const override { return false; }
    bool contains_bound_variables() const override { return true; }
 
    uint64_t hash() const override;
 
    bool operator==(const Expr &other) const override;
 
    void accept(ASTExprVisitor &v) override;
    void accept(ConstASTExprVisitor &v) const override;
 
    const ThreadSafePooledString & alias() const { return alias_; }
 
    private:
    static ThreadSafePooledString make_unique_alias();
};
 
#define M_AST_EXPR_LIST(X) \
    X(m::ast::ErrorExpr) \
    X(m::ast::Designator) \
    X(m::ast::Constant) \
    X(m::ast::FnApplicationExpr) \
    X(m::ast::UnaryExpr) \
    X(m::ast::BinaryExpr) \
    X(m::ast::QueryExpr)
 
M_DECLARE_VISITOR(ASTExprVisitor, Expr, M_AST_EXPR_LIST)
M_DECLARE_VISITOR(ConstASTExprVisitor, const Expr, M_AST_EXPR_LIST)
 
template<bool C>
struct TheRecursiveExprVisitorBase : std::conditional_t<C, ConstASTExprVisitor, ASTExprVisitor>
{
    using super = std::conditional_t<C, ConstASTExprVisitor, ASTExprVisitor>;
    template<typename T> using Const = typename super::template Const<T>;
 
    virtual ~TheRecursiveExprVisitorBase() { }
 
    using super::operator();
    void operator()(Const<FnApplicationExpr> &e) override {
        (*this)(*e.fn);
        for (auto &arg : e.args)
            (*this)(*arg);
    }
    void operator()(Const<UnaryExpr> &e) override { (*this)(*e.expr); }
    void operator()(Const<BinaryExpr> &e) override { (*this)(*e.lhs); (*this)(*e.rhs); }
};
 
using RecursiveExprVisitorBase = TheRecursiveExprVisitorBase<false>;
using RecursiveConstExprVisitorBase = TheRecursiveExprVisitorBase<true>;
 
template<bool C>
struct M_EXPORT ThePreOrderExprVisitor : std::conditional_t<C, ConstASTExprVisitor, ASTExprVisitor>
{
    using super = std::conditional_t<C, ConstASTExprVisitor, ASTExprVisitor>;
    template<typename T> using Const = typename super::template Const<T>;
 
    virtual ~ThePreOrderExprVisitor() { }
 
    void operator()(Const<Expr> &e);
};
 
template<bool C>
struct M_EXPORT ThePostOrderExprVisitor : std::conditional_t<C, ConstASTExprVisitor, ASTExprVisitor>
{
    using super = std::conditional_t<C, ConstASTExprVisitor, ASTExprVisitor>;
    template<typename T> using Const = typename super::template Const<T>;
 
    virtual ~ThePostOrderExprVisitor() { }
 
    void operator()(Const<Expr> &e);
};
 
using PreOrderExprVisitor = ThePreOrderExprVisitor<false>;
using ConstPreOrderExprVisitor = ThePreOrderExprVisitor<true>;
using PostOrderExprVisitor = ThePostOrderExprVisitor<false>;
using ConstPostOrderExprVisitor = ThePostOrderExprVisitor<true>;
 
M_MAKE_STL_VISITABLE(PreOrderExprVisitor, Expr, M_AST_EXPR_LIST)
M_MAKE_STL_VISITABLE(ConstPreOrderExprVisitor, const Expr, M_AST_EXPR_LIST)
M_MAKE_STL_VISITABLE(PostOrderExprVisitor, Expr, M_AST_EXPR_LIST)
M_MAKE_STL_VISITABLE(ConstPostOrderExprVisitor, const Expr, M_AST_EXPR_LIST)
 
 
/*======================================================================================================================
 * Clauses
 *====================================================================================================================*/
 
struct M_EXPORT Clause
{
    Token tok;
 
    Clause(Token tok) : tok(std::move(tok)) { }
    virtual ~Clause() { }
 
    virtual void accept(ASTClauseVisitor &v) = 0;
    virtual void accept(ConstASTClauseVisitor &v) const = 0;
 
    void dot(std::ostream &out) const;
 
    void dump(std::ostream &out) const;
    void dump() const;
 
    friend std::ostream & M_EXPORT operator<<(std::ostream &out, const Clause &c);
};
 
struct M_EXPORT ErrorClause : Clause
{
    ErrorClause(Token tok) : Clause(std::move(tok)) { }
 
    void accept(ASTClauseVisitor &v) override;
    void accept(ConstASTClauseVisitor &v) const override;
};
 
struct M_EXPORT SelectClause : Clause
{
    using select_type = std::pair<std::unique_ptr<Expr>, Token>; 
 
    std::vector<select_type> select;
    Token select_all;
    std::vector<std::unique_ptr<Expr>> expanded_select_all; 
 
    SelectClause(Token tok, std::vector<select_type> select, Token select_all)
            : Clause(std::move(tok))
            , select(std::move(select))
            , select_all(std::move(select_all))
    { }
 
    void accept(ASTClauseVisitor &v) override;
    void accept(ConstASTClauseVisitor &v) const override;
};
 
struct M_EXPORT FromClause : Clause
{
    struct from_type
    {
        friend struct Sema;
 
        public:
        std::variant<Token, Stmt*> source;
        Token alias;
 
        private:
        const Table *table_ = nullptr; 
 
        public:
        from_type(Token name, Token alias) : source(std::move(name)), alias(std::move(alias)) { }
        from_type(std::unique_ptr<Stmt> S, Token alias) : source(S.release()), alias(std::move(alias)) { }
 
        const Table & table() const { return *M_notnull(table_); }
        bool has_table() const { return table_ != nullptr; }
    };
 
    std::vector<from_type> from;
 
    FromClause(Token tok, std::vector<from_type> from) : Clause(std::move(tok)), from(std::move(from)) { }
    ~FromClause();
 
    void accept(ASTClauseVisitor &v) override;
    void accept(ConstASTClauseVisitor &v) const override;
};
 
struct M_EXPORT WhereClause : Clause
{
    std::unique_ptr<Expr> where;
 
    WhereClause(Token tok, std::unique_ptr<Expr> where)
        : Clause(std::move(tok))
        , where(M_notnull(std::move(where)))
    { }
 
    void accept(ASTClauseVisitor &v) override;
    void accept(ConstASTClauseVisitor &v) const override;
};
 
struct M_EXPORT GroupByClause : Clause
{
    using group_type = std::pair<std::unique_ptr<Expr>, Token>;
    std::vector<group_type> group_by; 
 
    GroupByClause(Token tok, std::vector<group_type> group_by)
        : Clause(std::move(tok))
        , group_by(std::move(group_by))
    { }
 
    void accept(ASTClauseVisitor &v) override;
    void accept(ConstASTClauseVisitor &v) const override;
};
 
struct M_EXPORT HavingClause : Clause
{
    std::unique_ptr<Expr> having;
 
    HavingClause(Token tok, std::unique_ptr<Expr> having)
        : Clause(std::move(tok))
        , having(M_notnull(std::move(having)))
    { }
 
    void accept(ASTClauseVisitor &v) override;
    void accept(ConstASTClauseVisitor &v) const override;
};
 
struct M_EXPORT OrderByClause : Clause
{
    using order_type = std::pair<std::unique_ptr<Expr>, bool>; 
 
    std::vector<order_type> order_by;
 
    OrderByClause(Token tok, std::vector<order_type> order_by)
        : Clause(std::move(tok))
        , order_by(std::move(order_by))
    { }
 
    void accept(ASTClauseVisitor &v) override;
    void accept(ConstASTClauseVisitor &v) const override;
};
 
struct M_EXPORT LimitClause : Clause
{
    Token limit;
    Token offset;
 
    LimitClause(Token tok, Token limit, Token offset)
        : Clause(std::move(tok))
        , limit(std::move(limit))
        , offset(std::move(offset))
    { }
 
    void accept(ASTClauseVisitor &v) override;
    void accept(ConstASTClauseVisitor &v) const override;
};
 
#define M_AST_CLAUSE_LIST(X) \
    X(m::ast::ErrorClause) \
    X(m::ast::SelectClause) \
    X(m::ast::FromClause) \
    X(m::ast::WhereClause) \
    X(m::ast::GroupByClause) \
    X(m::ast::HavingClause) \
    X(m::ast::OrderByClause) \
    X(m::ast::LimitClause)
 
M_DECLARE_VISITOR(ASTClauseVisitor, Clause, M_AST_CLAUSE_LIST)
M_DECLARE_VISITOR(ConstASTClauseVisitor, const Clause, M_AST_CLAUSE_LIST)
 
 
/*======================================================================================================================
 * Constraints
 *====================================================================================================================*/
 
struct M_EXPORT Constraint
{
    Token tok;
 
    Constraint(Token tok) : tok(std::move(tok)) { }
 
    virtual ~Constraint() { }
 
    virtual void accept(ASTConstraintVisitor &v) = 0;
    virtual void accept(ConstASTConstraintVisitor &v) const = 0;
};
 
struct M_EXPORT PrimaryKeyConstraint : Constraint
{
    PrimaryKeyConstraint(Token tok) : Constraint(std::move(tok)) { }
 
    void accept(ASTConstraintVisitor &v) override;
    void accept(ConstASTConstraintVisitor &v) const override;
};
 
struct M_EXPORT UniqueConstraint : Constraint
{
    UniqueConstraint(Token tok) : Constraint(std::move(tok)) { }
 
    void accept(ASTConstraintVisitor &v) override;
    void accept(ConstASTConstraintVisitor &v) const override;
};
 
struct M_EXPORT NotNullConstraint : Constraint
{
    NotNullConstraint(Token tok) : Constraint(std::move(tok)) { }
 
    void accept(ASTConstraintVisitor &v) override;
    void accept(ConstASTConstraintVisitor &v) const override;
};
 
struct M_EXPORT CheckConditionConstraint : Constraint
{
    std::unique_ptr<Expr> cond;
 
    CheckConditionConstraint(Token tok, std::unique_ptr<Expr> cond)
        : Constraint(std::move(tok))
        , cond(std::move(cond))
    {
        M_insist(bool(this->cond));
    }
 
    void accept(ASTConstraintVisitor &v) override;
    void accept(ConstASTConstraintVisitor &v) const override;
};
 
struct M_EXPORT ReferenceConstraint : Constraint
{
    enum OnDeleteAction
    {
        ON_DELETE_RESTRICT,
        ON_DELETE_CASCADE,
    };
 
    Token table_name;
    Token attr_name;
    OnDeleteAction on_delete;
 
    ReferenceConstraint(Token tok, Token table_name, Token attr_name, OnDeleteAction action)
            : Constraint(std::move(tok))
            , table_name(std::move(table_name))
            , attr_name(std::move(attr_name))
            , on_delete(action)
    { }
 
    void accept(ASTConstraintVisitor &v) override;
    void accept(ConstASTConstraintVisitor &v) const override;
};
 
#define M_AST_CONSTRAINT_LIST(X) \
    X(m::ast::PrimaryKeyConstraint) \
    X(m::ast::UniqueConstraint) \
    X(m::ast::NotNullConstraint) \
    X(m::ast::CheckConditionConstraint) \
    X(m::ast::ReferenceConstraint)
 
M_DECLARE_VISITOR(ASTConstraintVisitor, Constraint, M_AST_CONSTRAINT_LIST)
M_DECLARE_VISITOR(ConstASTConstraintVisitor, const Constraint, M_AST_CONSTRAINT_LIST)
 
 
/*======================================================================================================================
 * Command
 *====================================================================================================================*/
 
struct M_EXPORT Command
{
    virtual ~Command() = default;
 
    virtual void accept(ASTCommandVisitor &v) = 0;
    virtual void accept(ConstASTCommandVisitor &v) const = 0;
 
    void dump(std::ostream &out) const;
    void dump() const;
 
    friend std::ostream & M_EXPORT operator<<(std::ostream &out, const Command &cmd);
};
 
 
/*======================================================================================================================
 * Instruction
 *====================================================================================================================*/
 
struct M_EXPORT Instruction : Command
{
    Token tok;
    ThreadSafePooledString name;
    std::vector<std::string> args;
 
    Instruction(Token tok, ThreadSafePooledString name, std::vector<std::string> args)
        : tok(std::move(tok))
        , name(std::move(name))
        , args(std::move(args))
    { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
 
/*======================================================================================================================
 * Statements
 *====================================================================================================================*/
 
struct M_EXPORT Stmt : Command
{
    virtual ~Stmt() { }
 
    void dot(std::ostream &out) const;
};
 
struct M_EXPORT ErrorStmt : Stmt
{
    Token tok;
 
    explicit ErrorStmt(Token tok) : tok(std::move(tok)) { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
struct M_EXPORT EmptyStmt : Stmt
{
    Token tok;
 
    explicit EmptyStmt(Token tok) : tok(std::move(tok)) { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
struct M_EXPORT CreateDatabaseStmt : Stmt
{
    Token database_name;
 
    explicit CreateDatabaseStmt(Token database_name) : database_name(std::move(database_name)) { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
struct M_EXPORT DropDatabaseStmt : Stmt
{
    Token database_name;
    bool has_if_exists;
 
    explicit DropDatabaseStmt(Token database_name, bool has_if_exists)
        : database_name(std::move(database_name))
        , has_if_exists(has_if_exists)
    { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
struct M_EXPORT UseDatabaseStmt : Stmt
{
    Token database_name;
 
    explicit UseDatabaseStmt(Token database_name) : database_name(std::move(database_name)) { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
struct M_EXPORT CreateTableStmt : Stmt
{
    struct attribute_definition
    {
        Token name;
        const Type *type;
        std::vector<std::unique_ptr<Constraint>> constraints;
 
        attribute_definition(Token name, const Type *type, std::vector<std::unique_ptr<Constraint>> constraints)
                : name(std::move(name))
                , type(type)
                , constraints(std::move(constraints))
        { }
    };
 
    Token table_name;
    std::vector<std::unique_ptr<attribute_definition>> attributes;
 
    CreateTableStmt(Token table_name, std::vector<std::unique_ptr<attribute_definition>> attributes)
            : table_name(std::move(table_name))
            , attributes(std::move(attributes))
    { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
struct M_EXPORT DropTableStmt : Stmt
{
    std::vector<std::unique_ptr<Token>> table_names;
    bool has_if_exists;
 
    DropTableStmt(std::vector<std::unique_ptr<Token>> table_names, bool has_if_exists)
        : table_names(std::move(table_names))
        , has_if_exists(has_if_exists)
    { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
struct M_EXPORT CreateIndexStmt : Stmt
{
    Token has_unique;
    bool has_if_not_exists;
    Token index_name;
    Token table_name;
    Token method;
    std::vector<std::unique_ptr<Expr>> key_fields;
 
    CreateIndexStmt(Token has_unique, bool has_if_not_exists, Token index_name, Token table_name, Token method,
                    std::vector<std::unique_ptr<Expr>> key_fields)
        : has_unique(std::move(has_unique))
        , has_if_not_exists(has_if_not_exists)
        , index_name(std::move(index_name))
        , table_name(std::move(table_name))
        , method(std::move(method))
        , key_fields(std::move(key_fields))
    { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
struct M_EXPORT DropIndexStmt : Stmt
{
    std::vector<std::unique_ptr<Token>> index_names;
    bool has_if_exists;
 
    DropIndexStmt(std::vector<std::unique_ptr<Token>> index_names, bool has_if_exists)
        : index_names(std::move(index_names))
        , has_if_exists(has_if_exists)
    { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
struct M_EXPORT SelectStmt : Stmt
{
    std::unique_ptr<Clause> select;
    std::unique_ptr<Clause> from;
    std::unique_ptr<Clause> where;
    std::unique_ptr<Clause> group_by;
    std::unique_ptr<Clause> having;
    std::unique_ptr<Clause> order_by;
    std::unique_ptr<Clause> limit;
 
    SelectStmt(std::unique_ptr<Clause> select,
               std::unique_ptr<Clause> from,
               std::unique_ptr<Clause> where,
               std::unique_ptr<Clause> group_by,
               std::unique_ptr<Clause> having,
               std::unique_ptr<Clause> order_by,
               std::unique_ptr<Clause> limit)
            : select(M_notnull(std::move(select)))
            , from(std::move(from))
            , where(std::move(where))
            , group_by(std::move(group_by))
            , having(std::move(having))
            , order_by(std::move(order_by))
            , limit(std::move(limit))
    { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
struct M_EXPORT InsertStmt : Stmt
{
    enum kind_t { I_Default, I_Null, I_Expr };
    using element_type = std::pair<kind_t, std::unique_ptr<Expr>>;
    using tuple_t = std::vector<element_type>;
 
    Token table_name;
    std::vector<tuple_t> tuples;
 
    InsertStmt(Token table_name, std::vector<tuple_t> tuples)
        : table_name(std::move(table_name))
        , tuples(std::move(tuples))
    { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
struct M_EXPORT UpdateStmt : Stmt
{
    using set_type = std::pair<Token, std::unique_ptr<Expr>>;
 
    Token table_name;
    std::vector<set_type> set;
    std::unique_ptr<Clause> where;
 
    UpdateStmt(Token table_name, std::vector<set_type> set, std::unique_ptr<Clause> where)
        : table_name(std::move(table_name))
        , set(std::move(set))
        , where(std::move(where))
    { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
struct M_EXPORT DeleteStmt : Stmt
{
    Token table_name;
    std::unique_ptr<Clause> where = nullptr;
 
    DeleteStmt(Token table_name, std::unique_ptr<Clause> where)
        : table_name(std::move(table_name))
        , where(std::move(where))
    { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
struct M_EXPORT ImportStmt : Stmt
{
    Token table_name;
    ImportStmt(Token table_name) : table_name(std::move(table_name)) { }
};
 
struct M_EXPORT DSVImportStmt : ImportStmt
{
    Token path = Token::CreateArtificial();
    Token delimiter = Token::CreateArtificial();
    Token escape = Token::CreateArtificial();
    Token quote = Token::CreateArtificial();
    Token rows = Token::CreateArtificial();
    bool has_header = false;
    bool skip_header = false;
 
    DSVImportStmt(Token table_name) : ImportStmt(std::move(table_name)) { }
 
    void accept(ASTCommandVisitor &v) override;
    void accept(ConstASTCommandVisitor &v) const override;
};
 
#define M_AST_COMMAND_LIST(X) \
    X(m::ast::Instruction) \
    X(m::ast::ErrorStmt) \
    X(m::ast::EmptyStmt) \
    X(m::ast::CreateDatabaseStmt) \
    X(m::ast::UseDatabaseStmt) \
    X(m::ast::DropDatabaseStmt) \
    X(m::ast::CreateTableStmt) \
    X(m::ast::DropTableStmt) \
    X(m::ast::CreateIndexStmt) \
    X(m::ast::DropIndexStmt) \
    X(m::ast::SelectStmt) \
    X(m::ast::InsertStmt) \
    X(m::ast::UpdateStmt) \
    X(m::ast::DeleteStmt) \
    X(m::ast::DSVImportStmt)
 
M_DECLARE_VISITOR(ASTCommandVisitor, Command, M_AST_COMMAND_LIST)
M_DECLARE_VISITOR(ConstASTCommandVisitor, const Command, M_AST_COMMAND_LIST)
 
 
#define M_AST_LIST(X) \
    M_AST_EXPR_LIST(X) \
    M_AST_CLAUSE_LIST(X) \
    M_AST_CONSTRAINT_LIST(X) \
    M_AST_COMMAND_LIST(X)
 
struct M_EXPORT ASTVisitor : ASTExprVisitor, ASTClauseVisitor, ASTConstraintVisitor, ASTCommandVisitor
{
    template<typename T> using Const = ASTExprVisitor::Const<T>; // resolve ambiguous name lookup
 
    using ASTExprVisitor::operator();
    using ASTClauseVisitor::operator();
    using ASTConstraintVisitor::operator();
    using ASTCommandVisitor::operator();
};
 
struct M_EXPORT ConstASTVisitor : ConstASTExprVisitor, ConstASTClauseVisitor, ConstASTConstraintVisitor, ConstASTCommandVisitor
{
    template<typename T> using Const = ConstASTExprVisitor::Const<T>; // resolve ambiguous name lookup
 
    using ConstASTExprVisitor::operator();
    using ConstASTClauseVisitor::operator();
    using ConstASTConstraintVisitor::operator();
    using ConstASTCommandVisitor::operator();
};
 
M_MAKE_STL_VISITABLE(ASTVisitor, Expr, M_AST_EXPR_LIST)
M_MAKE_STL_VISITABLE(ASTVisitor, Clause, M_AST_CLAUSE_LIST)
M_MAKE_STL_VISITABLE(ASTVisitor, Constraint, M_AST_CONSTRAINT_LIST)
M_MAKE_STL_VISITABLE(ASTVisitor, Command, M_AST_COMMAND_LIST)
 
M_MAKE_STL_VISITABLE(ConstASTVisitor, const Expr, M_AST_LIST)
M_MAKE_STL_VISITABLE(ConstASTVisitor, const Clause, M_AST_LIST)
M_MAKE_STL_VISITABLE(ConstASTVisitor, const Constraint, M_AST_LIST)
M_MAKE_STL_VISITABLE(ConstASTVisitor, const Command, M_AST_LIST)
 
}
 
}
 
namespace std {
 
template<>
struct hash<m::ast::Expr>
{
    std::size_t operator()(const m::ast::Expr &e) const { return e.hash(); }
};
 
}