sql_query_builder/

structure.rs

use crate::behavior::TransactionQuery;

#[cfg(any(feature = "postgresql", feature = "sqlite"))]
use crate::behavior::WithQuery;

#[cfg(any(feature = "postgresql", feature = "sqlite"))]
use std::sync::Arc;

/// Builder to contruct a [AlterTable] command
///
/// Basic API
/// ```
/// use sql_query_builder as sql;
///
/// let query = sql::AlterTable::new()
///   .alter_table("users")
///   .add("COLUMN id serial primary key")
///   .add("COLUMN login varchar(40) not null")
///   .drop("CONSTRAINT users_login_key")
///   .as_string();
///
/// # let expected = "\
/// #   ALTER TABLE users \
/// #     ADD COLUMN id serial primary key, \
/// #     ADD COLUMN login varchar(40) not null, \
/// #     DROP CONSTRAINT users_login_key\
/// # ";
/// # assert_eq!(expected, query);
/// ```
///
/// Output (indented for readability)
///
/// ```sql
/// ALTER TABLE users
///   ADD COLUMN id serial primary key,
///   ADD COLUMN login varchar(40) not null,
///   DROP CONSTRAINT users_login_key
/// ```
#[derive(Default, Clone)]
pub struct AlterTable {
  pub(crate) _alter_table: String,
  pub(crate) _ordered_actions: Vec<AlterTableActionItem>,
  pub(crate) _raw_after: Vec<(AlterTableAction, String)>,
  pub(crate) _raw_before: Vec<(AlterTableAction, String)>,
  pub(crate) _raw: Vec<String>,
  pub(crate) _rename_to: String,
}

#[derive(PartialEq, Clone)]
pub(crate) struct AlterTableActionItem(pub(crate) AlterTableOrderedAction, pub(crate) String);

/// Actions used to build the sequencial part of [AlterTable]
#[derive(PartialEq, Clone)]
pub(crate) enum AlterTableOrderedAction {
  Add,
  Drop,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  Rename,

  #[cfg(any(feature = "postgresql"))]
  Alter,
}

/// All available params to be used in [AlterTable::raw_before] and [AlterTable::raw_after] methods on [AlterTable] builder
#[derive(PartialEq, Clone)]
pub enum AlterTableAction {
  AlterTable,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  RenameTo,
}

#[cfg(any(feature = "postgresql", feature = "sqlite"))]
pub(crate) enum Combinator {
  Except,
  Intersect,
  Union,
}

/// Builder to contruct a [CreateIndex] command. Available only for the crate features `postgresql` and `sqlite`
///
/// Basic API
/// ```
/// # #[cfg(any(feature = "postgresql", feature = "sqlite"))]
/// # {
/// use sql_query_builder as sql;
///
/// let query = sql::CreateIndex::new()
///   .create_index("users_name_idx")
///   .on("users")
///   .column("name")
///   .as_string();
///
/// # let expected = "CREATE INDEX users_name_idx ON users (name)";
/// # assert_eq!(expected, query);
/// # }
/// ```
///
/// Output
///
/// ```sql
/// CREATE INDEX users_name_idx ON users (name)
/// ```
#[cfg(any(feature = "postgresql", feature = "sqlite"))]
#[derive(Default, Clone)]
pub struct CreateIndex {
  pub(crate) _column: Vec<String>,
  pub(crate) _index_name: String,
  pub(crate) _create_index: bool,
  pub(crate) _if_not_exists: bool,
  pub(crate) _on: String,
  pub(crate) _raw_after: Vec<(CreateIndexParams, String)>,
  pub(crate) _raw_before: Vec<(CreateIndexParams, String)>,
  pub(crate) _raw: Vec<String>,
  pub(crate) _unique: bool,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _where: Vec<(LogicalOperator, String)>,

  #[cfg(feature = "postgresql")]
  pub(crate) _concurrently: bool,
  #[cfg(feature = "postgresql")]
  pub(crate) _include: Vec<String>,
  #[cfg(feature = "postgresql")]
  pub(crate) _only: bool,
  #[cfg(feature = "postgresql")]
  pub(crate) _using: String,
}

/// All available params to be used in [CreateIndex::raw_before] and [CreateIndex::raw_after] methods on [CreateIndex] builder
#[cfg(any(feature = "postgresql", feature = "sqlite"))]
#[derive(PartialEq, Clone)]
pub enum CreateIndexParams {
  Column,
  CreateIndex,
  On,
  Unique,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  Where,

  #[cfg(feature = "postgresql")]
  Concurrently,
  #[cfg(feature = "postgresql")]
  Only,
  #[cfg(feature = "postgresql")]
  Using,
  #[cfg(feature = "postgresql")]
  Include,
}

