From 54f62cfeb6c8835ecf86e55539ea55eabe81e587 Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Sat, 28 Oct 2023 18:51:18 -0400 Subject: [PATCH 01/10] Add filter() fn, update pagination() fn --- src/bin/main.rs | 13 +++ src/code.rs | 105 ++++++++++++++++-- src/lib.rs | 18 ++- .../models/todos/generated.rs | 53 +++++++-- .../models/todos/generated.rs | 53 +++++++-- .../models/todos/generated.rs | 53 +++++++-- .../models/todos/generated.rs | 68 ++++++++++-- .../models/todos/generated.rs | 63 +++++++++-- .../models/todos/generated.rs | 63 +++++++++-- .../models/tableA/generated.rs | 48 ++++++-- .../models/tableB/generated.rs | 53 +++++++-- .../models/tableA/generated.rs | 48 ++++++-- .../models/tableB/generated.rs | 53 +++++++-- .../models/todos/generated.rs | 48 ++++++-- .../models/users/generated.rs | 58 ++++++++-- .../models/table1/generated.rs | 48 ++++++-- .../models/table2/generated.rs | 48 ++++++-- .../models/table1/generated.rs | 48 ++++++-- .../models/table2/generated.rs | 48 ++++++-- .../models/table1.rs | 48 ++++++-- .../models/table2.rs | 48 ++++++-- .../models/table1/generated.rs | 48 ++++++-- .../models/table2/generated.rs | 48 ++++++-- test/simple_table/models/todos/generated.rs | 83 ++++++++++++-- .../models/todos/generated.rs | 73 ++++++++++-- .../models/todos/generated.rs | 73 ++++++++++-- .../models/todos/generated.rs | 73 ++++++++++-- test/single_model_file/models/table1.rs | 48 ++++++-- test/single_model_file/models/table2.rs | 48 ++++++-- .../models/fang_tasks/generated.rs | 93 ++++++++++++++-- 30 files changed, 1415 insertions(+), 257 deletions(-) diff --git a/src/bin/main.rs b/src/bin/main.rs index 08f04469..4e8493bf 100644 --- a/src/bin/main.rs +++ b/src/bin/main.rs @@ -102,6 +102,18 @@ pub struct MainOptions { /// Generate the "ConnectionType" type only once in a "common.rs" file #[arg(long = "once-connection-type")] pub once_connection_type: bool, + + /// Set which diesel backend to use (something which implements `diesel::backend::Backend`) + /// Deisel provides the following backends: + /// - `diesel::pg::Pg` + /// - `diesel::sqlite::Sqlite` + /// - `diesel::mysql::Mysql` + /// + /// See `crate::GenerationConfig::diesel_backend` for more details. + /// + /// Default is "diesel::pg::Pg" + #[arg(long = "diesel-backend", default_value = "diesel::pg::Pg")] + pub diesel_backend: String, } #[derive(Debug, ValueEnum, Clone, PartialEq, Default)] @@ -203,6 +215,7 @@ fn actual_main() -> dsync::Result<()> { model_path: args.model_path, once_common_structs: args.once_common_structs, once_connection_type: args.once_connection_type, + diesel_backend: args.diesel_backend, }, )?; diff --git a/src/code.rs b/src/code.rs index 89ef9a1f..4501cfc5 100644 --- a/src/code.rs +++ b/src/code.rs @@ -215,7 +215,7 @@ impl<'a> Struct<'a> { /// Render the full struct fn render(&mut self) { let ty = self.ty; - let table = &self.table; + let table = self.table; let primary_keys: Vec = table.primary_key_column_names(); @@ -422,25 +422,62 @@ impl {struct_name} {{ )); buffer.push_str(&format!(r##" - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub{async_keyword} fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> {{ + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub{async_keyword} fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: {struct_name}Filter) -> QueryResult> {{ use {schema_path}{table_name}::dsl::*; - let page_size = if page_size < 1 {{ 1 }} else {{ page_size }}; - let total_items = {table_name}.count().get_result(db){await_keyword}?; - let items = {table_name}.limit(page_size).offset(page * page_size).load::(db){await_keyword}?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db){await_keyword}?; Ok(PaginationResult {{ items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }}) }} "##)); + // Table::filter() helper fn + { + let diesel_backend = config.diesel_backend.clone(); + let filters = table + .columns + .iter() + .map(|column| { + let column_name = column.name.to_string(); + format!( + r##" + if let Some(filter_{column_name}) = filter.{column_name}.clone() {{ + query = query.filter({schema_path}{table_name}::{column_name}.eq(filter_{column_name})); + }}"## + ) + }) + .collect::>() + .join(""); + buffer.push_str(&format!( + r##" + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: {struct_name}Filter, + ) -> {schema_path}{table_name}::BoxedQuery<'a, {diesel_backend}> {{ + let mut query = {schema_path}{table_name}::table.into_boxed(); + + {filters} + + query + }} +"## + )); + } + // TODO: If primary key columns are attached to the form struct (not optionally) // then don't require item_id_params (otherwise it'll be duplicated) @@ -470,10 +507,56 @@ impl {struct_name} {{ )); buffer.push_str( - r##" -}"##, + r#" +}"#, ); + // generate filter struct for filter() helper function + { + let filter_fields = table + .columns + .iter() + .map(|column| { + let column_name = column.name.to_string(); + format!( + "pub {column_name}: Option<{column_type}>,", + column_name = column_name, + column_type = if column.is_nullable { + format!("Option<{}>", column.ty) + } else { + column.ty.clone() + } + ) + }) + .collect::>() + .join("\n "); + let filter_fields_default = table + .columns + .iter() + .map(|column| { + let column_name = column.name.to_string(); + format!("{column_name}: None,") + }) + .collect::>() + .join("\n "); + buffer.push_str(&format!( + r##" +#[derive(Clone)] +pub struct {struct_name}Filter {{ + {filter_fields} +}} + +impl Default for {struct_name}Filter {{ + fn default() -> {struct_name}Filter {{ + {struct_name}Filter {{ + {filter_fields_default} + }} + }} +}} +"## + )); + } + buffer } diff --git a/src/lib.rs b/src/lib.rs index 305db755..0fc0c769 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -214,14 +214,26 @@ impl<'a> Default for TableOptions<'a> { #[derive(Debug, Clone)] pub struct GenerationConfig<'a> { - /// Specific Table options for a given table + /// Specific code generation options for a particular table pub table_options: HashMap<&'a str, TableOptions<'a>>, - /// Default table options, used when not in `table_options` + /// Default table options, can be overriden by `table_options` pub default_table_options: TableOptions<'a>, /// Connection type to insert /// - /// Example: `diesel::SqliteConnection` + /// For example: + /// - `diesel::pg::PgConnection` (default) + /// - `diesel::sqlite::SqliteConnection` + /// - `diesel::mysql::MysqlConnection` + /// - or, your custom diesel connection type (struct which implements `diesel::connection::Connection`) pub connection_type: String, + /// Diesel backend + /// + /// For example: + /// - `diesel::pg::Pg` (default) + /// - `diesel::sqlite::Sqlite` + /// - `diesel::mysql::Mysql` + /// - or, your custom diesel backend type (struct which implements `diesel::backend::Backend`) + pub diesel_backend: String, /// Diesel schema import path /// /// by default `crate::schema::` diff --git a/test/autogenerated_all/models/todos/generated.rs b/test/autogenerated_all/models/todos/generated.rs index 12a5c285..9a75dae0 100644 --- a/test/autogenerated_all/models/todos/generated.rs +++ b/test/autogenerated_all/models/todos/generated.rs @@ -47,24 +47,45 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::todos::created_at.eq(filter_created_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -77,4 +98,18 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub created_at: Option, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + created_at: None, + } + } +} diff --git a/test/autogenerated_attributes/models/todos/generated.rs b/test/autogenerated_attributes/models/todos/generated.rs index 90fcf2cc..bf66d653 100644 --- a/test/autogenerated_attributes/models/todos/generated.rs +++ b/test/autogenerated_attributes/models/todos/generated.rs @@ -52,24 +52,45 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::todos::created_at.eq(filter_created_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -82,4 +103,18 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub created_at: Option, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + created_at: None, + } + } +} diff --git a/test/autogenerated_primary_keys/models/todos/generated.rs b/test/autogenerated_primary_keys/models/todos/generated.rs index fcb0fd23..040f0d36 100644 --- a/test/autogenerated_primary_keys/models/todos/generated.rs +++ b/test/autogenerated_primary_keys/models/todos/generated.rs @@ -52,24 +52,45 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -82,4 +103,18 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub text: Option, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + text: None, + } + } +} diff --git a/test/cleanup_generated_content/models/todos/generated.rs b/test/cleanup_generated_content/models/todos/generated.rs index 2cb0655d..96eee3da 100644 --- a/test/cleanup_generated_content/models/todos/generated.rs +++ b/test/cleanup_generated_content/models/todos/generated.rs @@ -60,24 +60,54 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + if let Some(filter_completed) = filter.completed.clone() { + query = query.filter(crate::schema::todos::completed.eq(filter_completed)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::todos::created_at.eq(filter_created_at)); + } + if let Some(filter_updated_at) = filter.updated_at.clone() { + query = query.filter(crate::schema::todos::updated_at.eq(filter_updated_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -90,4 +120,24 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub text: Option, + pub completed: Option, + pub created_at: Option>, + pub updated_at: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + text: None, + completed: None, + created_at: None, + updated_at: None, + } + } +} diff --git a/test/create_update_str_cow/models/todos/generated.rs b/test/create_update_str_cow/models/todos/generated.rs index b186fe90..06700656 100644 --- a/test/create_update_str_cow/models/todos/generated.rs +++ b/test/create_update_str_cow/models/todos/generated.rs @@ -59,24 +59,51 @@ impl Todos { todos.filter(text.eq(param_text)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + if let Some(filter_text_nullable) = filter.text_nullable.clone() { + query = query.filter(crate::schema::todos::text_nullable.eq(filter_text_nullable)); + } + if let Some(filter_varchar) = filter.varchar.clone() { + query = query.filter(crate::schema::todos::varchar.eq(filter_varchar)); + } + if let Some(filter_varchar_nullable) = filter.varchar_nullable.clone() { + query = query.filter(crate::schema::todos::varchar_nullable.eq(filter_varchar_nullable)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_text: String, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -89,4 +116,22 @@ impl Todos { diesel::delete(todos.filter(text.eq(param_text))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub text: Option, + pub text_nullable: Option>, + pub varchar: Option, + pub varchar_nullable: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + text: None, + text_nullable: None, + varchar: None, + varchar_nullable: None, + } + } +} diff --git a/test/create_update_str_str/models/todos/generated.rs b/test/create_update_str_str/models/todos/generated.rs index 49226d0a..986b149a 100644 --- a/test/create_update_str_str/models/todos/generated.rs +++ b/test/create_update_str_str/models/todos/generated.rs @@ -59,24 +59,51 @@ impl Todos { todos.filter(text.eq(param_text)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + if let Some(filter_text_nullable) = filter.text_nullable.clone() { + query = query.filter(crate::schema::todos::text_nullable.eq(filter_text_nullable)); + } + if let Some(filter_varchar) = filter.varchar.clone() { + query = query.filter(crate::schema::todos::varchar.eq(filter_varchar)); + } + if let Some(filter_varchar_nullable) = filter.varchar_nullable.clone() { + query = query.filter(crate::schema::todos::varchar_nullable.eq(filter_varchar_nullable)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_text: String, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -89,4 +116,22 @@ impl Todos { diesel::delete(todos.filter(text.eq(param_text))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub text: Option, + pub text_nullable: Option>, + pub varchar: Option, + pub varchar_nullable: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + text: None, + text_nullable: None, + varchar: None, + varchar_nullable: None, + } + } +} diff --git a/test/custom_model_and_schema_path/models/tableA/generated.rs b/test/custom_model_and_schema_path/models/tableA/generated.rs index ee0dbd28..70bf9ab8 100644 --- a/test/custom_model_and_schema_path/models/tableA/generated.rs +++ b/test/custom_model_and_schema_path/models/tableA/generated.rs @@ -46,28 +46,58 @@ impl TableA { tableA.filter(_id.eq(param__id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TableAFilter) -> QueryResult> { use crate::data::schema::tableA::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = tableA.count().get_result(db)?; - let items = tableA.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TableAFilter, + ) -> crate::data::schema::tableA::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::data::schema::tableA::table.into_boxed(); + + + if let Some(filter__id) = filter._id.clone() { + query = query.filter(crate::data::schema::tableA::_id.eq(filter__id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param__id: i32) -> QueryResult { use crate::data::schema::tableA::dsl::*; diesel::delete(tableA.filter(_id.eq(param__id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TableAFilter { + pub _id: Option, +} + +impl Default for TableAFilter { + fn default() -> TableAFilter { + TableAFilter { + _id: None, + } + } +} diff --git a/test/custom_model_and_schema_path/models/tableB/generated.rs b/test/custom_model_and_schema_path/models/tableB/generated.rs index 8c058699..604827c3 100644 --- a/test/custom_model_and_schema_path/models/tableB/generated.rs +++ b/test/custom_model_and_schema_path/models/tableB/generated.rs @@ -53,24 +53,45 @@ impl TableB { tableB.filter(_id.eq(param__id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TableBFilter) -> QueryResult> { use crate::data::schema::tableB::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = tableB.count().get_result(db)?; - let items = tableB.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TableBFilter, + ) -> crate::data::schema::tableB::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::data::schema::tableB::table.into_boxed(); + + + if let Some(filter__id) = filter._id.clone() { + query = query.filter(crate::data::schema::tableB::_id.eq(filter__id)); + } + if let Some(filter_link) = filter.link.clone() { + query = query.filter(crate::data::schema::tableB::link.eq(filter_link)); + } + + query + } + pub fn update(db: &mut ConnectionType, param__id: i32, item: &UpdateTableB) -> QueryResult { use crate::data::schema::tableB::dsl::*; @@ -83,4 +104,18 @@ impl TableB { diesel::delete(tableB.filter(_id.eq(param__id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TableBFilter { + pub _id: Option, + pub link: Option, +} + +impl Default for TableBFilter { + fn default() -> TableBFilter { + TableBFilter { + _id: None, + link: None, + } + } +} diff --git a/test/custom_model_path/models/tableA/generated.rs b/test/custom_model_path/models/tableA/generated.rs index 1ef02b7c..149490b8 100644 --- a/test/custom_model_path/models/tableA/generated.rs +++ b/test/custom_model_path/models/tableA/generated.rs @@ -46,28 +46,58 @@ impl TableA { tableA.filter(_id.eq(param__id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TableAFilter) -> QueryResult> { use crate::schema::tableA::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = tableA.count().get_result(db)?; - let items = tableA.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TableAFilter, + ) -> crate::schema::tableA::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::tableA::table.into_boxed(); + + + if let Some(filter__id) = filter._id.clone() { + query = query.filter(crate::schema::tableA::_id.eq(filter__id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param__id: i32) -> QueryResult { use crate::schema::tableA::dsl::*; diesel::delete(tableA.filter(_id.eq(param__id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TableAFilter { + pub _id: Option, +} + +impl Default for TableAFilter { + fn default() -> TableAFilter { + TableAFilter { + _id: None, + } + } +} diff --git a/test/custom_model_path/models/tableB/generated.rs b/test/custom_model_path/models/tableB/generated.rs index 5ccec4ac..3244c59e 100644 --- a/test/custom_model_path/models/tableB/generated.rs +++ b/test/custom_model_path/models/tableB/generated.rs @@ -53,24 +53,45 @@ impl TableB { tableB.filter(_id.eq(param__id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TableBFilter) -> QueryResult> { use crate::schema::tableB::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = tableB.count().get_result(db)?; - let items = tableB.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TableBFilter, + ) -> crate::schema::tableB::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::tableB::table.into_boxed(); + + + if let Some(filter__id) = filter._id.clone() { + query = query.filter(crate::schema::tableB::_id.eq(filter__id)); + } + if let Some(filter_link) = filter.link.clone() { + query = query.filter(crate::schema::tableB::link.eq(filter_link)); + } + + query + } + pub fn update(db: &mut ConnectionType, param__id: i32, item: &UpdateTableB) -> QueryResult { use crate::schema::tableB::dsl::*; @@ -83,4 +104,18 @@ impl TableB { diesel::delete(tableB.filter(_id.eq(param__id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TableBFilter { + pub _id: Option, + pub link: Option, +} + +impl Default for TableBFilter { + fn default() -> TableBFilter { + TableBFilter { + _id: None, + link: None, + } + } +} diff --git a/test/manual_primary_keys/models/todos/generated.rs b/test/manual_primary_keys/models/todos/generated.rs index 4bcdb7f0..82cca02f 100644 --- a/test/manual_primary_keys/models/todos/generated.rs +++ b/test/manual_primary_keys/models/todos/generated.rs @@ -46,28 +46,58 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: i32) -> QueryResult { use crate::schema::todos::dsl::*; diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + } + } +} diff --git a/test/multiple_primary_keys/models/users/generated.rs b/test/multiple_primary_keys/models/users/generated.rs index 579d05d3..84054340 100644 --- a/test/multiple_primary_keys/models/users/generated.rs +++ b/test/multiple_primary_keys/models/users/generated.rs @@ -55,24 +55,48 @@ impl Users { users.filter(name.eq(param_name)).filter(address.eq(param_address)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: UsersFilter) -> QueryResult> { use crate::schema::users::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = users.count().get_result(db)?; - let items = users.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: UsersFilter, + ) -> crate::schema::users::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::users::table.into_boxed(); + + + if let Some(filter_name) = filter.name.clone() { + query = query.filter(crate::schema::users::name.eq(filter_name)); + } + if let Some(filter_address) = filter.address.clone() { + query = query.filter(crate::schema::users::address.eq(filter_address)); + } + if let Some(filter_secret) = filter.secret.clone() { + query = query.filter(crate::schema::users::secret.eq(filter_secret)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_name: String, param_address: String, item: &UpdateUsers) -> QueryResult { use crate::schema::users::dsl::*; @@ -85,4 +109,20 @@ impl Users { diesel::delete(users.filter(name.eq(param_name)).filter(address.eq(param_address))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct UsersFilter { + pub name: Option, + pub address: Option, + pub secret: Option, +} + +impl Default for UsersFilter { + fn default() -> UsersFilter { + UsersFilter { + name: None, + address: None, + secret: None, + } + } +} diff --git a/test/once_common_structs/models/table1/generated.rs b/test/once_common_structs/models/table1/generated.rs index 9fb85dee..7c785853 100644 --- a/test/once_common_structs/models/table1/generated.rs +++ b/test/once_common_structs/models/table1/generated.rs @@ -32,28 +32,58 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table1.count().get_result(db)?; - let items = table1.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table1Filter, + ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table1::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table1::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table1::dsl::*; diesel::delete(table1.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table1Filter { + pub id: Option, +} + +impl Default for Table1Filter { + fn default() -> Table1Filter { + Table1Filter { + id: None, + } + } +} diff --git a/test/once_common_structs/models/table2/generated.rs b/test/once_common_structs/models/table2/generated.rs index 39a45fdc..c8d168f6 100644 --- a/test/once_common_structs/models/table2/generated.rs +++ b/test/once_common_structs/models/table2/generated.rs @@ -32,28 +32,58 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table2.count().get_result(db)?; - let items = table2.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table2Filter, + ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table2::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table2::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table2::dsl::*; diesel::delete(table2.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table2Filter { + pub id: Option, +} + +impl Default for Table2Filter { + fn default() -> Table2Filter { + Table2Filter { + id: None, + } + } +} diff --git a/test/once_common_structs_once_connection_type/models/table1/generated.rs b/test/once_common_structs_once_connection_type/models/table1/generated.rs index bbf169af..18b78dbb 100644 --- a/test/once_common_structs_once_connection_type/models/table1/generated.rs +++ b/test/once_common_structs_once_connection_type/models/table1/generated.rs @@ -29,28 +29,58 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table1.count().get_result(db)?; - let items = table1.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table1Filter, + ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table1::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table1::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table1::dsl::*; diesel::delete(table1.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table1Filter { + pub id: Option, +} + +impl Default for Table1Filter { + fn default() -> Table1Filter { + Table1Filter { + id: None, + } + } +} diff --git a/test/once_common_structs_once_connection_type/models/table2/generated.rs b/test/once_common_structs_once_connection_type/models/table2/generated.rs index f7b2425b..4c296f08 100644 --- a/test/once_common_structs_once_connection_type/models/table2/generated.rs +++ b/test/once_common_structs_once_connection_type/models/table2/generated.rs @@ -29,28 +29,58 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table2.count().get_result(db)?; - let items = table2.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table2Filter, + ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table2::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table2::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table2::dsl::*; diesel::delete(table2.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table2Filter { + pub id: Option, +} + +impl Default for Table2Filter { + fn default() -> Table2Filter { + Table2Filter { + id: None, + } + } +} diff --git a/test/once_common_structs_once_connection_type_single_file/models/table1.rs b/test/once_common_structs_once_connection_type_single_file/models/table1.rs index bbf169af..18b78dbb 100644 --- a/test/once_common_structs_once_connection_type_single_file/models/table1.rs +++ b/test/once_common_structs_once_connection_type_single_file/models/table1.rs @@ -29,28 +29,58 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table1.count().get_result(db)?; - let items = table1.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table1Filter, + ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table1::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table1::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table1::dsl::*; diesel::delete(table1.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table1Filter { + pub id: Option, +} + +impl Default for Table1Filter { + fn default() -> Table1Filter { + Table1Filter { + id: None, + } + } +} diff --git a/test/once_common_structs_once_connection_type_single_file/models/table2.rs b/test/once_common_structs_once_connection_type_single_file/models/table2.rs index f7b2425b..4c296f08 100644 --- a/test/once_common_structs_once_connection_type_single_file/models/table2.rs +++ b/test/once_common_structs_once_connection_type_single_file/models/table2.rs @@ -29,28 +29,58 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table2.count().get_result(db)?; - let items = table2.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table2Filter, + ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table2::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table2::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table2::dsl::*; diesel::delete(table2.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table2Filter { + pub id: Option, +} + +impl Default for Table2Filter { + fn default() -> Table2Filter { + Table2Filter { + id: None, + } + } +} diff --git a/test/once_connection_type/models/table1/generated.rs b/test/once_connection_type/models/table1/generated.rs index 9a7a44e1..c8c5bbc1 100644 --- a/test/once_connection_type/models/table1/generated.rs +++ b/test/once_connection_type/models/table1/generated.rs @@ -39,28 +39,58 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table1.count().get_result(db)?; - let items = table1.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table1Filter, + ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table1::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table1::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table1::dsl::*; diesel::delete(table1.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table1Filter { + pub id: Option, +} + +impl Default for Table1Filter { + fn default() -> Table1Filter { + Table1Filter { + id: None, + } + } +} diff --git a/test/once_connection_type/models/table2/generated.rs b/test/once_connection_type/models/table2/generated.rs index 4e1b27a8..5a8d92d7 100644 --- a/test/once_connection_type/models/table2/generated.rs +++ b/test/once_connection_type/models/table2/generated.rs @@ -39,28 +39,58 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table2.count().get_result(db)?; - let items = table2.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table2Filter, + ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table2::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table2::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table2::dsl::*; diesel::delete(table2.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table2Filter { + pub id: Option, +} + +impl Default for Table2Filter { + fn default() -> Table2Filter { + Table2Filter { + id: None, + } + } +} diff --git a/test/simple_table/models/todos/generated.rs b/test/simple_table/models/todos/generated.rs index 13f8da2e..154b2050 100644 --- a/test/simple_table/models/todos/generated.rs +++ b/test/simple_table/models/todos/generated.rs @@ -68,24 +68,63 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_unsigned) = filter.unsigned.clone() { + query = query.filter(crate::schema::todos::unsigned.eq(filter_unsigned)); + } + if let Some(filter_unsigned_nullable) = filter.unsigned_nullable.clone() { + query = query.filter(crate::schema::todos::unsigned_nullable.eq(filter_unsigned_nullable)); + } + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + if let Some(filter_completed) = filter.completed.clone() { + query = query.filter(crate::schema::todos::completed.eq(filter_completed)); + } + if let Some(filter_type_) = filter.type_.clone() { + query = query.filter(crate::schema::todos::type_.eq(filter_type_)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::todos::created_at.eq(filter_created_at)); + } + if let Some(filter_updated_at) = filter.updated_at.clone() { + query = query.filter(crate::schema::todos::updated_at.eq(filter_updated_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -98,4 +137,30 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub unsigned: Option, + pub unsigned_nullable: Option>, + pub text: Option, + pub completed: Option, + pub type_: Option, + pub created_at: Option>, + pub updated_at: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + unsigned: None, + unsigned_nullable: None, + text: None, + completed: None, + type_: None, + created_at: None, + updated_at: None, + } + } +} diff --git a/test/simple_table_async/models/todos/generated.rs b/test/simple_table_async/models/todos/generated.rs index e75d4fb6..09482f02 100644 --- a/test/simple_table_async/models/todos/generated.rs +++ b/test/simple_table_async/models/todos/generated.rs @@ -63,24 +63,57 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db).await } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub async fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub async fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db).await?; - let items = todos.limit(page_size).offset(page * page_size).load::(db).await?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db).await?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_unsigned) = filter.unsigned.clone() { + query = query.filter(crate::schema::todos::unsigned.eq(filter_unsigned)); + } + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + if let Some(filter_completed) = filter.completed.clone() { + query = query.filter(crate::schema::todos::completed.eq(filter_completed)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::todos::created_at.eq(filter_created_at)); + } + if let Some(filter_updated_at) = filter.updated_at.clone() { + query = query.filter(crate::schema::todos::updated_at.eq(filter_updated_at)); + } + + query + } + pub async fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -93,4 +126,26 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db).await } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub unsigned: Option, + pub text: Option, + pub completed: Option, + pub created_at: Option>, + pub updated_at: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + unsigned: None, + text: None, + completed: None, + created_at: None, + updated_at: None, + } + } +} diff --git a/test/simple_table_custom_schema_path/models/todos/generated.rs b/test/simple_table_custom_schema_path/models/todos/generated.rs index faea7dd0..2f84a925 100644 --- a/test/simple_table_custom_schema_path/models/todos/generated.rs +++ b/test/simple_table_custom_schema_path/models/todos/generated.rs @@ -62,24 +62,57 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::data::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::data::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::data::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::data::schema::todos::id.eq(filter_id)); + } + if let Some(filter_unsigned) = filter.unsigned.clone() { + query = query.filter(crate::data::schema::todos::unsigned.eq(filter_unsigned)); + } + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::data::schema::todos::text.eq(filter_text)); + } + if let Some(filter_completed) = filter.completed.clone() { + query = query.filter(crate::data::schema::todos::completed.eq(filter_completed)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::data::schema::todos::created_at.eq(filter_created_at)); + } + if let Some(filter_updated_at) = filter.updated_at.clone() { + query = query.filter(crate::data::schema::todos::updated_at.eq(filter_updated_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::data::schema::todos::dsl::*; @@ -92,4 +125,26 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub unsigned: Option, + pub text: Option, + pub completed: Option, + pub created_at: Option>, + pub updated_at: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + unsigned: None, + text: None, + completed: None, + created_at: None, + updated_at: None, + } + } +} diff --git a/test/simple_table_no_serde/models/todos/generated.rs b/test/simple_table_no_serde/models/todos/generated.rs index 2e7676ea..af2db11b 100644 --- a/test/simple_table_no_serde/models/todos/generated.rs +++ b/test/simple_table_no_serde/models/todos/generated.rs @@ -62,24 +62,57 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = todos.count().get_result(db)?; - let items = todos.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: TodosFilter, + ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::todos::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::todos::id.eq(filter_id)); + } + if let Some(filter_unsigned) = filter.unsigned.clone() { + query = query.filter(crate::schema::todos::unsigned.eq(filter_unsigned)); + } + if let Some(filter_text) = filter.text.clone() { + query = query.filter(crate::schema::todos::text.eq(filter_text)); + } + if let Some(filter_completed) = filter.completed.clone() { + query = query.filter(crate::schema::todos::completed.eq(filter_completed)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::todos::created_at.eq(filter_created_at)); + } + if let Some(filter_updated_at) = filter.updated_at.clone() { + query = query.filter(crate::schema::todos::updated_at.eq(filter_updated_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: i32, item: &UpdateTodos) -> QueryResult { use crate::schema::todos::dsl::*; @@ -92,4 +125,26 @@ impl Todos { diesel::delete(todos.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct TodosFilter { + pub id: Option, + pub unsigned: Option, + pub text: Option, + pub completed: Option, + pub created_at: Option>, + pub updated_at: Option>, +} + +impl Default for TodosFilter { + fn default() -> TodosFilter { + TodosFilter { + id: None, + unsigned: None, + text: None, + completed: None, + created_at: None, + updated_at: None, + } + } +} diff --git a/test/single_model_file/models/table1.rs b/test/single_model_file/models/table1.rs index e202479b..e4673af0 100644 --- a/test/single_model_file/models/table1.rs +++ b/test/single_model_file/models/table1.rs @@ -41,28 +41,58 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table1.count().get_result(db)?; - let items = table1.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table1Filter, + ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table1::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table1::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table1::dsl::*; diesel::delete(table1.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table1Filter { + pub id: Option, +} + +impl Default for Table1Filter { + fn default() -> Table1Filter { + Table1Filter { + id: None, + } + } +} diff --git a/test/single_model_file/models/table2.rs b/test/single_model_file/models/table2.rs index f87ab9db..881e8f1e 100644 --- a/test/single_model_file/models/table2.rs +++ b/test/single_model_file/models/table2.rs @@ -41,28 +41,58 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = table2.count().get_result(db)?; - let items = table2.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: Table2Filter, + ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::table2::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::table2::id.eq(filter_id)); + } + + query + } + pub fn delete(db: &mut ConnectionType, param_id: crate::schema::sql_types::Int) -> QueryResult { use crate::schema::table2::dsl::*; diesel::delete(table2.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct Table2Filter { + pub id: Option, +} + +impl Default for Table2Filter { + fn default() -> Table2Filter { + Table2Filter { + id: None, + } + } +} diff --git a/test/use_statements/models/fang_tasks/generated.rs b/test/use_statements/models/fang_tasks/generated.rs index 7323a394..af8668a1 100644 --- a/test/use_statements/models/fang_tasks/generated.rs +++ b/test/use_statements/models/fang_tasks/generated.rs @@ -77,24 +77,69 @@ impl FangTasks { fang_tasks.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) - pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64) -> QueryResult> { + /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) + pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: FangTasksFilter) -> QueryResult> { use crate::schema::fang_tasks::dsl::*; - let page_size = if page_size < 1 { 1 } else { page_size }; - let total_items = fang_tasks.count().get_result(db)?; - let items = fang_tasks.limit(page_size).offset(page * page_size).load::(db)?; + let param_page = param_page_starting_with_1.max(0); + let param_page_size = param_page_size.max(1); + let total_items = Self::filter(filter.clone()).count().get_result(db)?; + let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page, - page_size, + page: param_page, + page_size: param_page_size, /* ceiling division of integers */ - num_pages: total_items / page_size + i64::from(total_items % page_size != 0) + num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) }) } + /// A utility function to help build custom search queries + /// + /// Example: + /// + pub fn filter<'a>( + filter: FangTasksFilter, + ) -> crate::schema::fang_tasks::BoxedQuery<'a, diesel::pg::Pg> { + let mut query = crate::schema::fang_tasks::table.into_boxed(); + + + if let Some(filter_id) = filter.id.clone() { + query = query.filter(crate::schema::fang_tasks::id.eq(filter_id)); + } + if let Some(filter_metadata) = filter.metadata.clone() { + query = query.filter(crate::schema::fang_tasks::metadata.eq(filter_metadata)); + } + if let Some(filter_error_message) = filter.error_message.clone() { + query = query.filter(crate::schema::fang_tasks::error_message.eq(filter_error_message)); + } + if let Some(filter_state) = filter.state.clone() { + query = query.filter(crate::schema::fang_tasks::state.eq(filter_state)); + } + if let Some(filter_task_type) = filter.task_type.clone() { + query = query.filter(crate::schema::fang_tasks::task_type.eq(filter_task_type)); + } + if let Some(filter_uniq_hash) = filter.uniq_hash.clone() { + query = query.filter(crate::schema::fang_tasks::uniq_hash.eq(filter_uniq_hash)); + } + if let Some(filter_retries) = filter.retries.clone() { + query = query.filter(crate::schema::fang_tasks::retries.eq(filter_retries)); + } + if let Some(filter_scheduled_at) = filter.scheduled_at.clone() { + query = query.filter(crate::schema::fang_tasks::scheduled_at.eq(filter_scheduled_at)); + } + if let Some(filter_created_at) = filter.created_at.clone() { + query = query.filter(crate::schema::fang_tasks::created_at.eq(filter_created_at)); + } + if let Some(filter_updated_at) = filter.updated_at.clone() { + query = query.filter(crate::schema::fang_tasks::updated_at.eq(filter_updated_at)); + } + + query + } + pub fn update(db: &mut ConnectionType, param_id: uuid::Uuid, item: &UpdateFangTasks) -> QueryResult { use crate::schema::fang_tasks::dsl::*; @@ -107,4 +152,34 @@ impl FangTasks { diesel::delete(fang_tasks.filter(id.eq(param_id))).execute(db) } -} \ No newline at end of file +} +#[derive(Clone)] +pub struct FangTasksFilter { + pub id: Option, + pub metadata: Option, + pub error_message: Option>, + pub state: Option, + pub task_type: Option, + pub uniq_hash: Option>, + pub retries: Option, + pub scheduled_at: Option>, + pub created_at: Option>, + pub updated_at: Option>, +} + +impl Default for FangTasksFilter { + fn default() -> FangTasksFilter { + FangTasksFilter { + id: None, + metadata: None, + error_message: None, + state: None, + task_type: None, + uniq_hash: None, + retries: None, + scheduled_at: None, + created_at: None, + updated_at: None, + } + } +} From 7d428b4e09abed220362bbded46a7f47f461f8b1 Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Mon, 30 Oct 2023 00:37:19 +0000 Subject: [PATCH 02/10] Update src/bin/main.rs Co-authored-by: hasezoey --- src/bin/main.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/bin/main.rs b/src/bin/main.rs index 4e8493bf..79b51b3c 100644 --- a/src/bin/main.rs +++ b/src/bin/main.rs @@ -104,7 +104,7 @@ pub struct MainOptions { pub once_connection_type: bool, /// Set which diesel backend to use (something which implements `diesel::backend::Backend`) - /// Deisel provides the following backends: + /// Diesel provides the following backends: /// - `diesel::pg::Pg` /// - `diesel::sqlite::Sqlite` /// - `diesel::mysql::Mysql` From 8afaa2e580a0fff81a178ead6f94e359ae350668 Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Mon, 30 Oct 2023 01:17:32 +0000 Subject: [PATCH 03/10] Update src/code.rs Co-authored-by: hasezoey --- src/code.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/code.rs b/src/code.rs index 4501cfc5..f9be2b9f 100644 --- a/src/code.rs +++ b/src/code.rs @@ -541,7 +541,7 @@ impl {struct_name} {{ .join("\n "); buffer.push_str(&format!( r##" -#[derive(Clone)] +#[derive(Debug, Clone)] pub struct {struct_name}Filter {{ {filter_fields} }} From 3acf838d8b40c726ac0c466f5e62ad891a09ef77 Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Mon, 30 Oct 2023 01:25:32 +0000 Subject: [PATCH 04/10] Update src/code.rs Co-authored-by: hasezoey --- src/code.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/code.rs b/src/code.rs index f9be2b9f..176eed21 100644 --- a/src/code.rs +++ b/src/code.rs @@ -469,7 +469,6 @@ impl {struct_name} {{ filter: {struct_name}Filter, ) -> {schema_path}{table_name}::BoxedQuery<'a, {diesel_backend}> {{ let mut query = {schema_path}{table_name}::table.into_boxed(); - {filters} query From 9bf6b67971e5957ba8fa09c3e61b83066759f924 Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Sun, 29 Oct 2023 20:56:04 -0400 Subject: [PATCH 05/10] Require diesel_backend to be set manually --- src/bin/main.rs | 4 +--- src/error.rs | 4 ++++ src/lib.rs | 22 +++++++++++++++++++ test/autogenerated_all/test.sh | 2 +- test/autogenerated_attributes/test.sh | 2 +- test/autogenerated_primary_keys/test.sh | 2 +- test/cleanup_generated_content/test.sh | 4 ++-- test/create_update_str_cow/test.sh | 2 +- test/create_update_str_str/test.sh | 2 +- test/custom_model_and_schema_path/test.sh | 2 +- test/custom_model_path/test.sh | 2 +- test/manual_primary_keys/test.sh | 2 +- test/multiple_primary_keys/test.sh | 2 +- test/once_common_structs/test.sh | 2 +- .../test.sh | 2 +- .../test.sh | 2 +- test/once_connection_type/test.sh | 2 +- test/simple_table/test.sh | 2 +- test/simple_table_async/test.sh | 2 +- test/simple_table_custom_schema_path/test.sh | 2 +- test/simple_table_no_crud/test.sh | 2 +- test/simple_table_no_serde/test.sh | 2 +- test/single_model_file/test.sh | 2 +- test/use_statements/test.sh | 2 +- 24 files changed, 49 insertions(+), 25 deletions(-) diff --git a/src/bin/main.rs b/src/bin/main.rs index 79b51b3c..e6b0a9d8 100644 --- a/src/bin/main.rs +++ b/src/bin/main.rs @@ -110,9 +110,7 @@ pub struct MainOptions { /// - `diesel::mysql::Mysql` /// /// See `crate::GenerationConfig::diesel_backend` for more details. - /// - /// Default is "diesel::pg::Pg" - #[arg(long = "diesel-backend", default_value = "diesel::pg::Pg")] + #[arg(short = 'b', long = "diesel-backend")] pub diesel_backend: String, } diff --git a/src/error.rs b/src/error.rs index 45fe4bd9..79db1dad 100644 --- a/src/error.rs +++ b/src/error.rs @@ -122,6 +122,10 @@ pub enum ErrorEnum { #[error("NoFileSignature: {0}")] NoFileSignature(String), + /// Invalid generation config + #[error("InvalidGenerationConfig: {0}")] + InvalidGenerationConfig(String), + /// Variant for Other messages #[error("Other: {0}")] Other(String), diff --git a/src/lib.rs b/src/lib.rs index 0fc0c769..b25af4e1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -12,6 +12,8 @@ use std::collections::HashMap; use std::fmt::Display; use std::path::{Path, PathBuf}; +use crate::error::ErrorEnum; + #[derive(Debug, Clone, Copy, PartialEq, Default)] pub enum StringType { /// Use "String" @@ -321,6 +323,24 @@ impl From<&MarkedFile> for FileChange { } } +pub fn validate_config(config: &GenerationConfig) -> Result<()> { + const VALID_BACKENDS: [&str; 3] = [ + "diesel::pg::Pg", + "diesel::sqlite::Sqlite", + "diesel::mysql::Mysql", + ]; + + if !VALID_BACKENDS.contains(&config.diesel_backend.as_str()) { + return Err(Error::new(ErrorEnum::InvalidGenerationConfig(format!( + "Invalid diesel_backend '{}', please use one of the following: {:?}", + &config.diesel_backend, + VALID_BACKENDS.clone().join(", ") + )))); + } + + Ok(()) +} + /// Generate all Models for a given diesel schema file /// /// Models are saved to disk @@ -329,6 +349,8 @@ pub fn generate_files( output_models_dir: &Path, config: GenerationConfig, ) -> Result> { + validate_config(&config)?; + let generated = generate_code( &std::fs::read_to_string(input_diesel_schema_file) .attach_path_err(input_diesel_schema_file)?, diff --git a/test/autogenerated_all/test.sh b/test/autogenerated_all/test.sh index a1a75e04..b0d3d4ac 100755 --- a/test/autogenerated_all/test.sh +++ b/test/autogenerated_all/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g id -g created_at -c "diesel::r2d2::PooledConnection>" \ No newline at end of file +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g id -g created_at -c "diesel::r2d2::PooledConnection>" \ No newline at end of file diff --git a/test/autogenerated_attributes/test.sh b/test/autogenerated_attributes/test.sh index dc42cea4..d7d8fdff 100755 --- a/test/autogenerated_attributes/test.sh +++ b/test/autogenerated_attributes/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g created_at -c "diesel::r2d2::PooledConnection>" \ No newline at end of file +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g created_at -c "diesel::r2d2::PooledConnection>" \ No newline at end of file diff --git a/test/autogenerated_primary_keys/test.sh b/test/autogenerated_primary_keys/test.sh index 3e1a5730..5be7312b 100755 --- a/test/autogenerated_primary_keys/test.sh +++ b/test/autogenerated_primary_keys/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g id -c "diesel::r2d2::PooledConnection>" +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g id -c "diesel::r2d2::PooledConnection>" diff --git a/test/cleanup_generated_content/test.sh b/test/cleanup_generated_content/test.sh index b46239f9..fb17fd1b 100755 --- a/test/cleanup_generated_content/test.sh +++ b/test/cleanup_generated_content/test.sh @@ -4,5 +4,5 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema1.rs -o models -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" -cargo run -- -i schema2.rs -o models -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" \ No newline at end of file +cargo run -- -b diesel::pg::Pg -i schema1.rs -o models -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" +cargo run -- -b diesel::pg::Pg -i schema2.rs -o models -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" \ No newline at end of file diff --git a/test/create_update_str_cow/test.sh b/test/create_update_str_cow/test.sh index d78c05b7..188e5758 100755 --- a/test/create_update_str_cow/test.sh +++ b/test/create_update_str_cow/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --create-str=cow --update-str=cow +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --create-str=cow --update-str=cow diff --git a/test/create_update_str_str/test.sh b/test/create_update_str_str/test.sh index 7a2223e6..0c79e9eb 100755 --- a/test/create_update_str_str/test.sh +++ b/test/create_update_str_str/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --create-str=str --update-str=str +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --create-str=str --update-str=str diff --git a/test/custom_model_and_schema_path/test.sh b/test/custom_model_and_schema_path/test.sh index be6266be..663e20e5 100755 --- a/test/custom_model_and_schema_path/test.sh +++ b/test/custom_model_and_schema_path/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i data/schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --schema-path "crate::data::schema::" --model-path "crate::data::models::" +cargo run -- -b diesel::pg::Pg -i data/schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --schema-path "crate::data::schema::" --model-path "crate::data::models::" diff --git a/test/custom_model_path/test.sh b/test/custom_model_path/test.sh index a32e2ec6..b9a4483b 100755 --- a/test/custom_model_path/test.sh +++ b/test/custom_model_path/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --model-path "crate::data::models::" +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --model-path "crate::data::models::" diff --git a/test/manual_primary_keys/test.sh b/test/manual_primary_keys/test.sh index f85a3968..5559e283 100755 --- a/test/manual_primary_keys/test.sh +++ b/test/manual_primary_keys/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -c "diesel::r2d2::PooledConnection>" \ No newline at end of file +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -c "diesel::r2d2::PooledConnection>" \ No newline at end of file diff --git a/test/multiple_primary_keys/test.sh b/test/multiple_primary_keys/test.sh index f85a3968..5559e283 100755 --- a/test/multiple_primary_keys/test.sh +++ b/test/multiple_primary_keys/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -c "diesel::r2d2::PooledConnection>" \ No newline at end of file +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -c "diesel::r2d2::PooledConnection>" \ No newline at end of file diff --git a/test/once_common_structs/test.sh b/test/once_common_structs/test.sh index 6066b36f..59360e2b 100755 --- a/test/once_common_structs/test.sh +++ b/test/once_common_structs/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --once-common-structs +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --once-common-structs diff --git a/test/once_common_structs_once_connection_type/test.sh b/test/once_common_structs_once_connection_type/test.sh index 5f071b8e..0d4d4199 100755 --- a/test/once_common_structs_once_connection_type/test.sh +++ b/test/once_common_structs_once_connection_type/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --once-common-structs --once-connection-type +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --once-common-structs --once-connection-type diff --git a/test/once_common_structs_once_connection_type_single_file/test.sh b/test/once_common_structs_once_connection_type_single_file/test.sh index 56361b1b..a0996d64 100755 --- a/test/once_common_structs_once_connection_type_single_file/test.sh +++ b/test/once_common_structs_once_connection_type_single_file/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --once-common-structs --once-connection-type --single-model-file +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --once-common-structs --once-connection-type --single-model-file diff --git a/test/once_connection_type/test.sh b/test/once_connection_type/test.sh index 7bd0ac91..a6ef6fea 100755 --- a/test/once_connection_type/test.sh +++ b/test/once_connection_type/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --once-connection-type +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --once-connection-type diff --git a/test/simple_table/test.sh b/test/simple_table/test.sh index acf5dbde..eae23b32 100755 --- a/test/simple_table/test.sh +++ b/test/simple_table/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" \ No newline at end of file +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" \ No newline at end of file diff --git a/test/simple_table_async/test.sh b/test/simple_table_async/test.sh index 220d311e..37c74039 100755 --- a/test/simple_table_async/test.sh +++ b/test/simple_table_async/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run --features async -- -i schema.rs -o models -g id -g created_at -g updated_at -c "diesel_async::pooled_connection::deadpool::Object" --async \ No newline at end of file +cargo run --features async -- -b diesel::pg::Pg -i schema.rs -o models -g id -g created_at -g updated_at -c "diesel_async::pooled_connection::deadpool::Object" --async \ No newline at end of file diff --git a/test/simple_table_custom_schema_path/test.sh b/test/simple_table_custom_schema_path/test.sh index e5a2214a..9fae16f9 100755 --- a/test/simple_table_custom_schema_path/test.sh +++ b/test/simple_table_custom_schema_path/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i data/schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --schema-path "crate::data::schema::" +cargo run -- -b diesel::pg::Pg -i data/schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --schema-path "crate::data::schema::" diff --git a/test/simple_table_no_crud/test.sh b/test/simple_table_no_crud/test.sh index cdfdf0e7..0dc4b294 100755 --- a/test/simple_table_no_crud/test.sh +++ b/test/simple_table_no_crud/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --no-crud +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --no-crud diff --git a/test/simple_table_no_serde/test.sh b/test/simple_table_no_serde/test.sh index b66ccd9d..44641008 100755 --- a/test/simple_table_no_serde/test.sh +++ b/test/simple_table_no_serde/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --no-serde +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --no-serde diff --git a/test/single_model_file/test.sh b/test/single_model_file/test.sh index 78fec084..c84f8dec 100755 --- a/test/single_model_file/test.sh +++ b/test/single_model_file/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --single-model-file +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -g id -g created_at -g updated_at -c "diesel::r2d2::PooledConnection>" --single-model-file diff --git a/test/use_statements/test.sh b/test/use_statements/test.sh index f85a3968..5559e283 100755 --- a/test/use_statements/test.sh +++ b/test/use_statements/test.sh @@ -4,4 +4,4 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )" cd $SCRIPT_DIR -cargo run -- -i schema.rs -o models -c "diesel::r2d2::PooledConnection>" \ No newline at end of file +cargo run -- -i schema.rs -b diesel::pg::Pg -o models -c "diesel::r2d2::PooledConnection>" \ No newline at end of file From f57471cf2c3f41bcdb4fb71fc41963a209236086 Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Sun, 29 Oct 2023 21:04:18 -0400 Subject: [PATCH 06/10] Update param_page_* to page_* --- src/code.rs | 12 ++++++------ test/autogenerated_all/models/todos/generated.rs | 12 ++++++------ .../models/todos/generated.rs | 12 ++++++------ .../models/todos/generated.rs | 12 ++++++------ .../models/todos/generated.rs | 12 ++++++------ test/create_update_str_cow/models/todos/generated.rs | 12 ++++++------ test/create_update_str_str/models/todos/generated.rs | 12 ++++++------ .../models/tableA/generated.rs | 12 ++++++------ .../models/tableB/generated.rs | 12 ++++++------ test/custom_model_path/models/tableA/generated.rs | 12 ++++++------ test/custom_model_path/models/tableB/generated.rs | 12 ++++++------ test/manual_primary_keys/models/todos/generated.rs | 12 ++++++------ test/multiple_primary_keys/models/users/generated.rs | 12 ++++++------ test/once_common_structs/models/table1/generated.rs | 12 ++++++------ test/once_common_structs/models/table2/generated.rs | 12 ++++++------ .../models/table1/generated.rs | 12 ++++++------ .../models/table2/generated.rs | 12 ++++++------ .../models/table1.rs | 12 ++++++------ .../models/table2.rs | 12 ++++++------ test/once_connection_type/models/table1/generated.rs | 12 ++++++------ test/once_connection_type/models/table2/generated.rs | 12 ++++++------ test/simple_table/models/todos/generated.rs | 12 ++++++------ test/simple_table_async/models/todos/generated.rs | 12 ++++++------ .../models/todos/generated.rs | 12 ++++++------ test/simple_table_no_serde/models/todos/generated.rs | 12 ++++++------ test/single_model_file/models/table1.rs | 12 ++++++------ test/single_model_file/models/table2.rs | 12 ++++++------ test/use_statements/models/fang_tasks/generated.rs | 12 ++++++------ 28 files changed, 168 insertions(+), 168 deletions(-) diff --git a/src/code.rs b/src/code.rs index 176eed21..f4cb9caf 100644 --- a/src/code.rs +++ b/src/code.rs @@ -423,21 +423,21 @@ impl {struct_name} {{ buffer.push_str(&format!(r##" /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub{async_keyword} fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: {struct_name}Filter) -> QueryResult> {{ + pub{async_keyword} fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: {struct_name}Filter) -> QueryResult> {{ use {schema_path}{table_name}::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db){await_keyword}?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db){await_keyword}?; Ok(PaginationResult {{ items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }}) }} "##)); diff --git a/test/autogenerated_all/models/todos/generated.rs b/test/autogenerated_all/models/todos/generated.rs index 9a75dae0..650e3436 100644 --- a/test/autogenerated_all/models/todos/generated.rs +++ b/test/autogenerated_all/models/todos/generated.rs @@ -48,21 +48,21 @@ impl Todos { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/autogenerated_attributes/models/todos/generated.rs b/test/autogenerated_attributes/models/todos/generated.rs index bf66d653..1b92d2bb 100644 --- a/test/autogenerated_attributes/models/todos/generated.rs +++ b/test/autogenerated_attributes/models/todos/generated.rs @@ -53,21 +53,21 @@ impl Todos { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/autogenerated_primary_keys/models/todos/generated.rs b/test/autogenerated_primary_keys/models/todos/generated.rs index 040f0d36..8d544de7 100644 --- a/test/autogenerated_primary_keys/models/todos/generated.rs +++ b/test/autogenerated_primary_keys/models/todos/generated.rs @@ -53,21 +53,21 @@ impl Todos { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/cleanup_generated_content/models/todos/generated.rs b/test/cleanup_generated_content/models/todos/generated.rs index 96eee3da..b3e8142b 100644 --- a/test/cleanup_generated_content/models/todos/generated.rs +++ b/test/cleanup_generated_content/models/todos/generated.rs @@ -61,21 +61,21 @@ impl Todos { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/create_update_str_cow/models/todos/generated.rs b/test/create_update_str_cow/models/todos/generated.rs index 06700656..6f36a2ca 100644 --- a/test/create_update_str_cow/models/todos/generated.rs +++ b/test/create_update_str_cow/models/todos/generated.rs @@ -60,21 +60,21 @@ impl Todos { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/create_update_str_str/models/todos/generated.rs b/test/create_update_str_str/models/todos/generated.rs index 986b149a..d4680dad 100644 --- a/test/create_update_str_str/models/todos/generated.rs +++ b/test/create_update_str_str/models/todos/generated.rs @@ -60,21 +60,21 @@ impl Todos { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/custom_model_and_schema_path/models/tableA/generated.rs b/test/custom_model_and_schema_path/models/tableA/generated.rs index 70bf9ab8..16f2a75a 100644 --- a/test/custom_model_and_schema_path/models/tableA/generated.rs +++ b/test/custom_model_and_schema_path/models/tableA/generated.rs @@ -47,21 +47,21 @@ impl TableA { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TableAFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TableAFilter) -> QueryResult> { use crate::data::schema::tableA::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/custom_model_and_schema_path/models/tableB/generated.rs b/test/custom_model_and_schema_path/models/tableB/generated.rs index 604827c3..562fdd96 100644 --- a/test/custom_model_and_schema_path/models/tableB/generated.rs +++ b/test/custom_model_and_schema_path/models/tableB/generated.rs @@ -54,21 +54,21 @@ impl TableB { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TableBFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TableBFilter) -> QueryResult> { use crate::data::schema::tableB::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/custom_model_path/models/tableA/generated.rs b/test/custom_model_path/models/tableA/generated.rs index 149490b8..ec4352b3 100644 --- a/test/custom_model_path/models/tableA/generated.rs +++ b/test/custom_model_path/models/tableA/generated.rs @@ -47,21 +47,21 @@ impl TableA { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TableAFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TableAFilter) -> QueryResult> { use crate::schema::tableA::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/custom_model_path/models/tableB/generated.rs b/test/custom_model_path/models/tableB/generated.rs index 3244c59e..5bc5263f 100644 --- a/test/custom_model_path/models/tableB/generated.rs +++ b/test/custom_model_path/models/tableB/generated.rs @@ -54,21 +54,21 @@ impl TableB { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TableBFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TableBFilter) -> QueryResult> { use crate::schema::tableB::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/manual_primary_keys/models/todos/generated.rs b/test/manual_primary_keys/models/todos/generated.rs index 82cca02f..9367a89f 100644 --- a/test/manual_primary_keys/models/todos/generated.rs +++ b/test/manual_primary_keys/models/todos/generated.rs @@ -47,21 +47,21 @@ impl Todos { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/multiple_primary_keys/models/users/generated.rs b/test/multiple_primary_keys/models/users/generated.rs index 84054340..6e1571aa 100644 --- a/test/multiple_primary_keys/models/users/generated.rs +++ b/test/multiple_primary_keys/models/users/generated.rs @@ -56,21 +56,21 @@ impl Users { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: UsersFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: UsersFilter) -> QueryResult> { use crate::schema::users::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/once_common_structs/models/table1/generated.rs b/test/once_common_structs/models/table1/generated.rs index 7c785853..3e2d6385 100644 --- a/test/once_common_structs/models/table1/generated.rs +++ b/test/once_common_structs/models/table1/generated.rs @@ -33,21 +33,21 @@ impl Table1 { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/once_common_structs/models/table2/generated.rs b/test/once_common_structs/models/table2/generated.rs index c8d168f6..c30a5924 100644 --- a/test/once_common_structs/models/table2/generated.rs +++ b/test/once_common_structs/models/table2/generated.rs @@ -33,21 +33,21 @@ impl Table2 { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/once_common_structs_once_connection_type/models/table1/generated.rs b/test/once_common_structs_once_connection_type/models/table1/generated.rs index 18b78dbb..c4b94daf 100644 --- a/test/once_common_structs_once_connection_type/models/table1/generated.rs +++ b/test/once_common_structs_once_connection_type/models/table1/generated.rs @@ -30,21 +30,21 @@ impl Table1 { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/once_common_structs_once_connection_type/models/table2/generated.rs b/test/once_common_structs_once_connection_type/models/table2/generated.rs index 4c296f08..16c6d336 100644 --- a/test/once_common_structs_once_connection_type/models/table2/generated.rs +++ b/test/once_common_structs_once_connection_type/models/table2/generated.rs @@ -30,21 +30,21 @@ impl Table2 { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/once_common_structs_once_connection_type_single_file/models/table1.rs b/test/once_common_structs_once_connection_type_single_file/models/table1.rs index 18b78dbb..c4b94daf 100644 --- a/test/once_common_structs_once_connection_type_single_file/models/table1.rs +++ b/test/once_common_structs_once_connection_type_single_file/models/table1.rs @@ -30,21 +30,21 @@ impl Table1 { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/once_common_structs_once_connection_type_single_file/models/table2.rs b/test/once_common_structs_once_connection_type_single_file/models/table2.rs index 4c296f08..16c6d336 100644 --- a/test/once_common_structs_once_connection_type_single_file/models/table2.rs +++ b/test/once_common_structs_once_connection_type_single_file/models/table2.rs @@ -30,21 +30,21 @@ impl Table2 { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/once_connection_type/models/table1/generated.rs b/test/once_connection_type/models/table1/generated.rs index c8c5bbc1..b48c8f97 100644 --- a/test/once_connection_type/models/table1/generated.rs +++ b/test/once_connection_type/models/table1/generated.rs @@ -40,21 +40,21 @@ impl Table1 { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/once_connection_type/models/table2/generated.rs b/test/once_connection_type/models/table2/generated.rs index 5a8d92d7..8f87673a 100644 --- a/test/once_connection_type/models/table2/generated.rs +++ b/test/once_connection_type/models/table2/generated.rs @@ -40,21 +40,21 @@ impl Table2 { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/simple_table/models/todos/generated.rs b/test/simple_table/models/todos/generated.rs index 154b2050..9a766ed1 100644 --- a/test/simple_table/models/todos/generated.rs +++ b/test/simple_table/models/todos/generated.rs @@ -69,21 +69,21 @@ impl Todos { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/simple_table_async/models/todos/generated.rs b/test/simple_table_async/models/todos/generated.rs index 09482f02..e710bcec 100644 --- a/test/simple_table_async/models/todos/generated.rs +++ b/test/simple_table_async/models/todos/generated.rs @@ -64,21 +64,21 @@ impl Todos { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub async fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { + pub async fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db).await?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db).await?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/simple_table_custom_schema_path/models/todos/generated.rs b/test/simple_table_custom_schema_path/models/todos/generated.rs index 2f84a925..959a9613 100644 --- a/test/simple_table_custom_schema_path/models/todos/generated.rs +++ b/test/simple_table_custom_schema_path/models/todos/generated.rs @@ -63,21 +63,21 @@ impl Todos { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::data::schema::todos::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/simple_table_no_serde/models/todos/generated.rs b/test/simple_table_no_serde/models/todos/generated.rs index af2db11b..50420a50 100644 --- a/test/simple_table_no_serde/models/todos/generated.rs +++ b/test/simple_table_no_serde/models/todos/generated.rs @@ -63,21 +63,21 @@ impl Todos { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: TodosFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/single_model_file/models/table1.rs b/test/single_model_file/models/table1.rs index e4673af0..ed6fc7e7 100644 --- a/test/single_model_file/models/table1.rs +++ b/test/single_model_file/models/table1.rs @@ -42,21 +42,21 @@ impl Table1 { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table1Filter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/single_model_file/models/table2.rs b/test/single_model_file/models/table2.rs index 881e8f1e..ceb50a95 100644 --- a/test/single_model_file/models/table2.rs +++ b/test/single_model_file/models/table2.rs @@ -42,21 +42,21 @@ impl Table2 { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: Table2Filter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } diff --git a/test/use_statements/models/fang_tasks/generated.rs b/test/use_statements/models/fang_tasks/generated.rs index af8668a1..aad71372 100644 --- a/test/use_statements/models/fang_tasks/generated.rs +++ b/test/use_statements/models/fang_tasks/generated.rs @@ -78,21 +78,21 @@ impl FangTasks { } /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, param_page_starting_with_1: i64, param_page_size: i64, filter: FangTasksFilter) -> QueryResult> { + pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: FangTasksFilter) -> QueryResult> { use crate::schema::fang_tasks::dsl::*; - let param_page = param_page_starting_with_1.max(0); - let param_page_size = param_page_size.max(1); + let param_page = page_starting_with_1.max(0); + let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(param_page_size).offset(param_page * param_page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, page: param_page, - page_size: param_page_size, + page_size: page_size, /* ceiling division of integers */ - num_pages: total_items / param_page_size + i64::from(total_items % param_page_size != 0) + num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) } From 7518fa18911cd4b836fc8888c6a177b967bef21b Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Sun, 29 Oct 2023 21:08:01 -0400 Subject: [PATCH 07/10] Move back to 0-based page param --- src/code.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/code.rs b/src/code.rs index f4cb9caf..a3d7c28e 100644 --- a/src/code.rs +++ b/src/code.rs @@ -422,20 +422,20 @@ impl {struct_name} {{ )); buffer.push_str(&format!(r##" - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub{async_keyword} fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: {struct_name}Filter) -> QueryResult> {{ + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub{async_keyword} fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: {struct_name}Filter) -> QueryResult> {{ use {schema_path}{table_name}::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db){await_keyword}?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db){await_keyword}?; Ok(PaginationResult {{ items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }}) From c049d342d75a286620e7bd78a8e68ecc6840a5df Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Sun, 29 Oct 2023 21:14:36 -0400 Subject: [PATCH 08/10] Add example in doc comment --- src/code.rs | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/code.rs b/src/code.rs index a3d7c28e..b387dd5b 100644 --- a/src/code.rs +++ b/src/code.rs @@ -444,7 +444,7 @@ impl {struct_name} {{ // Table::filter() helper fn { - let diesel_backend = config.diesel_backend.clone(); + let diesel_backend = &config.diesel_backend; let filters = table .columns .iter() @@ -465,6 +465,16 @@ impl {struct_name} {{ /// /// Example: /// + /// ```rust + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter {{ + /// completed: Some(true), + /// ..Default::default() + /// }}); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: {struct_name}Filter, ) -> {schema_path}{table_name}::BoxedQuery<'a, {diesel_backend}> {{ From 92697c88f98233725dfc08cb2ed6eb10b7bc9472 Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Wed, 1 Nov 2023 19:48:03 -0400 Subject: [PATCH 09/10] Address comments --- src/code.rs | 48 ++++++------------- src/lib.rs | 4 +- .../models/todos/generated.rs | 34 ++++++------- .../models/todos/generated.rs | 34 ++++++------- .../models/todos/generated.rs | 34 ++++++------- .../models/todos/generated.rs | 37 +++++++------- .../models/todos/generated.rs | 36 +++++++------- .../models/todos/generated.rs | 36 +++++++------- .../models/tableA/generated.rs | 33 ++++++------- .../models/tableB/generated.rs | 34 ++++++------- .../models/tableA/generated.rs | 33 ++++++------- .../models/tableB/generated.rs | 34 ++++++------- .../models/todos/generated.rs | 33 ++++++------- .../models/users/generated.rs | 35 +++++++------- .../models/table1/generated.rs | 33 ++++++------- .../models/table2/generated.rs | 33 ++++++------- .../models/table1/generated.rs | 33 ++++++------- .../models/table2/generated.rs | 33 ++++++------- .../models/table1.rs | 33 ++++++------- .../models/table2.rs | 33 ++++++------- .../models/table1/generated.rs | 33 ++++++------- .../models/table2/generated.rs | 33 ++++++------- test/simple_table/models/todos/generated.rs | 44 ++++++++--------- .../models/todos/generated.rs | 40 +++++++--------- .../models/todos/generated.rs | 40 +++++++--------- .../models/todos/generated.rs | 40 +++++++--------- test/single_model_file/models/table1.rs | 33 ++++++------- test/single_model_file/models/table2.rs | 33 ++++++------- .../models/fang_tasks/generated.rs | 42 +++++++--------- 29 files changed, 480 insertions(+), 521 deletions(-) diff --git a/src/code.rs b/src/code.rs index b387dd5b..9021e8e9 100644 --- a/src/code.rs +++ b/src/code.rs @@ -465,16 +465,16 @@ impl {struct_name} {{ /// /// Example: /// - /// ```rust - /// // create a filter for completed todos - /// let query = Todo::filter(TodoFilter {{ - /// completed: Some(true), - /// ..Default::default() - /// }}); + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter {{ + /// completed: Some(true), + /// ..Default::default() + /// }}); /// - /// // delete completed todos - /// diesel::delete(query).execute(db)?; - /// ``` + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: {struct_name}Filter, ) -> {schema_path}{table_name}::BoxedQuery<'a, {diesel_backend}> {{ @@ -526,42 +526,22 @@ impl {struct_name} {{ .columns .iter() .map(|column| { - let column_name = column.name.to_string(); + let struct_field = StructField::from(column); format!( "pub {column_name}: Option<{column_type}>,", - column_name = column_name, - column_type = if column.is_nullable { - format!("Option<{}>", column.ty) - } else { - column.ty.clone() - } + column_name = struct_field.name, + column_type = struct_field.to_rust_type() ) }) .collect::>() .join("\n "); - let filter_fields_default = table - .columns - .iter() - .map(|column| { - let column_name = column.name.to_string(); - format!("{column_name}: None,") - }) - .collect::>() - .join("\n "); + buffer.push_str(&format!( r##" -#[derive(Debug, Clone)] +#[derive(Debug, Default, Clone)] pub struct {struct_name}Filter {{ {filter_fields} }} - -impl Default for {struct_name}Filter {{ - fn default() -> {struct_name}Filter {{ - {struct_name}Filter {{ - {filter_fields_default} - }} - }} -}} "## )); } diff --git a/src/lib.rs b/src/lib.rs index b25af4e1..f5b0223f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -330,9 +330,9 @@ pub fn validate_config(config: &GenerationConfig) -> Result<()> { "diesel::mysql::Mysql", ]; - if !VALID_BACKENDS.contains(&config.diesel_backend.as_str()) { + if config.diesel_backend.is_empty() { return Err(Error::new(ErrorEnum::InvalidGenerationConfig(format!( - "Invalid diesel_backend '{}', please use one of the following: {:?}", + "Invalid diesel_backend '{}', please use one of the following: {:?}; or, a custom diesel backend type (a struct which implements `diesel::backend::Backend`).", &config.diesel_backend, VALID_BACKENDS.clone().join(", ") )))); diff --git a/test/autogenerated_all/models/todos/generated.rs b/test/autogenerated_all/models/todos/generated.rs index 650e3436..5162e02a 100644 --- a/test/autogenerated_all/models/todos/generated.rs +++ b/test/autogenerated_all/models/todos/generated.rs @@ -47,20 +47,20 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -70,12 +70,21 @@ impl Todos { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TodosFilter, ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::todos::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::todos::id.eq(filter_id)); } @@ -99,17 +108,8 @@ impl Todos { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TodosFilter { pub id: Option, pub created_at: Option, } - -impl Default for TodosFilter { - fn default() -> TodosFilter { - TodosFilter { - id: None, - created_at: None, - } - } -} diff --git a/test/autogenerated_attributes/models/todos/generated.rs b/test/autogenerated_attributes/models/todos/generated.rs index 1b92d2bb..a699496e 100644 --- a/test/autogenerated_attributes/models/todos/generated.rs +++ b/test/autogenerated_attributes/models/todos/generated.rs @@ -52,20 +52,20 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -75,12 +75,21 @@ impl Todos { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TodosFilter, ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::todos::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::todos::id.eq(filter_id)); } @@ -104,17 +113,8 @@ impl Todos { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TodosFilter { pub id: Option, pub created_at: Option, } - -impl Default for TodosFilter { - fn default() -> TodosFilter { - TodosFilter { - id: None, - created_at: None, - } - } -} diff --git a/test/autogenerated_primary_keys/models/todos/generated.rs b/test/autogenerated_primary_keys/models/todos/generated.rs index 8d544de7..4d5b598e 100644 --- a/test/autogenerated_primary_keys/models/todos/generated.rs +++ b/test/autogenerated_primary_keys/models/todos/generated.rs @@ -52,20 +52,20 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -75,12 +75,21 @@ impl Todos { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TodosFilter, ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::todos::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::todos::id.eq(filter_id)); } @@ -104,17 +113,8 @@ impl Todos { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TodosFilter { pub id: Option, pub text: Option, } - -impl Default for TodosFilter { - fn default() -> TodosFilter { - TodosFilter { - id: None, - text: None, - } - } -} diff --git a/test/cleanup_generated_content/models/todos/generated.rs b/test/cleanup_generated_content/models/todos/generated.rs index b3e8142b..2ec182c3 100644 --- a/test/cleanup_generated_content/models/todos/generated.rs +++ b/test/cleanup_generated_content/models/todos/generated.rs @@ -60,20 +60,20 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -83,12 +83,21 @@ impl Todos { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TodosFilter, ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::todos::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::todos::id.eq(filter_id)); } @@ -121,7 +130,7 @@ impl Todos { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TodosFilter { pub id: Option, pub text: Option, @@ -129,15 +138,3 @@ pub struct TodosFilter { pub created_at: Option>, pub updated_at: Option>, } - -impl Default for TodosFilter { - fn default() -> TodosFilter { - TodosFilter { - id: None, - text: None, - completed: None, - created_at: None, - updated_at: None, - } - } -} diff --git a/test/create_update_str_cow/models/todos/generated.rs b/test/create_update_str_cow/models/todos/generated.rs index 6f36a2ca..65187a73 100644 --- a/test/create_update_str_cow/models/todos/generated.rs +++ b/test/create_update_str_cow/models/todos/generated.rs @@ -59,20 +59,20 @@ impl Todos { todos.filter(text.eq(param_text)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -82,12 +82,21 @@ impl Todos { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TodosFilter, ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::todos::table.into_boxed(); - if let Some(filter_text) = filter.text.clone() { query = query.filter(crate::schema::todos::text.eq(filter_text)); } @@ -117,21 +126,10 @@ impl Todos { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TodosFilter { pub text: Option, pub text_nullable: Option>, pub varchar: Option, pub varchar_nullable: Option>, } - -impl Default for TodosFilter { - fn default() -> TodosFilter { - TodosFilter { - text: None, - text_nullable: None, - varchar: None, - varchar_nullable: None, - } - } -} diff --git a/test/create_update_str_str/models/todos/generated.rs b/test/create_update_str_str/models/todos/generated.rs index d4680dad..870c8074 100644 --- a/test/create_update_str_str/models/todos/generated.rs +++ b/test/create_update_str_str/models/todos/generated.rs @@ -59,20 +59,20 @@ impl Todos { todos.filter(text.eq(param_text)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -82,12 +82,21 @@ impl Todos { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TodosFilter, ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::todos::table.into_boxed(); - if let Some(filter_text) = filter.text.clone() { query = query.filter(crate::schema::todos::text.eq(filter_text)); } @@ -117,21 +126,10 @@ impl Todos { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TodosFilter { pub text: Option, pub text_nullable: Option>, pub varchar: Option, pub varchar_nullable: Option>, } - -impl Default for TodosFilter { - fn default() -> TodosFilter { - TodosFilter { - text: None, - text_nullable: None, - varchar: None, - varchar_nullable: None, - } - } -} diff --git a/test/custom_model_and_schema_path/models/tableA/generated.rs b/test/custom_model_and_schema_path/models/tableA/generated.rs index 16f2a75a..628375f3 100644 --- a/test/custom_model_and_schema_path/models/tableA/generated.rs +++ b/test/custom_model_and_schema_path/models/tableA/generated.rs @@ -46,20 +46,20 @@ impl TableA { tableA.filter(_id.eq(param__id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TableAFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TableAFilter) -> QueryResult> { use crate::data::schema::tableA::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -69,12 +69,21 @@ impl TableA { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TableAFilter, ) -> crate::data::schema::tableA::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::data::schema::tableA::table.into_boxed(); - if let Some(filter__id) = filter._id.clone() { query = query.filter(crate::data::schema::tableA::_id.eq(filter__id)); } @@ -89,15 +98,7 @@ impl TableA { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TableAFilter { pub _id: Option, } - -impl Default for TableAFilter { - fn default() -> TableAFilter { - TableAFilter { - _id: None, - } - } -} diff --git a/test/custom_model_and_schema_path/models/tableB/generated.rs b/test/custom_model_and_schema_path/models/tableB/generated.rs index 562fdd96..103a9310 100644 --- a/test/custom_model_and_schema_path/models/tableB/generated.rs +++ b/test/custom_model_and_schema_path/models/tableB/generated.rs @@ -53,20 +53,20 @@ impl TableB { tableB.filter(_id.eq(param__id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TableBFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TableBFilter) -> QueryResult> { use crate::data::schema::tableB::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -76,12 +76,21 @@ impl TableB { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TableBFilter, ) -> crate::data::schema::tableB::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::data::schema::tableB::table.into_boxed(); - if let Some(filter__id) = filter._id.clone() { query = query.filter(crate::data::schema::tableB::_id.eq(filter__id)); } @@ -105,17 +114,8 @@ impl TableB { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TableBFilter { pub _id: Option, pub link: Option, } - -impl Default for TableBFilter { - fn default() -> TableBFilter { - TableBFilter { - _id: None, - link: None, - } - } -} diff --git a/test/custom_model_path/models/tableA/generated.rs b/test/custom_model_path/models/tableA/generated.rs index ec4352b3..9f53e725 100644 --- a/test/custom_model_path/models/tableA/generated.rs +++ b/test/custom_model_path/models/tableA/generated.rs @@ -46,20 +46,20 @@ impl TableA { tableA.filter(_id.eq(param__id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TableAFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TableAFilter) -> QueryResult> { use crate::schema::tableA::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -69,12 +69,21 @@ impl TableA { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TableAFilter, ) -> crate::schema::tableA::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::tableA::table.into_boxed(); - if let Some(filter__id) = filter._id.clone() { query = query.filter(crate::schema::tableA::_id.eq(filter__id)); } @@ -89,15 +98,7 @@ impl TableA { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TableAFilter { pub _id: Option, } - -impl Default for TableAFilter { - fn default() -> TableAFilter { - TableAFilter { - _id: None, - } - } -} diff --git a/test/custom_model_path/models/tableB/generated.rs b/test/custom_model_path/models/tableB/generated.rs index 5bc5263f..8892de79 100644 --- a/test/custom_model_path/models/tableB/generated.rs +++ b/test/custom_model_path/models/tableB/generated.rs @@ -53,20 +53,20 @@ impl TableB { tableB.filter(_id.eq(param__id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TableBFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TableBFilter) -> QueryResult> { use crate::schema::tableB::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -76,12 +76,21 @@ impl TableB { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TableBFilter, ) -> crate::schema::tableB::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::tableB::table.into_boxed(); - if let Some(filter__id) = filter._id.clone() { query = query.filter(crate::schema::tableB::_id.eq(filter__id)); } @@ -105,17 +114,8 @@ impl TableB { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TableBFilter { pub _id: Option, pub link: Option, } - -impl Default for TableBFilter { - fn default() -> TableBFilter { - TableBFilter { - _id: None, - link: None, - } - } -} diff --git a/test/manual_primary_keys/models/todos/generated.rs b/test/manual_primary_keys/models/todos/generated.rs index 9367a89f..30b8aa54 100644 --- a/test/manual_primary_keys/models/todos/generated.rs +++ b/test/manual_primary_keys/models/todos/generated.rs @@ -46,20 +46,20 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -69,12 +69,21 @@ impl Todos { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TodosFilter, ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::todos::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::todos::id.eq(filter_id)); } @@ -89,15 +98,7 @@ impl Todos { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TodosFilter { pub id: Option, } - -impl Default for TodosFilter { - fn default() -> TodosFilter { - TodosFilter { - id: None, - } - } -} diff --git a/test/multiple_primary_keys/models/users/generated.rs b/test/multiple_primary_keys/models/users/generated.rs index 6e1571aa..68993e53 100644 --- a/test/multiple_primary_keys/models/users/generated.rs +++ b/test/multiple_primary_keys/models/users/generated.rs @@ -55,20 +55,20 @@ impl Users { users.filter(name.eq(param_name)).filter(address.eq(param_address)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: UsersFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: UsersFilter) -> QueryResult> { use crate::schema::users::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -78,12 +78,21 @@ impl Users { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: UsersFilter, ) -> crate::schema::users::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::users::table.into_boxed(); - if let Some(filter_name) = filter.name.clone() { query = query.filter(crate::schema::users::name.eq(filter_name)); } @@ -110,19 +119,9 @@ impl Users { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct UsersFilter { pub name: Option, pub address: Option, pub secret: Option, } - -impl Default for UsersFilter { - fn default() -> UsersFilter { - UsersFilter { - name: None, - address: None, - secret: None, - } - } -} diff --git a/test/once_common_structs/models/table1/generated.rs b/test/once_common_structs/models/table1/generated.rs index 3e2d6385..8273b344 100644 --- a/test/once_common_structs/models/table1/generated.rs +++ b/test/once_common_structs/models/table1/generated.rs @@ -32,20 +32,20 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -55,12 +55,21 @@ impl Table1 { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: Table1Filter, ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::table1::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::table1::id.eq(filter_id)); } @@ -75,15 +84,7 @@ impl Table1 { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct Table1Filter { pub id: Option, } - -impl Default for Table1Filter { - fn default() -> Table1Filter { - Table1Filter { - id: None, - } - } -} diff --git a/test/once_common_structs/models/table2/generated.rs b/test/once_common_structs/models/table2/generated.rs index c30a5924..6c976258 100644 --- a/test/once_common_structs/models/table2/generated.rs +++ b/test/once_common_structs/models/table2/generated.rs @@ -32,20 +32,20 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -55,12 +55,21 @@ impl Table2 { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: Table2Filter, ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::table2::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::table2::id.eq(filter_id)); } @@ -75,15 +84,7 @@ impl Table2 { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct Table2Filter { pub id: Option, } - -impl Default for Table2Filter { - fn default() -> Table2Filter { - Table2Filter { - id: None, - } - } -} diff --git a/test/once_common_structs_once_connection_type/models/table1/generated.rs b/test/once_common_structs_once_connection_type/models/table1/generated.rs index c4b94daf..b1e743d0 100644 --- a/test/once_common_structs_once_connection_type/models/table1/generated.rs +++ b/test/once_common_structs_once_connection_type/models/table1/generated.rs @@ -29,20 +29,20 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -52,12 +52,21 @@ impl Table1 { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: Table1Filter, ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::table1::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::table1::id.eq(filter_id)); } @@ -72,15 +81,7 @@ impl Table1 { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct Table1Filter { pub id: Option, } - -impl Default for Table1Filter { - fn default() -> Table1Filter { - Table1Filter { - id: None, - } - } -} diff --git a/test/once_common_structs_once_connection_type/models/table2/generated.rs b/test/once_common_structs_once_connection_type/models/table2/generated.rs index 16c6d336..16d87b23 100644 --- a/test/once_common_structs_once_connection_type/models/table2/generated.rs +++ b/test/once_common_structs_once_connection_type/models/table2/generated.rs @@ -29,20 +29,20 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -52,12 +52,21 @@ impl Table2 { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: Table2Filter, ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::table2::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::table2::id.eq(filter_id)); } @@ -72,15 +81,7 @@ impl Table2 { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct Table2Filter { pub id: Option, } - -impl Default for Table2Filter { - fn default() -> Table2Filter { - Table2Filter { - id: None, - } - } -} diff --git a/test/once_common_structs_once_connection_type_single_file/models/table1.rs b/test/once_common_structs_once_connection_type_single_file/models/table1.rs index c4b94daf..b1e743d0 100644 --- a/test/once_common_structs_once_connection_type_single_file/models/table1.rs +++ b/test/once_common_structs_once_connection_type_single_file/models/table1.rs @@ -29,20 +29,20 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -52,12 +52,21 @@ impl Table1 { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: Table1Filter, ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::table1::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::table1::id.eq(filter_id)); } @@ -72,15 +81,7 @@ impl Table1 { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct Table1Filter { pub id: Option, } - -impl Default for Table1Filter { - fn default() -> Table1Filter { - Table1Filter { - id: None, - } - } -} diff --git a/test/once_common_structs_once_connection_type_single_file/models/table2.rs b/test/once_common_structs_once_connection_type_single_file/models/table2.rs index 16c6d336..16d87b23 100644 --- a/test/once_common_structs_once_connection_type_single_file/models/table2.rs +++ b/test/once_common_structs_once_connection_type_single_file/models/table2.rs @@ -29,20 +29,20 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -52,12 +52,21 @@ impl Table2 { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: Table2Filter, ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::table2::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::table2::id.eq(filter_id)); } @@ -72,15 +81,7 @@ impl Table2 { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct Table2Filter { pub id: Option, } - -impl Default for Table2Filter { - fn default() -> Table2Filter { - Table2Filter { - id: None, - } - } -} diff --git a/test/once_connection_type/models/table1/generated.rs b/test/once_connection_type/models/table1/generated.rs index b48c8f97..75fbec4c 100644 --- a/test/once_connection_type/models/table1/generated.rs +++ b/test/once_connection_type/models/table1/generated.rs @@ -39,20 +39,20 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -62,12 +62,21 @@ impl Table1 { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: Table1Filter, ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::table1::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::table1::id.eq(filter_id)); } @@ -82,15 +91,7 @@ impl Table1 { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct Table1Filter { pub id: Option, } - -impl Default for Table1Filter { - fn default() -> Table1Filter { - Table1Filter { - id: None, - } - } -} diff --git a/test/once_connection_type/models/table2/generated.rs b/test/once_connection_type/models/table2/generated.rs index 8f87673a..b67a250f 100644 --- a/test/once_connection_type/models/table2/generated.rs +++ b/test/once_connection_type/models/table2/generated.rs @@ -39,20 +39,20 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -62,12 +62,21 @@ impl Table2 { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: Table2Filter, ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::table2::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::table2::id.eq(filter_id)); } @@ -82,15 +91,7 @@ impl Table2 { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct Table2Filter { pub id: Option, } - -impl Default for Table2Filter { - fn default() -> Table2Filter { - Table2Filter { - id: None, - } - } -} diff --git a/test/simple_table/models/todos/generated.rs b/test/simple_table/models/todos/generated.rs index 9a766ed1..96109e19 100644 --- a/test/simple_table/models/todos/generated.rs +++ b/test/simple_table/models/todos/generated.rs @@ -68,20 +68,20 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -91,12 +91,21 @@ impl Todos { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TodosFilter, ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::todos::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::todos::id.eq(filter_id)); } @@ -138,29 +147,14 @@ impl Todos { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TodosFilter { pub id: Option, - pub unsigned: Option, - pub unsigned_nullable: Option>, + pub unsigned: Option, + pub unsigned_nullable: Option>, pub text: Option, pub completed: Option, pub type_: Option, pub created_at: Option>, pub updated_at: Option>, } - -impl Default for TodosFilter { - fn default() -> TodosFilter { - TodosFilter { - id: None, - unsigned: None, - unsigned_nullable: None, - text: None, - completed: None, - type_: None, - created_at: None, - updated_at: None, - } - } -} diff --git a/test/simple_table_async/models/todos/generated.rs b/test/simple_table_async/models/todos/generated.rs index e710bcec..806ba2d7 100644 --- a/test/simple_table_async/models/todos/generated.rs +++ b/test/simple_table_async/models/todos/generated.rs @@ -63,20 +63,20 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db).await } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub async fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub async fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db).await?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db).await?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -86,12 +86,21 @@ impl Todos { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TodosFilter, ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::todos::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::todos::id.eq(filter_id)); } @@ -127,25 +136,12 @@ impl Todos { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TodosFilter { pub id: Option, - pub unsigned: Option, + pub unsigned: Option, pub text: Option, pub completed: Option, pub created_at: Option>, pub updated_at: Option>, } - -impl Default for TodosFilter { - fn default() -> TodosFilter { - TodosFilter { - id: None, - unsigned: None, - text: None, - completed: None, - created_at: None, - updated_at: None, - } - } -} diff --git a/test/simple_table_custom_schema_path/models/todos/generated.rs b/test/simple_table_custom_schema_path/models/todos/generated.rs index 959a9613..68b91a34 100644 --- a/test/simple_table_custom_schema_path/models/todos/generated.rs +++ b/test/simple_table_custom_schema_path/models/todos/generated.rs @@ -62,20 +62,20 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::data::schema::todos::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -85,12 +85,21 @@ impl Todos { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TodosFilter, ) -> crate::data::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::data::schema::todos::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::data::schema::todos::id.eq(filter_id)); } @@ -126,25 +135,12 @@ impl Todos { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TodosFilter { pub id: Option, - pub unsigned: Option, + pub unsigned: Option, pub text: Option, pub completed: Option, pub created_at: Option>, pub updated_at: Option>, } - -impl Default for TodosFilter { - fn default() -> TodosFilter { - TodosFilter { - id: None, - unsigned: None, - text: None, - completed: None, - created_at: None, - updated_at: None, - } - } -} diff --git a/test/simple_table_no_serde/models/todos/generated.rs b/test/simple_table_no_serde/models/todos/generated.rs index 50420a50..0d8bbdd6 100644 --- a/test/simple_table_no_serde/models/todos/generated.rs +++ b/test/simple_table_no_serde/models/todos/generated.rs @@ -62,20 +62,20 @@ impl Todos { todos.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: TodosFilter) -> QueryResult> { use crate::schema::todos::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -85,12 +85,21 @@ impl Todos { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: TodosFilter, ) -> crate::schema::todos::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::todos::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::todos::id.eq(filter_id)); } @@ -126,25 +135,12 @@ impl Todos { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct TodosFilter { pub id: Option, - pub unsigned: Option, + pub unsigned: Option, pub text: Option, pub completed: Option, pub created_at: Option>, pub updated_at: Option>, } - -impl Default for TodosFilter { - fn default() -> TodosFilter { - TodosFilter { - id: None, - unsigned: None, - text: None, - completed: None, - created_at: None, - updated_at: None, - } - } -} diff --git a/test/single_model_file/models/table1.rs b/test/single_model_file/models/table1.rs index ed6fc7e7..cd4103f3 100644 --- a/test/single_model_file/models/table1.rs +++ b/test/single_model_file/models/table1.rs @@ -41,20 +41,20 @@ impl Table1 { table1.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: Table1Filter) -> QueryResult> { use crate::schema::table1::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -64,12 +64,21 @@ impl Table1 { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: Table1Filter, ) -> crate::schema::table1::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::table1::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::table1::id.eq(filter_id)); } @@ -84,15 +93,7 @@ impl Table1 { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct Table1Filter { pub id: Option, } - -impl Default for Table1Filter { - fn default() -> Table1Filter { - Table1Filter { - id: None, - } - } -} diff --git a/test/single_model_file/models/table2.rs b/test/single_model_file/models/table2.rs index ceb50a95..b181d7ff 100644 --- a/test/single_model_file/models/table2.rs +++ b/test/single_model_file/models/table2.rs @@ -41,20 +41,20 @@ impl Table2 { table2.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: Table2Filter) -> QueryResult> { use crate::schema::table2::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -64,12 +64,21 @@ impl Table2 { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: Table2Filter, ) -> crate::schema::table2::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::table2::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::table2::id.eq(filter_id)); } @@ -84,15 +93,7 @@ impl Table2 { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct Table2Filter { pub id: Option, } - -impl Default for Table2Filter { - fn default() -> Table2Filter { - Table2Filter { - id: None, - } - } -} diff --git a/test/use_statements/models/fang_tasks/generated.rs b/test/use_statements/models/fang_tasks/generated.rs index aad71372..1d6e3e1a 100644 --- a/test/use_statements/models/fang_tasks/generated.rs +++ b/test/use_statements/models/fang_tasks/generated.rs @@ -77,20 +77,20 @@ impl FangTasks { fang_tasks.filter(id.eq(param_id)).first::(db) } - /// Paginates through the table where page is a 1-based index (i.e. page 1 is the first page) - pub fn paginate(db: &mut ConnectionType, page_starting_with_1: i64, page_size: i64, filter: FangTasksFilter) -> QueryResult> { + /// Paginates through the table where page is a 0-based index (i.e. page 0 is the first page) + pub fn paginate(db: &mut ConnectionType, page: i64, page_size: i64, filter: FangTasksFilter) -> QueryResult> { use crate::schema::fang_tasks::dsl::*; - let param_page = page_starting_with_1.max(0); + let page = page.max(0); let page_size = page_size.max(1); let total_items = Self::filter(filter.clone()).count().get_result(db)?; - let items = Self::filter(filter).limit(page_size).offset(param_page * page_size).load::(db)?; + let items = Self::filter(filter).limit(page_size).offset(page * page_size).load::(db)?; Ok(PaginationResult { items, total_items, - page: param_page, - page_size: page_size, + page, + page_size, /* ceiling division of integers */ num_pages: total_items / page_size + i64::from(total_items % page_size != 0) }) @@ -100,12 +100,21 @@ impl FangTasks { /// /// Example: /// + /// ``` + /// // create a filter for completed todos + /// let query = Todo::filter(TodoFilter { + /// completed: Some(true), + /// ..Default::default() + /// }); + /// + /// // delete completed todos + /// diesel::delete(query).execute(db)?; + /// ``` pub fn filter<'a>( filter: FangTasksFilter, ) -> crate::schema::fang_tasks::BoxedQuery<'a, diesel::pg::Pg> { let mut query = crate::schema::fang_tasks::table.into_boxed(); - if let Some(filter_id) = filter.id.clone() { query = query.filter(crate::schema::fang_tasks::id.eq(filter_id)); } @@ -153,7 +162,7 @@ impl FangTasks { } } -#[derive(Clone)] +#[derive(Debug, Default, Clone)] pub struct FangTasksFilter { pub id: Option, pub metadata: Option, @@ -166,20 +175,3 @@ pub struct FangTasksFilter { pub created_at: Option>, pub updated_at: Option>, } - -impl Default for FangTasksFilter { - fn default() -> FangTasksFilter { - FangTasksFilter { - id: None, - metadata: None, - error_message: None, - state: None, - task_type: None, - uniq_hash: None, - retries: None, - scheduled_at: None, - created_at: None, - updated_at: None, - } - } -} From 8fc15f36c5beb257bee9078e0219f90f71eccb57 Mon Sep 17 00:00:00 2001 From: Haris <4259838+Wulf@users.noreply.github.com> Date: Sun, 5 Nov 2023 16:07:10 -0500 Subject: [PATCH 10/10] Remove .clone() --- src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib.rs b/src/lib.rs index f5b0223f..e63a2aeb 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -334,7 +334,7 @@ pub fn validate_config(config: &GenerationConfig) -> Result<()> { return Err(Error::new(ErrorEnum::InvalidGenerationConfig(format!( "Invalid diesel_backend '{}', please use one of the following: {:?}; or, a custom diesel backend type (a struct which implements `diesel::backend::Backend`).", &config.diesel_backend, - VALID_BACKENDS.clone().join(", ") + VALID_BACKENDS.join(", ") )))); }