query/source/orm/query/internal/query_parts.cpp

#include "matador/query/internal/query_parts.hpp"

#include <utility>

namespace matador::query::internal {
query_alter_part::query_alter_part()
: query_part(sql::dialect_token::Alter) {}

void query_alter_part::accept( query_part_visitor& visitor ) {
  visitor.visit(*this);
}

query_alter_table_part::query_alter_table_part(class table tab)
: query_part(sql::dialect_token::Table)
, table_(std::move(tab)) {}

void query_alter_table_part::accept(query_part_visitor& visitor) {
  visitor.visit(*this);
}

const table& query_alter_table_part::table() const {
  return table_;
}

query_add_key_constraint_part::query_add_key_constraint_part(std::string name)
: query_part(sql::dialect_token::AddConstraint)
, name_(std::move(name)){}

void query_add_key_constraint_part::accept( query_part_visitor& visitor ) {
  visitor.visit(*this);
}

const std::string& query_add_key_constraint_part::name() const {
   return name_;
}

query_add_constraint_part_by_constraint::query_add_constraint_part_by_constraint(const query::table_constraint &co)
: query_part(sql::dialect_token::AddConstraint)
, constraint_(co) {}

void query_add_constraint_part_by_constraint::accept(query_part_visitor &visitor) {
  visitor.visit(*this);
}

const table_constraint & query_add_constraint_part_by_constraint::constraint() const {
  return constraint_;
}

query_drop_key_constraint_part_by_name::query_drop_key_constraint_part_by_name(std::string name)
: query_part( sql::dialect_token::DropConstraint )
, name_(std::move( name )){}

void query_drop_key_constraint_part_by_name::accept(query_part_visitor& visitor) {
  visitor.visit(*this);
}

const std::string& query_drop_key_constraint_part_by_name::name() const {
  return name_;
}

query_drop_key_constraint_part_by_constraint::query_drop_key_constraint_part_by_constraint(const table_constraint &co)
: query_part( sql::dialect_token::DropConstraint )
, constraint_(co) {}

void query_drop_key_constraint_part_by_constraint::accept(query_part_visitor& visitor) {
    visitor.visit(*this);
}

const table_constraint& query_drop_key_constraint_part_by_constraint::constraint() const {
  return constraint_;
}

query_add_foreign_key_constraint_part::query_add_foreign_key_constraint_part(const std::vector<table_column>& columns)
: query_part(sql::dialect_token::ForeignKey)
, columns_(columns) {}

void query_add_foreign_key_constraint_part::accept( query_part_visitor& visitor ) {
  visitor.visit(*this);
}

const std::vector<table_column>& query_add_foreign_key_constraint_part::columns() const {
  return columns_;
}

query_add_foreign_key_reference_part::query_add_foreign_key_reference_part(class table tab, const std::vector<table_column>& columns)
: query_part(sql::dialect_token::References)
, table_(std::move(tab))
, columns_(columns) {}

void query_add_foreign_key_reference_part::accept( query_part_visitor& visitor ) {
  visitor.visit(*this);
}

const table& query_add_foreign_key_reference_part::table() const {
  return table_;
}

const std::vector<table_column>& query_add_foreign_key_reference_part::columns() const {
  return columns_;
}

query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector<table_column>& columns)
: query_part(sql::dialect_token::PrimaryKey)
, columns_(columns) {}

void query_add_primary_key_constraint_part::accept( query_part_visitor& visitor ) {
  visitor.visit(*this);
}

const std::vector<table_column>& query_add_primary_key_constraint_part::columns() const {
  return columns_;
}

query_select_part::query_select_part(std::vector<table_column> columns)
  : query_part(sql::dialect_token::Select)
  , columns_(std::move(columns)) {}

void query_select_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

const std::vector<table_column>& query_select_part::columns() const
{
  return columns_;
}

query_from_part::query_from_part(class table tab)
  : query_part(sql::dialect_token::From)
  , table_(std::move(tab)) {}

const table &query_from_part::table() const
{
  return table_;
}

void query_from_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_join_part::query_join_part(class table tab)
  : query_part(sql::dialect_token::Join)
  , table_(std::move(tab)) {}

const table &query_join_part::table() const
{
  return table_;
}

void query_join_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_on_part::query_on_part(std::unique_ptr<abstract_criteria> &&cond)
: query_part(sql::dialect_token::On)
, condition_(std::move(cond)) {}

const abstract_criteria &query_on_part::condition() const
{
  return *condition_;
}

void query_on_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_where_part::query_where_part(std::unique_ptr<abstract_criteria> &&cond)
: query_part(sql::dialect_token::Where)
, condition_(std::move(cond)) {}

void query_where_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

const abstract_criteria &query_where_part::condition() const
{
  return *condition_;
}

query_table_name_part::query_table_name_part(const sql::dialect_token token, std::string table_name)
: query_part(token)
, table_name_(std::move(table_name)) {}