/// Builder to contruct a [CreateTable] command
///
/// Basic API
/// ```
/// use sql_query_builder as sql;
///
/// let query = sql::CreateTable::new()
///   .create_table("users")
///   .column("id serial primary key")
///   .column("login varchar(40) not null")
///   .constraint("users_login_key unique(login)")
///   .as_string();
///
/// # let expected = "\
/// #   CREATE TABLE users (\
/// #     id serial primary key, \
/// #     login varchar(40) not null, \
/// #     CONSTRAINT users_login_key unique(login)\
/// #   )\
/// # ";
/// # assert_eq!(expected, query);
/// ```
///
///
/// Output (indented for readability)
///
/// ```sql
/// CREATE TABLE users (
///   id serial primary key,
///   login varchar(40) not null,
///   created_at timestamp not null,
///   CONSTRAINT users_login_key unique(login)
/// )
/// ```
#[derive(Default, Clone)]
pub struct CreateTable {
  pub(crate) _column: Vec<String>,
  pub(crate) _constraint: Vec<String>,
  pub(crate) _create_table: String,
  pub(crate) _foreign_key: Vec<String>,
  pub(crate) _primary_key: String,
  pub(crate) _raw_after: Vec<(CreateTableParams, String)>,
  pub(crate) _raw_before: Vec<(CreateTableParams, String)>,
  pub(crate) _raw: Vec<String>,
}

/// All available params to be used in [CreateTable::raw_before] and [CreateTable::raw_after] methods on [CreateTable] builder
#[derive(PartialEq, Clone)]
pub enum CreateTableParams {
  Column,
  Constraint,
  CreateTable,
  ForeignKey,
  PrimaryKey,
}

/// Builder to contruct a [DropIndex] command. Available only for the crate features `postgresql` and `sqlite`
///
/// Basic API
/// ```
/// # #[cfg(any(feature = "postgresql", feature = "sqlite"))]
/// # {
/// use sql_query_builder as sql;
///
/// let query = sql::DropIndex::new()
///   .drop_index("users_name_idx")
///   .as_string();
///
/// # let expected = "DROP INDEX users_name_idx";
/// # assert_eq!(expected, query);
/// # }
/// ```
///
///
/// Output
///
/// ```sql
/// DROP INDEX users_name_idx
/// ```
#[cfg(any(feature = "postgresql", feature = "sqlite"))]
#[derive(Default, Clone)]
pub struct DropIndex {
  pub(crate) _drop_index: Vec<String>,
  pub(crate) _if_exists: bool,
  pub(crate) _raw_after: Vec<(DropIndexParams, String)>,
  pub(crate) _raw_before: Vec<(DropIndexParams, String)>,
  pub(crate) _raw: Vec<String>,
}

/// All available params to be used in [DropIndex::raw_before] and [DropIndex::raw_after] methods on [DropIndex] builder
#[cfg(any(feature = "postgresql", feature = "sqlite"))]
#[derive(PartialEq, Clone)]
pub enum DropIndexParams {
  DropIndex,
}

/// Builder to contruct a [DropTable] command
///
/// Basic API
/// ```
/// use sql_query_builder as sql;
///
/// let query = sql::DropTable::new()
///   .drop_table("users")
///   .as_string();
///
/// # let expected = "DROP TABLE users";
/// # assert_eq!(expected, query);
/// ```
///
///
/// Output
///
/// ```sql
/// DROP TABLE users
/// ```
#[derive(Default, Clone)]
pub struct DropTable {
  pub(crate) _drop_table: Vec<String>,
  pub(crate) _if_exists: bool,
  pub(crate) _raw_after: Vec<(DropTableParams, String)>,
  pub(crate) _raw_before: Vec<(DropTableParams, String)>,
  pub(crate) _raw: Vec<String>,
}

/// All available params to be used in [DropTable::raw_before] and [DropTable::raw_after] methods on [DropTable] builder
#[derive(PartialEq, Clone)]
pub enum DropTableParams {
  DropTable,
}

/// Builder to contruct a [Delete] command
#[derive(Default, Clone)]
pub struct Delete {
  pub(crate) _delete_from: String,
  pub(crate) _raw_after: Vec<(DeleteClause, String)>,
  pub(crate) _raw_before: Vec<(DeleteClause, String)>,
  pub(crate) _raw: Vec<String>,
  pub(crate) _where: Vec<(LogicalOperator, String)>,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _returning: Vec<String>,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _with: Vec<(String, std::sync::Arc<dyn crate::behavior::WithQuery>)>,
}

/// All available clauses to be used in [Delete::raw_before] and [Delete::raw_after] methods on [Delete] builder
#[derive(PartialEq, Clone)]
pub enum DeleteClause {
  DeleteFrom,
  Where,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  Returning,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  With,
}

/// Builder to contruct a [Insert] command
#[derive(Default, Clone)]
pub struct Insert {
  pub(crate) _default_values: bool,
  pub(crate) _on_conflict: String,
  pub(crate) _overriding: String,
  pub(crate) _raw_after: Vec<(InsertClause, String)>,
  pub(crate) _raw_before: Vec<(InsertClause, String)>,
  pub(crate) _raw: Vec<String>,
  pub(crate) _select: Option<Select>,
  pub(crate) _values: Vec<String>,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _returning: Vec<String>,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _with: Vec<(String, std::sync::Arc<dyn crate::behavior::WithQuery>)>,

  #[cfg(not(feature = "sqlite"))]
  pub(crate) _insert_into: String,

