feat: use query_as non macro when type array was used

Author: LeadcodeDev

Cargo.lock

@@ -130,6 +130,7 @@ mod tests {
             is_primary_key: false,
             ordinal_position: 0,
             schema_name: "public".to_string(),
+            column_default: None,
         }
     }
 

crates/sqlx_gen/src/codegen/composite_gen.rs

@@ -24,11 +24,11 @@ pub fn generate_crud_from_parsed(
     // Pool type (used via full path sqlx::PgPool etc., no import needed)
     let pool_type = pool_type_tokens(db_kind);
 
-    // When the entity has custom SQL array types (e.g. Vec<ConnectorUsages> from connector_usages[]),
+    // When the entity has custom SQL types (enums, composites, arrays),
     // query_as! macro can't resolve the column type at compile time. Fall back to runtime query_as::<_, T>()
     // for queries that return rows. DELETE (no rows returned) can still use macro.
-    let has_sql_array = entity.fields.iter().any(|f| f.is_sql_array);
-    let use_macro = query_macro && !has_sql_array;
+    let has_custom_sql_type = entity.fields.iter().any(|f| f.sql_type.is_some());
+    let use_macro = query_macro && !has_custom_sql_type;
 
     // Entity import
     imports.insert(format!("use {}::{};", entity_module_path, entity.struct_name));
@@ -1288,7 +1288,7 @@ mod tests {
         assert!(!code.contains("query!("));
     }
 
-    // --- sql_array fallback: macro mode + array field → runtime for SELECT, macro for DELETE ---
+    // --- custom sql_type fallback: macro mode + custom type → runtime for SELECT, macro for DELETE ---
 
     fn entity_with_sql_array() -> ParsedEntity {
         ParsedEntity {
@@ -1379,4 +1379,57 @@ mod tests {
         // Should NOT contain query_as! macro (only query_as::<_ for runtime)
         assert!(!code.contains("query_as!("));
     }
+
+    // --- custom enum (non-array) also triggers runtime fallback ---
+
+    fn entity_with_sql_enum() -> ParsedEntity {
+        ParsedEntity {
+            struct_name: "Task".to_string(),
+            table_name: "tasks".to_string(),
+            schema_name: None,
+            is_view: false,
+            fields: vec![
+                ParsedField {
+                    rust_name: "id".to_string(),
+                    column_name: "id".to_string(),
+                    rust_type: "i32".to_string(),
+                    inner_type: "i32".to_string(),
+                    is_nullable: false,
+                    is_primary_key: true,
+                    sql_type: None,
+                    is_sql_array: false,
+                },
+                ParsedField {
+                    rust_name: "status".to_string(),
+                    column_name: "status".to_string(),
+                    rust_type: "TaskStatus".to_string(),
+                    inner_type: "TaskStatus".to_string(),
+                    is_nullable: false,
+                    is_primary_key: false,
+                    sql_type: Some("task_status".to_string()),
+                    is_sql_array: false,
+                },
+            ],
+            imports: vec![],
+        }
+    }
+
+    #[test]
+    fn test_sql_enum_macro_uses_runtime() {
+        let skip = Methods::all();
+        let (tokens, _) = generate_crud_from_parsed(&entity_with_sql_enum(), DatabaseKind::Postgres, "crate::models::task", &skip, true);
+        let code = parse_and_format(&tokens);
+        // SELECT queries should use runtime query_as, not macro
+        assert!(code.contains("query_as::<"));
+        assert!(!code.contains("query_as!("));
+    }
+
+    #[test]
+    fn test_sql_enum_macro_delete_still_uses_macro() {
+        let skip = Methods::all();
+        let (tokens, _) = generate_crud_from_parsed(&entity_with_sql_enum(), DatabaseKind::Postgres, "crate::models::task", &skip, true);
+        let code = parse_and_format(&tokens);
+        // DELETE still uses query! macro
+        assert!(code.contains("query!"));
+    }
 }

crates/sqlx_gen/src/codegen/crud_gen.rs

@@ -31,6 +31,7 @@ pub fn generate_domain(
         is_primary_key: false,
         ordinal_position: 0,
         schema_name: domain.schema_name.clone(),
+        column_default: None,
     };
 
     let rust_type = typemap::map_column(&fake_col, db_kind, schema_info, type_overrides);

crates/sqlx_gen/src/codegen/domain_gen.rs

@@ -71,6 +71,20 @@ pub fn generate_enum(
         })
         .collect();
 
+    let default_impl = if let Some(ref default_variant) = enum_info.default_variant {
+        let variant_pascal = default_variant.to_upper_camel_case();
+        let variant_ident = format_ident!("{}", variant_pascal);
+        quote! {
+            impl Default for #enum_name {
+                fn default() -> Self {
+                    Self::#variant_ident
+                }
+            }
+        }
+    } else {
+        quote! {}
+    };
+
     let tokens = quote! {
         #[doc = #doc]
         #[derive(#(#derive_tokens),*)]
@@ -79,6 +93,8 @@ pub fn generate_enum(
         pub enum #enum_name {
             #(#variants)*
         }
+
+        #default_impl
     };
 
     (tokens, imports)
@@ -94,6 +110,7 @@ mod tests {
             schema_name: "public".to_string(),
             name: name.to_string(),
             variants: variants.into_iter().map(|s| s.to_string()).collect(),
+            default_variant: None,
         }
     }
 
@@ -150,6 +167,7 @@ mod tests {
             schema_name: "auth".to_string(),
             name: "role".to_string(),
             variants: vec!["admin".to_string(), "user".to_string()],
+            default_variant: None,
         };
         let (tokens, _) = generate_enum(&e, DatabaseKind::Postgres, &[]);
         let code = parse_and_format(&tokens);
@@ -289,4 +307,39 @@ mod tests {
         let code = gen(&e, DatabaseKind::Postgres);
         assert!(code.contains("pub enum MyEnum"));
     }
+
+    // --- impl Default ---
+
+    #[test]
+    fn test_default_impl_generated() {
+        let e = EnumInfo {
+            schema_name: "public".to_string(),
+            name: "task_status".to_string(),
+            variants: vec!["idle".to_string(), "running".to_string(), "done".to_string()],
+            default_variant: Some("idle".to_string()),
+        };
+        let code = gen(&e, DatabaseKind::Postgres);
+        assert!(code.contains("impl Default for TaskStatus"));
+        assert!(code.contains("Self::Idle"));
+    }
+
+    #[test]
+    fn test_no_default_impl_when_none() {
+        let e = make_enum("status", vec!["active", "inactive"]);
+        let code = gen(&e, DatabaseKind::Postgres);
+        assert!(!code.contains("impl Default"));
+    }
+
+    #[test]
+    fn test_default_impl_snake_case_variant() {
+        let e = EnumInfo {
+            schema_name: "public".to_string(),
+            name: "status".to_string(),
+            variants: vec!["in_progress".to_string(), "done".to_string()],
+            default_variant: Some("in_progress".to_string()),
+        };
+        let code = gen(&e, DatabaseKind::Postgres);
+        assert!(code.contains("impl Default for Status"));
+        assert!(code.contains("Self::InProgress"));
+    }
 }