mutable.hpp

Go to the documentation of this file.

#pragma once
 
#include <mutable/mutable-config.hpp>
 
#include <filesystem>
#include <mutable/backend/Backend.hpp>
#include <mutable/catalog/CardinalityEstimator.hpp>
#include <mutable/catalog/Catalog.hpp>
#include <mutable/catalog/CostFunction.hpp>
#include <mutable/catalog/DatabaseCommand.hpp>
#include <mutable/catalog/Schema.hpp>
#include <mutable/catalog/Type.hpp>
#include <mutable/IR/CNF.hpp>
#include <mutable/IR/Operator.hpp>
#include <mutable/IR/Optimizer.hpp>
#include <mutable/IR/PlanEnumerator.hpp>
#include <mutable/IR/PlanTable.hpp>
#include <mutable/IR/QueryGraph.hpp>
#include <mutable/IR/Tuple.hpp>
#include <mutable/lex/Token.hpp>
#include <mutable/lex/TokenType.hpp>
#include <mutable/parse/AST.hpp>
#include <mutable/storage/DataLayout.hpp>
#include <mutable/storage/Store.hpp>
#include <mutable/util/ADT.hpp>
#include <mutable/util/ArgParser.hpp>
#include <mutable/util/Diagnostic.hpp>
#include <mutable/util/Diagnostic.hpp>
#include <mutable/util/DotTool.hpp>
#include <mutable/util/exception.hpp>
#include <mutable/util/fn.hpp>
#include <mutable/util/macro.hpp>
#include <mutable/util/memory.hpp>
#include <mutable/util/Pool.hpp>
#include <mutable/util/Position.hpp>
#include <mutable/util/Timer.hpp>
#include <mutable/version.hpp>
 
 
namespace m {
 
bool M_EXPORT init(void);
 
std::unique_ptr<ast::Stmt> M_EXPORT statement_from_string(Diagnostic &diag, const std::string &str);
 
std::unique_ptr<ast::Instruction> M_EXPORT instruction_from_string(Diagnostic &diag, const std::string &str);
 
std::unique_ptr<DatabaseCommand> M_EXPORT command_from_string(Diagnostic &diag, const std::string &str);
 
void M_EXPORT execute_statement(Diagnostic &diag, const ast::Stmt &stmt, bool is_stdin = false);
 
void M_EXPORT process_stream(std::istream &in, const char *filename, Diagnostic diag);
 
void M_EXPORT execute_instruction(Diagnostic &diag, const ast::Instruction &instruction);
 
std::unique_ptr<Consumer> M_EXPORT logical_plan_from_statement(Diagnostic &diag, const ast::SelectStmt &stmt,
                                                               std::unique_ptr<Consumer> consumer);
std::unique_ptr<MatchBase> M_EXPORT physical_plan_from_logical_plan(Diagnostic &diag, const Consumer &logical_plan);
std::unique_ptr<MatchBase> M_EXPORT physical_plan_from_logical_plan(Diagnostic &diag, const Consumer &logical_plan,
                                                                    const Backend &backend);
 
void M_EXPORT execute_physical_plan(Diagnostic &diag, const MatchBase &physical_plan);
void M_EXPORT execute_physical_plan(Diagnostic &diag, const MatchBase &physical_plan, const Backend &backend);
 
[[deprecated("Use command_from_string() instead.")]]
void M_EXPORT execute_query(Diagnostic &diag, const ast::SelectStmt &stmt, std::unique_ptr<Consumer> consumer);
[[deprecated("Use command_from_string() instead.")]]
void M_EXPORT execute_query(Diagnostic &diag, const ast::SelectStmt &stmt, std::unique_ptr<Consumer> consumer,
                            const Backend &backend);
 
void M_EXPORT load_from_CSV(Diagnostic &diag,
                            Table &table,
                            const std::filesystem::path &path,
                            std::size_t num_rows = std::numeric_limits<std::size_t>::max(),
                            bool has_header = false,
                            bool skip_header = false);
 
void M_EXPORT execute_file(Diagnostic &diag, const std::filesystem::path &path);
 
struct M_EXPORT StoreWriter
{
    private:
    Store &store_; 
    Schema S; 
    mutable std::unique_ptr<m::StackMachine> writer_; 
    mutable const storage::DataLayout *layout_ = nullptr; 
 
    public:
    StoreWriter(Store &store);
    ~StoreWriter();
 
    const Schema & schema() const { return S; }
 
    void append(const Tuple &tup) const;
};
 
}