  #[cfg(feature = "sqlite")]
  pub(crate) _insert: (InsertVars, String),
}

#[cfg(feature = "sqlite")]
#[derive(Default, Clone, PartialEq)]
pub(crate) enum InsertVars {
  #[default]
  InsertInto,
  InsertOr,
  ReplaceInto,
}

/// All available clauses to be used in [Insert::raw_before] and [Insert::raw_after] methods on [Insert] builder
#[derive(PartialEq, Clone)]
pub enum InsertClause {
  DefaultValues,
  InsertInto,
  OnConflict,
  Overriding,
  Select,
  Values,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  Returning,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  With,

  #[cfg(feature = "sqlite")]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  InsertOr,

  #[cfg(feature = "sqlite")]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  ReplaceInto,
}

#[derive(Clone, PartialEq)]
pub(crate) enum LogicalOperator {
  And,
  Or,
}

/// Builder to contruct a [Select] command
#[derive(Default, Clone)]
pub struct Select {
  pub(crate) _from: Vec<String>,
  pub(crate) _group_by: Vec<String>,
  pub(crate) _having: Vec<String>,
  pub(crate) _join: Vec<String>,
  pub(crate) _order_by: Vec<String>,
  pub(crate) _raw_after: Vec<(SelectClause, String)>,
  pub(crate) _raw_before: Vec<(SelectClause, String)>,
  pub(crate) _raw: Vec<String>,
  pub(crate) _select: Vec<String>,
  pub(crate) _where: Vec<(LogicalOperator, String)>,
  pub(crate) _window: Vec<String>,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _except: Vec<Self>,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _intersect: Vec<Self>,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _limit: String,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _offset: String,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _union: Vec<Self>,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _with: Vec<(String, Arc<dyn WithQuery>)>,
}

/// All available clauses to be used in [Select::raw_before] and [Select::raw_after] methods on [Select] builder
#[derive(Clone, PartialEq)]
pub enum SelectClause {
  From,
  GroupBy,
  Having,
  Join,
  Limit,
  Offset,
  OrderBy,
  Select,
  Where,
  Window,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  Except,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  Intersect,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  Union,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  With,
}

/// Builder to contruct a [Transaction] block
#[derive(Default)]
pub struct Transaction {
  pub(crate) _commit: Option<TransactionCommand>,
  pub(crate) _ordered_commands: Vec<Box<dyn TransactionQuery>>,
  pub(crate) _raw: Vec<String>,
  pub(crate) _set_transaction: Option<TransactionCommand>,
  pub(crate) _start_transaction: Option<TransactionCommand>,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _begin: Option<TransactionCommand>,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _end: Option<TransactionCommand>,
}

/// Commands used in to build a [Transaction]
#[derive(PartialEq)]
pub(crate) enum TrCmd {
  Commit,
  ReleaseSavepoint,
  Rollback,
  Savepoint,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  Begin,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  End,

  #[cfg(not(feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  SetTransaction,

  #[cfg(not(feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  StartTransaction,
}

#[derive(PartialEq)]
pub(crate) struct TransactionCommand(pub(crate) TrCmd, pub(crate) String);

/// Builder to contruct a [Update] command
#[derive(Default, Clone)]
pub struct Update {
  pub(crate) _raw_after: Vec<(UpdateClause, String)>,
  pub(crate) _raw_before: Vec<(UpdateClause, String)>,
  pub(crate) _raw: Vec<String>,
  pub(crate) _set: Vec<String>,
  pub(crate) _where: Vec<(LogicalOperator, String)>,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _from: Vec<String>,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _returning: Vec<String>,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  pub(crate) _with: Vec<(String, std::sync::Arc<dyn crate::behavior::WithQuery>)>,

  #[cfg(not(feature = "sqlite"))]
  pub(crate) _update: String,

  #[cfg(feature = "sqlite")]
  pub(crate) _update: (UpdateVars, String),

  #[cfg(feature = "sqlite")]
  pub(crate) _join: Vec<String>,
}

#[cfg(feature = "sqlite")]
#[derive(Default, Clone, PartialEq)]
pub(crate) enum UpdateVars {
  #[default]
  Update,
  UpdateOr,
}

/// All available clauses to be used in [Update::raw_before] and [Update::raw_after] methods on [Update] builder
#[derive(PartialEq, Clone)]
pub enum UpdateClause {
  Set,
  Update,
  Where,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  From,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  Returning,

  #[cfg(any(feature = "postgresql", feature = "sqlite"))]
  #[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  With,

  #[cfg(feature = "sqlite")]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  UpdateOr,

  #[cfg(feature = "sqlite")]
  #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
  Join,
}

/// Builder to contruct a [Values] command
#[derive(Default, Clone)]
pub struct Values {
  pub(crate) _raw_after: Vec<(ValuesClause, String)>,
  pub(crate) _raw_before: Vec<(ValuesClause, String)>,
  pub(crate) _raw: Vec<String>,
  pub(crate) _values: Vec<String>,
}

/// All available clauses to be used in [Values::raw_before] and [Values::raw_after] methods on [Values] builder
#[derive(PartialEq, Clone)]
pub enum ValuesClause {
  Values,
}