From 73db4b55010ff6bcacf91e078f1bfdc7200b63c8 Mon Sep 17 00:00:00 2001 From: Belchior Oliveira Date: Sun, 16 Mar 2025 18:10:28 -0300 Subject: [PATCH] Add Mysql syntax to DropIndex builder --- src/drop_index/drop_index.rs | 113 ++++++------- src/lib.rs | 6 +- src/structure.rs | 8 +- tests/command_drop_index_spec.rs | 266 ++++++++++++++++++------------- 4 files changed, 216 insertions(+), 177 deletions(-) diff --git a/src/drop_index/drop_index.rs b/src/drop_index/drop_index.rs index 5eabd68..2e47dac 100644 --- a/src/drop_index/drop_index.rs +++ b/src/drop_index/drop_index.rs @@ -38,7 +38,7 @@ impl DropIndex { /// ### Example 1 /// ///``` - /// # #[cfg(not(feature = "postgresql"))] + /// # #[cfg(any(feature = "sqlite", feature = "mysql"))] /// # { /// # use sql_query_builder as sql; /// let query = sql::DropIndex::new() @@ -85,59 +85,6 @@ impl DropIndex { self } - /// Defines a drop index parameter with the `if exists` modifier, this method overrides the previous value - /// - /// ### Example 1 - /// - /// ``` - /// # #[cfg(not(feature = "postgresql"))] - /// # { - /// # use sql_query_builder as sql; - /// let query = sql::DropIndex::new() - /// .drop_index("users_name_idx") - /// .drop_index_if_exists("orders_product_name_idx") - /// .to_string(); - /// - /// # let expected = "DROP INDEX IF EXISTS orders_product_name_idx"; - /// # assert_eq!(expected, query); - /// # } - /// ``` - /// - /// Outputs - /// - /// ```sql - /// DROP INDEX IF EXISTS orders_product_name_idx - /// ``` - /// - /// ### Example 2 `crate features postgresql only` - /// - /// Multiples call will concatenates all values - /// - /// ``` - /// # #[cfg(feature = "postgresql")] - /// # { - /// # use sql_query_builder as sql; - /// let query = sql::DropIndex::new() - /// .drop_index("users_name_idx") - /// .drop_index_if_exists("orders_product_name_idx") - /// .to_string(); - /// - /// # let expected = "DROP INDEX IF EXISTS users_name_idx, orders_product_name_idx"; - /// # assert_eq!(expected, query); - /// # } - /// ``` - /// - /// Outputs - /// - /// ```sql - /// DROP INDEX IF EXISTS users_name_idx, orders_product_name_idx - /// ``` - pub fn drop_index_if_exists(mut self, index_name: &str) -> Self { - push_unique(&mut self._drop_index, index_name.trim().to_string()); - self._if_exists = true; - self - } - /// Prints the current state of the [DropIndex] to the standard output in a more ease to read version. /// This method is useful to debug complex queries or just print the generated SQL while you type /// @@ -259,6 +206,64 @@ impl DropIndex { } } +#[cfg(any(feature = "postgresql", feature = "sqlite"))] +#[cfg_attr(docsrs, doc(cfg(feature = "postgresql")))] +#[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))] +impl DropIndex { + /// Defines a drop index parameter with the `if exists` modifier, this method overrides the previous value + /// + /// ### Example 1 + /// + /// ``` + /// # #[cfg(feature = "sqlite")] + /// # { + /// # use sql_query_builder as sql; + /// let query = sql::DropIndex::new() + /// .drop_index("users_name_idx") + /// .drop_index_if_exists("orders_product_name_idx") + /// .to_string(); + /// + /// # let expected = "DROP INDEX IF EXISTS orders_product_name_idx"; + /// # assert_eq!(expected, query); + /// # } + /// ``` + /// + /// Outputs + /// + /// ```sql + /// DROP INDEX IF EXISTS orders_product_name_idx + /// ``` + /// + /// ### Example 2 `crate features postgresql only` + /// + /// Multiples call will concatenates all values + /// + /// ``` + /// # #[cfg(feature = "postgresql")] + /// # { + /// # use sql_query_builder as sql; + /// let query = sql::DropIndex::new() + /// .drop_index("users_name_idx") + /// .drop_index_if_exists("orders_product_name_idx") + /// .to_string(); + /// + /// # let expected = "DROP INDEX IF EXISTS users_name_idx, orders_product_name_idx"; + /// # assert_eq!(expected, query); + /// # } + /// ``` + /// + /// Outputs + /// + /// ```sql + /// DROP INDEX IF EXISTS users_name_idx, orders_product_name_idx + /// ``` + pub fn drop_index_if_exists(mut self, index_name: &str) -> Self { + push_unique(&mut self._drop_index, index_name.trim().to_string()); + self._if_exists = true; + self + } +} + impl std::fmt::Display for DropIndex { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { write!(f, "{}", self.as_string()) diff --git a/src/lib.rs b/src/lib.rs index 61949d8..60c6357 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -23,10 +23,8 @@ pub use crate::structure::{ #[cfg(any(feature = "postgresql", feature = "sqlite", feature = "mysql"))] mod create_index; -#[cfg(any(feature = "postgresql", feature = "sqlite"))] +#[cfg(any(feature = "postgresql", feature = "sqlite", feature = "mysql"))] mod drop_index; #[cfg(any(feature = "postgresql", feature = "sqlite", feature = "mysql"))] -pub use crate::structure::{CreateIndex, CreateIndexParams}; -#[cfg(any(feature = "postgresql", feature = "sqlite"))] -pub use crate::structure::{DropIndex, DropIndexParams}; +pub use crate::structure::{CreateIndex, CreateIndexParams, DropIndex, DropIndexParams}; diff --git a/src/structure.rs b/src/structure.rs index f6359b3..6894724 100644 --- a/src/structure.rs +++ b/src/structure.rs @@ -330,12 +330,12 @@ pub enum DeleteClause { Partition, } -/// Builder to contruct a [DropIndex] command. Available only for the crate features `postgresql` and `sqlite`. +/// Builder to contruct a [DropIndex] command. Available only for the crate features `postgresql` and `sqlite` and `mysql`. /// /// Basic API /// /// ``` -/// # #[cfg(any(feature = "postgresql", feature = "sqlite"))] +/// # #[cfg(any(feature = "postgresql", feature = "sqlite", feature = "mysql"))] /// # { /// use sql_query_builder as sql; /// @@ -354,7 +354,7 @@ pub enum DeleteClause { /// ```sql /// DROP INDEX users_name_idx /// ``` -#[cfg(any(feature = "postgresql", feature = "sqlite"))] +#[cfg(any(feature = "postgresql", feature = "sqlite", feature = "mysql"))] #[derive(Default, Clone)] pub struct DropIndex { pub(crate) _drop_index: Vec, @@ -365,7 +365,7 @@ pub struct DropIndex { } /// All available params to be used in [DropIndex::raw_before] and [DropIndex::raw_after] methods on [DropIndex] builder -#[cfg(any(feature = "postgresql", feature = "sqlite"))] +#[cfg(any(feature = "postgresql", feature = "sqlite", feature = "mysql"))] #[derive(PartialEq, Clone)] pub enum DropIndexParams { DropIndex, diff --git a/tests/command_drop_index_spec.rs b/tests/command_drop_index_spec.rs index da37722..c9dd32b 100644 --- a/tests/command_drop_index_spec.rs +++ b/tests/command_drop_index_spec.rs @@ -1,4 +1,48 @@ -#[cfg(any(feature = "postgresql", feature = "sqlite"))] +#[cfg(any(feature = "postgresql", feature = "sqlite", feature = "mysql"))] +mod full_api { + use pretty_assertions::assert_eq; + use sql_query_builder as sql; + + #[cfg(feature = "postgresql")] + #[test] + fn postgres_with_all_methods() { + let query = sql::DropIndex::new() + // at least one of methods + .drop_index("users_name_idx") + .drop_index_if_exists("users_login_idx") + .as_string(); + + let expected_query = "DROP INDEX IF EXISTS users_name_idx, users_login_idx"; + + assert_eq!(expected_query, query); + } + + #[cfg(feature = "sqlite")] + #[test] + fn sqlite_with_all_methods() { + let query = sql::DropIndex::new() + // at least one of methods + .drop_index("users_name_idx") + .drop_index_if_exists("users_login_idx") + .as_string(); + + let expected_query = "DROP INDEX IF EXISTS users_login_idx"; + + assert_eq!(expected_query, query); + } + + #[cfg(feature = "mysql")] + #[test] + fn mysql_with_all_methods() { + let query = sql::DropIndex::new().drop_index("users_name_idx").as_string(); + + let expected_query = "DROP INDEX users_name_idx"; + + assert_eq!(expected_query, query); + } +} + +#[cfg(any(feature = "postgresql", feature = "sqlite", feature = "mysql"))] mod builder_features { use pretty_assertions::assert_eq; use sql_query_builder as sql; @@ -27,36 +71,47 @@ mod builder_features { assert_eq!(expected_query, query); } - #[cfg(not(feature = "postgresql"))] #[test] - fn drop_index_builder_should_be_able_to_conditionally_add_clauses() { - let mut drop_index = sql::DropIndex::new().drop_index("users_name_idx"); + fn drop_index_builder_should_be_composable() { + fn add_comment(select: sql::DropIndex) -> sql::DropIndex { + select.raw("/* drop command */") + } - if true { - drop_index = drop_index.drop_index("users_name_idx"); + fn drop_users_name_idx(select: sql::DropIndex) -> sql::DropIndex { + select.drop_index("users_name_idx") } - let query = drop_index.as_string(); - let expected_query = "DROP INDEX users_name_idx"; + fn as_string(select: sql::DropIndex) -> String { + select.as_string() + } + + let query = Some(sql::DropIndex::new()) + .map(add_comment) + .map(drop_users_name_idx) + .map(as_string) + .unwrap(); + + let expected_query = "/* drop command */ DROP INDEX users_name_idx"; assert_eq!(expected_query, query); } - #[cfg(feature = "postgresql")] + #[cfg(any(feature = "sqlite", feature = "mysql"))] #[test] fn drop_index_builder_should_be_able_to_conditionally_add_clauses() { let mut drop_index = sql::DropIndex::new().drop_index("users_name_idx"); if true { - drop_index = drop_index.drop_index("users_age_idx"); + drop_index = drop_index.drop_index("users_name_idx"); } - let expected_query = "DROP INDEX users_name_idx, users_age_idx"; + let query = drop_index.as_string(); + let expected_query = "DROP INDEX users_name_idx"; - assert_eq!(expected_query, drop_index.as_string()); + assert_eq!(expected_query, query); } - #[cfg(not(feature = "postgresql"))] + #[cfg(any(feature = "sqlite", feature = "mysql"))] #[test] fn drop_index_builder_should_be_cloneable() { let drop_users = sql::DropIndex::new().drop_index("users_name_idx"); @@ -74,7 +129,21 @@ mod builder_features { #[cfg(feature = "postgresql")] #[test] - fn drop_index_builder_should_be_cloneable() { + fn drop_index_builder_should_be_able_to_conditionally_add_clauses_in_postgresql() { + let mut drop_index = sql::DropIndex::new().drop_index("users_name_idx"); + + if true { + drop_index = drop_index.drop_index("users_age_idx"); + } + + let expected_query = "DROP INDEX users_name_idx, users_age_idx"; + + assert_eq!(expected_query, drop_index.as_string()); + } + + #[cfg(feature = "postgresql")] + #[test] + fn drop_index_builder_should_be_cloneable_in_postgresql() { let drop_index_name = sql::DropIndex::new().drop_index("users_name_idx"); let drop_index_name_and_age = drop_index_name.clone().drop_index("users_age_idx"); @@ -84,34 +153,9 @@ mod builder_features { let expected_drop_index_name_and_age = "DROP INDEX users_name_idx, users_age_idx"; assert_eq!(expected_drop_index_name_and_age, drop_index_name_and_age.as_string()); } - - #[test] - fn drop_index_builder_should_be_composable() { - fn add_comment(select: sql::DropIndex) -> sql::DropIndex { - select.raw("/* drop command */") - } - - fn drop_users_name_idx(select: sql::DropIndex) -> sql::DropIndex { - select.drop_index("users_name_idx") - } - - fn as_string(select: sql::DropIndex) -> String { - select.as_string() - } - - let query = Some(sql::DropIndex::new()) - .map(add_comment) - .map(drop_users_name_idx) - .map(as_string) - .unwrap(); - - let expected_query = "/* drop command */ DROP INDEX users_name_idx"; - - assert_eq!(expected_query, query); - } } -#[cfg(any(feature = "postgresql", feature = "sqlite"))] +#[cfg(any(feature = "postgresql", feature = "sqlite", feature = "mysql"))] mod builder_methods { use pretty_assertions::assert_eq; use sql_query_builder as sql; @@ -134,24 +178,18 @@ mod builder_methods { #[test] fn method_debug_should_print_at_console_in_a_human_readable_format() { - let query = sql::DropIndex::new() - .drop_index_if_exists("users_name_idx") - .debug() - .as_string(); + let query = sql::DropIndex::new().drop_index("users_name_idx").debug().as_string(); - let expected_query = "DROP INDEX IF EXISTS users_name_idx"; + let expected_query = "DROP INDEX users_name_idx"; assert_eq!(expected_query, query); } #[test] fn method_print_should_print_in_one_line_the_current_state_of_builder() { - let query = sql::DropIndex::new() - .drop_index_if_exists("users_name_idx") - .print() - .as_string(); + let query = sql::DropIndex::new().drop_index("users_name_idx").print().as_string(); - let expected_query = "DROP INDEX IF EXISTS users_name_idx"; + let expected_query = "DROP INDEX users_name_idx"; assert_eq!(expected_query, query); } @@ -238,7 +276,7 @@ mod builder_methods { } } -#[cfg(any(feature = "postgresql", feature = "sqlite"))] +#[cfg(any(feature = "postgresql", feature = "sqlite", feature = "mysql"))] mod method_drop_index { use pretty_assertions::assert_eq; use sql_query_builder as sql; @@ -251,28 +289,50 @@ mod method_drop_index { assert_eq!(expected_query, query); } - #[cfg(not(feature = "postgresql"))] #[test] - fn method_drop_index_should_overrides_previous_value_on_consecutive_calls() { + fn method_drop_index_should_trim_space_of_the_argument() { + let query = sql::DropIndex::new().drop_index(" films_title_idx ").as_string(); + let expected_query = "DROP INDEX films_title_idx"; + + assert_eq!(expected_query, query); + } + + #[test] + fn method_raw_before_should_add_raw_sql_before_method_drop_index() { let query = sql::DropIndex::new() + .raw_before(sql::DropIndexParams::DropIndex, "/* drop command */") .drop_index("films_title_idx") - .drop_index("films_published_at_idx") .as_string(); + let expected_query = "/* drop command */ DROP INDEX films_title_idx"; - let expected_query = "DROP INDEX films_published_at_idx"; + assert_eq!(expected_query, query); + } + + #[test] + fn method_raw_after_should_add_raw_sql_after_method_drop_index() { + let query = sql::DropIndex::new() + .drop_index("films_title_idx") + .raw_after(sql::DropIndexParams::DropIndex, "/* end drop index */") + .as_string(); + let expected_query = "DROP INDEX films_title_idx /* end drop index */"; assert_eq!(expected_query, query); } + #[cfg(any(feature = "sqlite", feature = "mysql"))] #[test] - fn method_drop_index_should_trim_space_of_the_argument() { - let query = sql::DropIndex::new().drop_index(" films_title_idx ").as_string(); - let expected_query = "DROP INDEX films_title_idx"; + fn method_drop_index_should_overrides_previous_value_on_consecutive_calls() { + let query = sql::DropIndex::new() + .drop_index("films_title_idx") + .drop_index("films_published_at_idx") + .as_string(); + + let expected_query = "DROP INDEX films_published_at_idx"; assert_eq!(expected_query, query); } - #[cfg(not(feature = "postgresql"))] + #[cfg(any(feature = "sqlite", feature = "mysql"))] #[test] fn method_drop_index_should_not_accumulate_arguments_with_the_same_content() { let query = sql::DropIndex::new() @@ -284,24 +344,29 @@ mod method_drop_index { assert_eq!(expected_query, query); } + #[cfg(feature = "postgresql")] #[test] - fn method_raw_before_should_add_raw_sql_before_method_drop_index() { + fn method_drop_index_should_accumulate_values_on_consecutive_calls() { let query = sql::DropIndex::new() - .raw_before(sql::DropIndexParams::DropIndex, "/* drop command */") .drop_index("films_title_idx") + .drop_index("series") .as_string(); - let expected_query = "/* drop command */ DROP INDEX films_title_idx"; + + let expected_query = "DROP INDEX films_title_idx, series"; assert_eq!(expected_query, query); } + #[cfg(feature = "postgresql")] #[test] - fn method_raw_after_should_add_raw_sql_after_method_drop_index() { + fn method_drop_index_should_not_accumulate_values_when_expression_is_empty() { let query = sql::DropIndex::new() - .drop_index("films_title_idx") - .raw_after(sql::DropIndexParams::DropIndex, "/* end drop index */") + .drop_index("") + .drop_index("series") + .drop_index("") .as_string(); - let expected_query = "DROP INDEX films_title_idx /* end drop index */"; + + let expected_query = "DROP INDEX series"; assert_eq!(expected_query, query); } @@ -322,19 +387,6 @@ mod method_drop_index_if_exists { assert_eq!(expected_query, query); } - #[cfg(not(feature = "postgresql"))] - #[test] - fn method_drop_index_if_exists_should_overrides_previous_value_on_consecutive_calls() { - let query = sql::DropIndex::new() - .drop_index_if_exists("films_title_idx") - .drop_index_if_exists("films_published_at_idx") - .as_string(); - - let expected_query = "DROP INDEX IF EXISTS films_published_at_idx"; - - assert_eq!(expected_query, query); - } - #[test] fn method_drop_index_if_exists_should_trim_space_of_the_argument() { let query = sql::DropIndex::new() @@ -345,18 +397,6 @@ mod method_drop_index_if_exists { assert_eq!(expected_query, query); } - #[cfg(not(feature = "postgresql"))] - #[test] - fn method_drop_index_if_exists_should_not_accumulate_arguments_with_the_same_content() { - let query = sql::DropIndex::new() - .drop_index_if_exists("films_title_idx") - .drop_index_if_exists("films_title_idx") - .as_string(); - let expected_query = "DROP INDEX IF EXISTS films_title_idx"; - - assert_eq!(expected_query, query); - } - #[test] fn method_raw_before_should_add_raw_sql_before_method_drop_index_if_exists() { let query = sql::DropIndex::new() @@ -378,59 +418,55 @@ mod method_drop_index_if_exists { assert_eq!(expected_query, query); } -} - -#[cfg(feature = "postgresql")] -mod postgres_feature_flag { - use pretty_assertions::assert_eq; - use sql_query_builder as sql; + #[cfg(feature = "postgresql")] #[test] - fn method_drop_index_should_accumulate_values_on_consecutive_calls() { + fn method_drop_index_if_exists_should_accumulate_values_on_consecutive_calls() { let query = sql::DropIndex::new() - .drop_index("films_title_idx") - .drop_index("series") + .drop_index_if_exists("films_title_idx") + .drop_index_if_exists("series") .as_string(); - let expected_query = "DROP INDEX films_title_idx, series"; + let expected_query = "DROP INDEX IF EXISTS films_title_idx, series"; assert_eq!(expected_query, query); } + #[cfg(feature = "postgresql")] #[test] - fn method_drop_index_should_not_accumulate_values_when_expression_is_empty() { + fn method_drop_index_if_exists_should_not_accumulate_values_when_expression_is_empty() { let query = sql::DropIndex::new() - .drop_index("") - .drop_index("series") - .drop_index("") + .drop_index_if_exists("") + .drop_index_if_exists("series") + .drop_index_if_exists("") .as_string(); - let expected_query = "DROP INDEX series"; + let expected_query = "DROP INDEX IF EXISTS series"; assert_eq!(expected_query, query); } + #[cfg(feature = "sqlite")] #[test] - fn method_drop_index_if_exists_should_accumulate_values_on_consecutive_calls() { + fn method_drop_index_if_exists_should_overrides_previous_value_on_consecutive_calls() { let query = sql::DropIndex::new() .drop_index_if_exists("films_title_idx") - .drop_index_if_exists("series") + .drop_index_if_exists("films_published_at_idx") .as_string(); - let expected_query = "DROP INDEX IF EXISTS films_title_idx, series"; + let expected_query = "DROP INDEX IF EXISTS films_published_at_idx"; assert_eq!(expected_query, query); } + #[cfg(feature = "sqlite")] #[test] - fn method_drop_index_if_exists_should_not_accumulate_values_when_expression_is_empty() { + fn method_drop_index_if_exists_should_not_accumulate_arguments_with_the_same_content() { let query = sql::DropIndex::new() - .drop_index_if_exists("") - .drop_index_if_exists("series") - .drop_index_if_exists("") + .drop_index_if_exists("films_title_idx") + .drop_index_if_exists("films_title_idx") .as_string(); - - let expected_query = "DROP INDEX IF EXISTS series"; + let expected_query = "DROP INDEX IF EXISTS films_title_idx"; assert_eq!(expected_query, query); }