query_group_by_part::query_group_by_part(class table_column col)
: query_part(sql::dialect_token::GroupBy)
, column_(std::move(col))
{}

const table_column &query_group_by_part::column() const
{
  return column_;
}

void query_group_by_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_order_by_part::query_order_by_part(class table_column col)
: query_part(sql::dialect_token::OrderBy)
, column_(std::move(col))
{}

const table_column &query_order_by_part::column() const
{
  return column_;
}

void query_order_by_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_order_by_asc_part::query_order_by_asc_part()
: query_part(sql::dialect_token::Asc)
{}

void query_order_by_asc_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_order_by_desc_part::query_order_by_desc_part()
: query_part(sql::dialect_token::Desc)
{}

void query_order_by_desc_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_offset_part::query_offset_part(size_t offset)
: query_part(sql::dialect_token::Offset)
, offset_(offset) {}

size_t query_offset_part::offset() const
{
  return offset_;
}

void query_offset_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_limit_part::query_limit_part(size_t limit)
: query_part(sql::dialect_token::Limit)
, limit_(limit) {}

size_t query_limit_part::limit() const
{
  return limit_;
}

void query_limit_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_insert_part::query_insert_part()
: query_part(sql::dialect_token::Insert) {}

void query_insert_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_into_part::query_into_part(class table tab, std::vector<table_column> columns)
: query_part(sql::dialect_token::Insert)
, table_(std::move(tab))
, columns_(std::move(columns)) {}

const table &query_into_part::table() const
{
  return table_;
}

const std::vector<table_column> &query_into_part::columns() const
{
  return columns_;
}

void query_into_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_values_part::query_values_part(std::vector<std::variant<utils::placeholder, utils::database_type>> &&values)
: query_part(sql::dialect_token::Values)
, values_(std::move(values)) {}

const std::vector<std::variant<utils::placeholder, utils::database_type>>& query_values_part::values() const
{
  return values_;
}

void query_values_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_update_part::query_update_part(class table tab)
: query_part(sql::dialect_token::Update)
, table_(std::move(tab)) {}

const table& query_update_part::table() const
{
  return table_;
}

void query_update_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_set_part::query_set_part(const std::vector<column_value_pair>& key_value_pairs)
: query_part(sql::dialect_token::Set)
, key_value_pairs_(key_value_pairs) {}

const std::vector<column_value_pair> &query_set_part::column_values() const
{
  return key_value_pairs_;
}

void query_set_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_delete_part::query_delete_part()
: query_part(sql::dialect_token::Remove) {}

void query_delete_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_delete_from_part::query_delete_from_part(class table tab)
: query_part(sql::dialect_token::From)
, table_(std::move(tab)) {}

const table &query_delete_from_part::table() const
{
  return table_;
}

void query_delete_from_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_create_part::query_create_part()
: query_part(sql::dialect_token::Create) {}

void query_create_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_create_table_part::query_create_table_part(class table tab)
: query_part(sql::dialect_token::Table)
, table_(std::move(tab)) {}

const table &query_create_table_part::table() const
{
  return table_;
}

void query_create_table_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_create_table_columns_part::query_create_table_columns_part(const std::list<table_column>& columns)
: query_part( sql::dialect_token::Columns )
, columns_(columns){}

const std::list<table_column>& query_create_table_columns_part::columns() const {
  return columns_;
}

void query_create_table_columns_part::accept(query_part_visitor& visitor) {
  visitor.visit(*this);
}

query_create_table_constraints_part::query_create_table_constraints_part(const std::list<class table_constraint>& constraints)
: query_part( sql::dialect_token::Constraint )
, constraints_(constraints) {}

const std::list<class table_constraint>& query_create_table_constraints_part::constraints() const {
  return constraints_;
}

void query_create_table_constraints_part::accept( query_part_visitor& visitor ) {
  visitor.visit(*this);
}

query_create_schema_part::query_create_schema_part(std::string schema)
: query_part( sql::dialect_token::Schema )
, schema_( std::move( schema ) ){}

const std::string& query_create_schema_part::schema() const {
    return schema_;
}

void query_create_schema_part::accept( query_part_visitor& visitor ) {
    visitor.visit(*this);
}

query_drop_part::query_drop_part()
: query_part(sql::dialect_token::Drop) {}

void query_drop_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_drop_table_part::query_drop_table_part(class table tab)
: query_part(sql::dialect_token::Table)
, table_(std::move(tab)) {}

const table &query_drop_table_part::table() const
{
  return table_;
}

void query_drop_table_part::accept(query_part_visitor &visitor)
{
  visitor.visit(*this);
}

query_drop_schema_part::query_drop_schema_part(std::string schema_)
: query_part( sql::dialect_token::Schema )
, schema_( std::move( schema_ ) ) {}

const std::string& query_drop_schema_part::schema() const {
  return schema_;
}

void query_drop_schema_part::accept( query_part_visitor& visitor ) {
  visitor.visit(*this);
}
}