New iden design (#909)

* 1. change unquoted() signature

* 2. change quoted() signature

* 3. introduce unquoted_static

* 4. remove prepare from iden

* 5. remove type-sensitive comparison

* remove quote from quoted

* 6. revamp SeaRc and DynIden

* rename to prepare_iden

* tweaks

* Impl IntoIden for String

* improve tests

* clippy

* const fn is_static_iden

hopefully this can get optimized

* Apply suggestions from code review

Co-authored-by: Dmitrii Aleksandrov <[email protected]>

* Update src/types.rs

Co-authored-by: Dmitrii Aleksandrov <[email protected]>

* dep

* fix build

---------

Co-authored-by: Dmitrii Aleksandrov <[email protected]>

Author: tyt2y3

README.md

@@ -158,18 +158,13 @@ pub enum Character {
 
 // Mapping between Enum variant and its corresponding string value
 impl Iden for Character {
-    fn unquoted(&self, s: &mut dyn std::fmt::Write) {
-        write!(
-            s,
-            "{}",
-            match self {
-                Self::Table => "character",
-                Self::Id => "id",
-                Self::FontId => "font_id",
-                Self::FontSize => "font_size",
-            }
-        )
-        .unwrap();
+    fn unquoted(&self) -> &str {
+        match self {
+            Self::Table => "character",
+            Self::Id => "id",
+            Self::FontId => "font_id",
+            Self::FontSize => "font_size",
+        }
     }
 }
 ```
@@ -198,7 +193,7 @@ assert_eq!(Glyph.to_string(), "glyph");
 
 ```rust
 #[cfg(feature = "derive")]
-use sea_query::{enum_def, Iden};
+use sea_query::{Iden, enum_def};
 
 #[enum_def]
 struct Character {
@@ -476,8 +471,8 @@ assert_eq!(
 struct MyFunction;
 
 impl Iden for MyFunction {
-    fn unquoted(&self, s: &mut dyn Write) {
-        write!(s, "MY_FUNCTION").unwrap();
+    fn unquoted(&self) -> &str {
+        "MY_FUNCTION"
     }
 }
 
@@ -574,12 +569,7 @@ assert_eq!(
 ```rust
 let table = Table::alter()
     .table(Font::Table)
-    .add_column(
-        ColumnDef::new("new_col")
-            .integer()
-            .not_null()
-            .default(100),
-    )
+    .add_column(ColumnDef::new("new_col").integer().not_null().default(100))
     .to_owned();
 
 assert_eq!(
@@ -621,9 +611,7 @@ assert_eq!(
 ### Table Rename
 
 ```rust
-let table = Table::rename()
-    .table(Font::Table, "font_new")
-    .to_owned();
+let table = Table::rename().table(Font::Table, "font_new").to_owned();
 
 assert_eq!(
     table.to_string(MysqlQueryBuilder),

sea-query-derive/Cargo.toml

@@ -23,7 +23,7 @@ proc-macro2 = { version = "1", default-features = false }
 thiserror = { version = "2", default-features = false }
 
 [dev-dependencies]
-trybuild = "1.0"
+trybuild = "1.0.86"
 sea-query = { version = "1.0.0-rc.1", path = ".." }
 strum = { version = "0.25", features = ["derive"] }
 

sea-query-derive/src/iden/mod.rs

@@ -13,11 +13,11 @@ pub(crate) struct DeriveIden;
 
 impl WriteArm for DeriveIden {
     fn variant(variant: TokenStream, name: TokenStream) -> TokenStream {
-        quote! { Self::#variant => write!(s, "{}", #name).unwrap() }
+        quote! { Self::#variant => #name }
     }
 
     fn flattened(variant: TokenStream, name: &Ident) -> TokenStream {
-        quote! { Self::#variant => #name.unquoted(s) }
+        quote! { Self::#variant => #name.unquoted() }
     }
 }
 

sea-query-derive/src/iden/write_arm.rs

@@ -7,7 +7,7 @@ use quote::{ToTokens, TokenStreamExt, quote};
 use syn::{Error, Fields, FieldsNamed, Ident, Variant};
 
 use super::{attr::IdenAttr, error::ErrorMsg};
-use crate::{find_attr, must_be_valid_iden};
+use crate::{find_attr, is_static_iden};
 
 pub(crate) trait WriteArm {
     fn variant(variant: TokenStream, name: TokenStream) -> TokenStream;
@@ -159,7 +159,7 @@ where
         T::variant(variant, name)
     }
 
-    pub(crate) fn must_be_valid_iden(&self) -> bool {
+    pub(crate) fn is_static_iden(&self) -> bool {
         let name: String = match &self.attr {
             Some(a) => match a {
                 IdenAttr::Rename(name) => name.to_owned(),
@@ -169,7 +169,7 @@ where
             None => self.table_or_snake_case(),
         };
 
-        must_be_valid_iden(&name)
+        is_static_iden(&name)
     }
 }
 

sea-query-derive/src/lib.rs

@@ -107,7 +107,7 @@ pub fn derive_iden_static(input: TokenStream) -> TokenStream {
         .map(IdenVariant::<DeriveIdenStatic>::try_from)
         .collect::<syn::Result<Vec<_>>>()
     {
-        Ok(v) => quote! { #(#v),* },
+        Ok(v) => v,
         Err(e) => return e.to_compile_error().into(),
     };
 
@@ -117,7 +117,7 @@ pub fn derive_iden_static(input: TokenStream) -> TokenStream {
         impl #sea_query_path::IdenStatic for #ident {
             fn as_str(&self) -> &'static str {
                 match self {
-                    #match_arms
+                    #(#match_arms),*
                 }
             }
         }
@@ -149,7 +149,7 @@ fn get_table_name(ident: &proc_macro2::Ident, attrs: Vec<Attribute>) -> Result<S
     Ok(table_name)
 }
 
-fn must_be_valid_iden(name: &str) -> bool {
+fn is_static_iden(name: &str) -> bool {
     // can only begin with [a-z_]
     name.chars()
         .take(1)
@@ -163,24 +163,24 @@ fn impl_iden_for_unit_struct(
 ) -> proc_macro2::TokenStream {
     let sea_query_path = sea_query_path();
 
-    let prepare = if must_be_valid_iden(table_name) {
+    if is_static_iden(table_name) {
         quote! {
-            fn prepare(&self, s: &mut dyn ::std::fmt::Write, q: #sea_query_path::Quote) {
-                write!(s, "{}", q.left()).unwrap();
-                self.unquoted(s);
-                write!(s, "{}", q.right()).unwrap();
+            impl #sea_query_path::Iden for #ident {
+                fn quoted(&self) -> std::borrow::Cow<'static, str> {
+                    std::borrow::Cow::Borrowed(#table_name)
+                }
+
+                fn unquoted(&self) -> &str {
+                    #table_name
+                }
             }
         }
     } else {
-        quote! {}
-    };
-
-    quote! {
-        impl #sea_query_path::Iden for #ident {
-            #prepare
-
-            fn unquoted(&self, s: &mut dyn ::std::fmt::Write) {
-                write!(s, #table_name).unwrap();
+        quote! {
+            impl #sea_query_path::Iden for #ident {
+                fn unquoted(&self) -> &str {
+                    #table_name
+                }
             }
         }
     }
@@ -196,41 +196,44 @@ where
 {
     let sea_query_path = sea_query_path();
 
-    let mut is_all_valid = true;
+    let mut is_all_static_iden = true;
 
     let match_arms = match variants
-        .map(|v| (table_name, v))
         .map(|v| {
-            let v = IdenVariant::<DeriveIden>::try_from(v)?;
-            is_all_valid &= v.must_be_valid_iden();
+            let v = IdenVariant::<DeriveIden>::try_from((table_name, v))?;
+            is_all_static_iden &= v.is_static_iden();
             Ok(v)
         })
         .collect::<syn::Result<Vec<_>>>()
     {
-        Ok(v) => quote! { #(#v),* },
+        Ok(v) => v,
         Err(e) => return e.to_compile_error(),
     };
 
-    let prepare = if is_all_valid {
+    if is_all_static_iden {
         quote! {
-            fn prepare(&self, s: &mut dyn ::std::fmt::Write, q: #sea_query_path::Quote) {
-                write!(s, "{}", q.left()).unwrap();
-                self.unquoted(s);
-                write!(s, "{}", q.right()).unwrap();
+            impl #sea_query_path::Iden for #ident {
+                fn quoted(&self) -> std::borrow::Cow<'static, str> {
+                    std::borrow::Cow::Borrowed(match self {
+                        #(#match_arms),*
+                    })
+                }
+
+                fn unquoted(&self) -> &str {
+                    match self {
+                        #(#match_arms),*
+                    }
+                }
             }
         }
     } else {
-        quote! {}
-    };
-
-    quote! {
-        impl #sea_query_path::Iden for #ident {
-            #prepare
-
-            fn unquoted(&self, s: &mut dyn ::std::fmt::Write) {
-                match self {
-                    #match_arms
-                };
+        quote! {
+            impl #sea_query_path::Iden for #ident {
+                fn unquoted(&self) -> &str {
+                    match self {
+                        #(#match_arms),*
+                    }
+                }
             }
         }
     }
@@ -359,8 +362,8 @@ pub fn enum_def(args: TokenStream, input: TokenStream) -> TokenStream {
         }
 
         impl #import_name::Iden for #enum_name {
-            fn unquoted(&self, s: &mut dyn sea_query::Write) {
-                write!(s, "{}", <Self as #import_name::IdenStatic>::as_str(&self)).unwrap();
+            fn unquoted(&self) -> &str {
+                <Self as #import_name::IdenStatic>::as_str(&self)
             }
         }
 

sea-query-derive/tests/pass-static/flattened_unnamed.rs

@@ -10,19 +10,14 @@ enum Asset {
     Creation(CreationInfo),
 }
 
-#[derive(Copy, Clone, IdenStatic)]
+#[derive(Default, Copy, Clone, IdenStatic)]
 enum CreationInfo {
+    #[default]
     UserId,
     #[iden = "creation_date"]
     Date,
 }
 
-impl Default for CreationInfo {
-    fn default() -> Self {
-        Self::UserId
-    }
-}
-
 fn main() {
     // custom ends up being default string which is an empty string
     let expected = ["asset", "id", "asset_name", "user_id", "creation_date"];

sea-query-derive/tests/pass-static/meta_list_renaming_everything.rs

@@ -1,4 +1,4 @@
-use sea_query::{Iden, IdenStatic};
+use sea_query::{Iden, IntoIden, IdenStatic, MysqlQueryBuilder, PostgresQueryBuilder, QuotedBuilder};
 use strum::{EnumIter, IntoEnumIterator};
 
 #[derive(IdenStatic, EnumIter, Copy, Clone)]
@@ -39,10 +39,10 @@ fn main() {
         .for_each(|(iden, exp)| assert_eq!(iden, exp));
 
     let mut string = String::new();
-    Custom::Email(0).prepare(&mut string, '"'.into());
+    PostgresQueryBuilder.prepare_iden(&Custom::Email(0).into_iden(), &mut string);
     assert_eq!(string, "\"EM`ail\"");
 
     let mut string = String::new();
-    Custom::Email(0).prepare(&mut string, b'`'.into());
+    MysqlQueryBuilder.prepare_iden(&Custom::Email(0).into_iden(), &mut string);
     assert_eq!(string, "`EM``ail`");
 }

sea-query-derive/tests/pass-static/simple_unit_struct.rs

@@ -1,4 +1,4 @@
-use sea_query::{Iden, IdenStatic};
+use sea_query::{Iden, IntoIden, IdenStatic, MysqlQueryBuilder, PostgresQueryBuilder, QuotedBuilder};
 
 #[derive(Copy, Clone, IdenStatic)]
 pub struct SomeType;
@@ -12,14 +12,14 @@ fn main() {
     assert_eq!(SomeTypeWithRename.to_string(), "Hel`lo");
 
     let mut string = String::new();
-    SomeType.prepare(&mut string, '"'.into());
+    PostgresQueryBuilder.prepare_iden(&SomeType.into_iden(), &mut string);
     assert_eq!(string, "\"some_type\"");
 
     let mut string = String::new();
-    SomeTypeWithRename.prepare(&mut string, '"'.into());
+    PostgresQueryBuilder.prepare_iden(&SomeTypeWithRename.into_iden(), &mut string);
     assert_eq!(string, "\"Hel`lo\"");
 
     let mut string = String::new();
-    SomeTypeWithRename.prepare(&mut string, b'`'.into());
+    MysqlQueryBuilder.prepare_iden(&SomeTypeWithRename.into_iden(), &mut string);
     assert_eq!(string, "`Hel``lo`");
 }

sea-query-derive/tests/pass/flattened_named.rs

@@ -1,5 +1,6 @@
 use sea_query::Iden;
 use strum::{EnumIter, IntoEnumIterator};
+use std::borrow::Cow;
 
 #[derive(Copy, Clone, Iden, EnumIter)]
 enum Asset {
@@ -35,5 +36,6 @@ fn main() {
         .zip(expected)
         .for_each(|(var, exp)| {
             assert_eq!(var.to_string(), exp);
+            assert_eq!(var.quoted(), Cow::Borrowed(exp));
         })
 }

sea-query-derive/tests/pass/meta_list_renaming_everything.rs

@@ -1,5 +1,6 @@
-use sea_query::Iden;
+use sea_query::{Iden, IntoIden, MysqlQueryBuilder, PostgresQueryBuilder, QuotedBuilder};
 use strum::{EnumIter, IntoEnumIterator};
+use std::borrow::Cow;
 
 #[derive(Iden, EnumIter)]
 // Outer iden attributes overrides what's used for "Table"...
@@ -39,10 +40,12 @@ fn main() {
         .for_each(|(iden, exp)| assert_eq!(iden, exp));
 
     let mut string = String::new();
-    Custom::Email("".to_owned()).prepare(&mut string, '"'.into());
+    PostgresQueryBuilder.prepare_iden(&Custom::Email("".to_owned()).into_iden(), &mut string);
     assert_eq!(string, "\"EM`ail\"");
 
     let mut string = String::new();
-    Custom::Email("".to_owned()).prepare(&mut string, b'`'.into());
+    MysqlQueryBuilder.prepare_iden(&Custom::Email("".to_owned()).into_iden(), &mut string);
     assert_eq!(string, "`EM``ail`");
+
+    assert!(matches!(Custom::FirstName.quoted(), Cow::Owned(_)));
 }