QueryableByName supoort non ident column name

delete #[allow(dead_code)]

Author: 0xPoe

diesel_derives/src/field.rs

@@ -13,13 +13,12 @@ pub struct Field {
     pub span: Span,
     pub sql_type: Option<syn::Type>,
     pub flags: MetaItem,
-    column_name_from_attribute: Option<syn::Ident>,
+    column_name_from_attribute: Option<MetaItem>,
 }
 
 impl Field {
     pub fn from_struct_field(field: &syn::Field, index: usize) -> Self {
-        let column_name_from_attribute =
-            MetaItem::with_name(&field.attrs, "column_name").map(|m| m.expect_ident_value());
+        let column_name_from_attribute = MetaItem::with_name(&field.attrs, "column_name");
         let name = match field.ident.clone() {
             Some(mut x) => {
                 // https://github.com/rust-lang/rust/issues/47983#issuecomment-362817105
@@ -51,7 +50,8 @@ impl Field {
 
     pub fn column_name(&self) -> syn::Ident {
         self.column_name_from_attribute
-            .clone()
+            .as_ref()
+            .map(|m| m.expect_ident_value())
             .unwrap_or_else(|| match self.name {
                 FieldName::Named(ref x) => x.clone(),
                 _ => {
@@ -65,6 +65,23 @@ impl Field {
             })
     }
 
+    pub fn column_str_name(&self) -> String {
+        self.column_name_from_attribute
+            .as_ref()
+            .map(|m| {
+                m.str_value().unwrap_or_else(|e| {
+                    e.emit();
+                    "unknown_column".to_string()
+                })
+            })
+            .unwrap_or_else(|| {
+                self.span
+                    .error("All fields of tuple structs must be annotated with `#[column_name]`")
+                    .emit();
+                "unknown_column".to_string()
+            })
+    }
+
     pub fn has_flag(&self, flag: &str) -> bool {
         self.flags.has_flag(flag)
     }

diesel_derives/src/queryable_by_name.rs

@@ -22,15 +22,25 @@ pub fn derive(item: syn::DeriveInput) -> Result<proc_macro2::TokenStream, Diagno
                     row,
                 )?))
             } else {
-                let name = f.column_name();
                 let field_ty = &f.ty;
                 let deserialize_ty = f.ty_for_deserialize()?;
-                Ok(quote!(
-                   {
-                       let field = diesel::row::NamedRow::get(row, stringify!(#name))?;
-                       <#deserialize_ty as Into<#field_ty>>::into(field)
-                   }
-                ))
+                if model.has_table_name_attribute() {
+                    let name = f.column_name();
+                    Ok(quote!(
+                            {
+                                let field = diesel::row::NamedRow::get(row, stringify!(#name))?;
+                                <#deserialize_ty as Into<#field_ty>>::into(field)
+                            }
+                    ))
+                } else {
+                    let name = f.column_str_name();
+                    Ok(quote!(
+                       {
+                           let field = diesel::row::NamedRow::get(row, stringify!(#name))?;
+                           <#deserialize_ty as Into<#field_ty>>::into(field)
+                       }
+                    ))
+                }
             }
         })
         .collect::<Result<Vec<_>, Diagnostic>>()?;
@@ -93,12 +103,12 @@ fn get_ident(field: &Field) -> Ident {
 
 fn sql_type(field: &Field, model: &Model) -> syn::Type {
     let table_name = model.table_name();
-    let column_name = field.column_name();
 
     match field.sql_type {
         Some(ref st) => st.clone(),
         None => {
             if model.has_table_name_attribute() {
+                let column_name = field.column_name();
                 parse_quote!(diesel::dsl::SqlTypeOf<#table_name::#column_name>)
             } else {
                 let field_name = match field.name {

diesel_derives/tests/queryable_by_name.rs

@@ -24,6 +24,16 @@ fn named_struct_definition() {
     assert_eq!(Ok(MyStruct { foo: 1, bar: 2 }), data);
 }
 
+#[test]
+fn non_ident_column_name() {
+    #[derive(QueryableByName)]
+    struct Out {
+        #[sql_type = "diesel::sql_types::Text"]
+        #[column_name = "QUERY PLAN "]
+        qp: String,
+    }
+}
+
 #[test]
 fn tuple_struct() {
     #[derive(Debug, Clone, Copy, PartialEq, Eq, QueryableByName)]