sqlxplus_derive/
lib.rs

1use proc_macro::TokenStream;
2use proc_macro2;
3use quote::quote;
4use syn::{parse::Parser, parse_macro_input, Data, DataStruct, DeriveInput, Fields, Meta};
5
6/// 生成 Model trait 的实现
7///
8/// 自动生成 `TABLE`、`PK` 和可选的 `SOFT_DELETE_FIELD` 常量
9///
10/// 使用示例：
11/// ```ignore
12/// // 物理删除模式（默认）
13/// #[derive(ModelMeta)]
14/// #[model(table = "users", pk = "id")]
15/// struct User {
16///     id: i64,
17///     name: String,
18/// }
19///
20/// // 逻辑删除模式
21/// #[derive(ModelMeta)]
22/// #[model(table = "users", pk = "id", soft_delete = "is_deleted")]
23/// struct UserWithSoftDelete {
24///     id: i64,
25///     name: String,
26///     is_deleted: i32, // 逻辑删除字段：0=未删除，1=已删除
27/// }
28/// ```
29#[proc_macro_derive(ModelMeta, attributes(model))]
30pub fn derive_model_meta(input: TokenStream) -> TokenStream {
31    let input = parse_macro_input!(input as DeriveInput);
32    let name = &input.ident;
33
34    // 解析属性
35    let mut table_name = None;
36    let mut pk_field = None;
37    let mut soft_delete_field = None;
38
39    for attr in &input.attrs {
40        if attr.path().is_ident("model") {
41            // 在 syn 2.0 中，使用 meta() 方法获取元数据
42            if let syn::Meta::List(list) = &attr.meta {
43                // 解析列表中的每个 Meta::NameValue
44                let parser = syn::punctuated::Punctuated::<Meta, syn::Token![,]>::parse_terminated;
45                if let Ok(metas) = parser.parse2(list.tokens.clone()) {
46                    for meta in metas {
47                        if let Meta::NameValue(nv) = meta {
48                            if nv.path.is_ident("table") {
49                                if let syn::Expr::Lit(syn::ExprLit {
50                                    lit: syn::Lit::Str(s),
51                                    ..
52                                }) = nv.value
53                                {
54                                    table_name = Some(s.value());
55                                }
56                            } else if nv.path.is_ident("pk") {
57                                if let syn::Expr::Lit(syn::ExprLit {
58                                    lit: syn::Lit::Str(s),
59                                    ..
60                                }) = nv.value
61                                {
62                                    pk_field = Some(s.value());
63                                }
64                            } else if nv.path.is_ident("soft_delete") {
65                                if let syn::Expr::Lit(syn::ExprLit {
66                                    lit: syn::Lit::Str(s),
67                                    ..
68                                }) = nv.value
69                                {
70                                    soft_delete_field = Some(s.value());
71                                }
72                            }
73                        }
74                    }
75                }
76            } else if let syn::Meta::NameValue(nv) = &attr.meta {
77                // 单个 NameValue 的情况
78                if nv.path.is_ident("table") {
79                    if let syn::Expr::Lit(syn::ExprLit {
80                        lit: syn::Lit::Str(s),
81                        ..
82                    }) = &nv.value
83                    {
84                        table_name = Some(s.value());
85                    }
86                } else if nv.path.is_ident("pk") {
87                    if let syn::Expr::Lit(syn::ExprLit {
88                        lit: syn::Lit::Str(s),
89                        ..
90                    }) = &nv.value
91                    {
92                        pk_field = Some(s.value());
93                    }
94                } else if nv.path.is_ident("soft_delete") {
95                    if let syn::Expr::Lit(syn::ExprLit {
96                        lit: syn::Lit::Str(s),
97                        ..
98                    }) = &nv.value
99                    {
100                        soft_delete_field = Some(s.value());
101                    }
102                }
103            }
104        }
105    }
106
107    // 如果没有指定表名，使用结构体名称的小写蛇形命名方式
108    let table = table_name.unwrap_or_else(|| {
109        let s = name.to_string();
110        // 将 PascalCase 转换为 snake_case
111        let mut result = String::new();
112        for (i, c) in s.chars().enumerate() {
113            if c.is_uppercase() && i > 0 {
114                result.push('_');
115            }
116            result.push(c.to_ascii_lowercase());
117        }
118        result
119    });
120
121    // 如果没有指定主键，默认使用 "id"
122    let pk = pk_field.unwrap_or_else(|| "id".to_string());
123
124    // 生成实现代码
125    let expanded = if let Some(soft_delete) = soft_delete_field {
126        // 如果指定了逻辑删除字段，生成包含 SOFT_DELETE_FIELD 的实现
127        let soft_delete_lit = syn::LitStr::new(&soft_delete, proc_macro2::Span::call_site());
128        quote! {
129            impl sqlxplus::Model for #name {
130                const TABLE: &'static str = #table;
131                const PK: &'static str = #pk;
132                const SOFT_DELETE_FIELD: Option<&'static str> = Some(#soft_delete_lit);
133            }
134        }
135    } else {
136        // 如果没有指定逻辑删除字段，SOFT_DELETE_FIELD 为 None
137        quote! {
138            impl sqlxplus::Model for #name {
139                const TABLE: &'static str = #table;
140                const PK: &'static str = #pk;
141                const SOFT_DELETE_FIELD: Option<&'static str> = None;
142            }
143        }
144    };
145
146    TokenStream::from(expanded)
147}
148
149/// 生成 CRUD trait 的实现
150///
151/// 自动生成 insert 和 update 方法的实现
152///
153/// 使用示例：
154/// ```ignore
155/// // 物理删除模式
156/// #[derive(CRUD, FromRow, ModelMeta)]
157/// #[model(table = "users", pk = "id")]
158/// struct User {
159///     id: i64,
160///     name: String,
161///     email: String,
162/// }
163///
164/// // 逻辑删除模式
165/// #[derive(CRUD, FromRow, ModelMeta)]
166/// #[model(table = "users", pk = "id", soft_delete = "is_deleted")]
167/// struct UserWithSoftDelete {
168///     id: i64,
169///     name: String,
170///     email: String,
171///     is_deleted: i32, // 逻辑删除字段
172/// }
173/// ```
174#[proc_macro_derive(CRUD, attributes(model, skip))]
175pub fn derive_crud(input: TokenStream) -> TokenStream {
176    let input = parse_macro_input!(input as DeriveInput);
177    let name = &input.ident;
178
179    // 解析 #[model(pk = "...")]，获取主键字段名，默认 "id"
180    let mut pk_field = None;
181    for attr in &input.attrs {
182        if attr.path().is_ident("model") {
183            if let syn::Meta::List(list) = &attr.meta {
184                let parser = syn::punctuated::Punctuated::<Meta, syn::Token![,]>::parse_terminated;
185                if let Ok(metas) = parser.parse2(list.tokens.clone()) {
186                    for meta in metas {
187                        if let Meta::NameValue(nv) = meta {
188                            if nv.path.is_ident("pk") {
189                                if let syn::Expr::Lit(syn::ExprLit {
190                                    lit: syn::Lit::Str(s),
191                                    ..
192                                }) = nv.value
193                                {
194                                    pk_field = Some(s.value());
195                                }
196                            }
197                        }
198                    }
199                }
200            } else if let syn::Meta::NameValue(nv) = &attr.meta {
201                if nv.path.is_ident("pk") {
202                    if let syn::Expr::Lit(syn::ExprLit {
203                        lit: syn::Lit::Str(s),
204                        ..
205                    }) = &nv.value
206                    {
207                        pk_field = Some(s.value());
208                    }
209                }
210            }
211        }
212    }
213    // 如果没有指定主键，默认使用 "id"
214    let pk = pk_field.unwrap_or_else(|| "id".to_string());
215
216    // 获取字段列表（必须是具名字段的结构体）
217    let fields = match &input.data {
218        Data::Struct(DataStruct {
219            fields: Fields::Named(fields),
220            ..
221        }) => &fields.named,
222        _ => {
223            return syn::Error::new_spanned(
224                name,
225                "CRUD derive only supports structs with named fields",
226            )
227            .to_compile_error()
228            .into();
229        }
230    };
231
232    // 收集字段信息
233    // - pk_ident: 主键字段 Ident
234    // - insert_*/update_*: 非主键字段（INSERT / UPDATE 使用）
235    let mut pk_ident_opt: Option<&syn::Ident> = None;
236
237    // INSERT 使用的字段（非主键）
238    let mut insert_normal_field_names: Vec<&syn::Ident> = Vec::new();
239    let mut insert_normal_field_columns: Vec<syn::LitStr> = Vec::new();
240    let mut insert_option_field_names: Vec<&syn::Ident> = Vec::new();
241    let mut insert_option_field_columns: Vec<syn::LitStr> = Vec::new();
242
243    // UPDATE 使用的字段（非主键）
244    let mut update_normal_field_names: Vec<&syn::Ident> = Vec::new();
245    let mut update_normal_field_columns: Vec<syn::LitStr> = Vec::new();
246    let mut update_option_field_names: Vec<&syn::Ident> = Vec::new();
247    let mut update_option_field_columns: Vec<syn::LitStr> = Vec::new();
248
249    for field in fields {
250        let field_name = field.ident.as_ref().unwrap();
251        let field_name_str = field_name.to_string();
252
253        // 检查属性：skip / model
254        let mut skip = false;
255        for attr in &field.attrs {
256            if attr.path().is_ident("skip") || attr.path().is_ident("model") {
257                skip = true;
258                break;
259            }
260        }
261
262        if !skip {
263            if field_name_str == pk {
264                // 记录主键字段
265                pk_ident_opt = Some(field_name);
266            } else {
267                // 非主键字段用于 INSERT / UPDATE
268                let is_opt = is_option_type(&field.ty);
269                let col_lit = syn::LitStr::new(&field_name_str, proc_macro2::Span::call_site());
270
271                if is_opt {
272                    insert_option_field_names.push(field_name);
273                    insert_option_field_columns.push(col_lit.clone());
274
275                    update_option_field_names.push(field_name);
276                    update_option_field_columns.push(col_lit);
277                } else {
278                    insert_normal_field_names.push(field_name);
279                    insert_normal_field_columns.push(col_lit.clone());
280
281                    update_normal_field_names.push(field_name);
282                    update_normal_field_columns.push(col_lit);
283                }
284            }
285        }
286    }
287
288    // 编译期确保主键字段存在
289    let pk_ident = pk_ident_opt.expect("Primary key field not found in struct");
290
291    // 生成实现代码
292    let expanded = quote! {
293        // Trait 方法实现
294        #[async_trait::async_trait]
295        impl sqlxplus::Crud for #name {
296            // 泛型版本的 insert（自动类型推断）
297            async fn insert<'e, 'c: 'e, DB, E>(&self, executor: E) -> sqlxplus::Result<sqlxplus::crud::Id>
298            where
299                DB: sqlx::Database + sqlxplus::DatabaseInfo,
300                for<'a> DB::Arguments<'a>: sqlx::IntoArguments<'a, DB>,
301                E: sqlxplus::DatabaseType<DB = DB>
302                    + sqlx::Executor<'c, Database = DB>
303                    + Send,
304                i64: sqlx::Type<DB> + for<'r> sqlx::Decode<'r, DB>,
305                usize: sqlx::ColumnIndex<DB::Row>,
306                // 基本类型必须实现 Type<DB> 和 Encode<DB>（用于绑定值）
307                String: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
308                i64: for<'b> sqlx::Encode<'b, DB>,
309                i32: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
310                i16: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
311                Option<String>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
312                Option<i64>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
313                Option<i32>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
314                Option<i16>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
315                chrono::DateTime<chrono::Utc>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
316                Option<chrono::DateTime<chrono::Utc>>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
317                serde_json::Value: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
318                Option<serde_json::Value>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
319            {
320                use sqlxplus::Model;
321                use sqlxplus::DatabaseInfo;
322                use sqlxplus::db_pool::DbDriver;
323                let table = Self::TABLE;
324                let escaped_table = DB::escape_identifier(table);
325
326                // 构建列名和占位符
327                let mut columns: Vec<&str> = Vec::new();
328                let mut placeholders: Vec<String> = Vec::new();
329                let mut placeholder_index = 0;
330
331                // 非 Option 字段：始终参与 INSERT
332                #(
333                    columns.push(#insert_normal_field_columns);
334                    placeholders.push(DB::placeholder(placeholder_index));
335                    placeholder_index += 1;
336                )*
337
338                // Option 字段：仅当为 Some 时参与 INSERT
339                #(
340                    if self.#insert_option_field_names.is_some() {
341                        columns.push(#insert_option_field_columns);
342                        placeholders.push(DB::placeholder(placeholder_index));
343                        placeholder_index += 1;
344                    }
345                )*
346
347                // 根据数据库类型构建 SQL
348                let sql = match DB::get_driver() {
349                    DbDriver::Postgres => {
350                        let pk = Self::PK;
351                        let escaped_pk = DB::escape_identifier(pk);
352                        format!(
353                            "INSERT INTO {} ({}) VALUES ({}) RETURNING {}",
354                            escaped_table,
355                            columns.join(", "),
356                            placeholders.join(", "),
357                            escaped_pk
358                        )
359                    }
360                    _ => {
361                        format!(
362                            "INSERT INTO {} ({}) VALUES ({})",
363                            escaped_table,
364                            columns.join(", "),
365                            placeholders.join(", ")
366                        )
367                    }
368                };
369
370                // 根据数据库类型执行查询
371                match DB::get_driver() {
372                    DbDriver::Postgres => {
373                        let mut query = sqlx::query_scalar::<_, i64>(&sql);
374                        // 非 Option 字段：始终绑定
375                        #(
376                            query = query.bind(&self.#insert_normal_field_names);
377                        )*
378                        // Option 字段：仅当为 Some 时绑定
379                        #(
380                            if let Some(ref val) = self.#insert_option_field_names {
381                                query = query.bind(val);
382                            }
383                        )*
384                        let id: i64 = query.fetch_one(executor).await?;
385                        Ok(id)
386                    }
387                    DbDriver::MySql => {
388                        let mut query = sqlx::query(&sql);
389                        // 非 Option 字段：始终绑定
390                        #(
391                            query = query.bind(&self.#insert_normal_field_names);
392                        )*
393                        // Option 字段：仅当为 Some 时绑定
394                        #(
395                            if let Some(ref val) = self.#insert_option_field_names {
396                                query = query.bind(val);
397                            }
398                        )*
399                        let result = query.execute(executor).await?;
400                        // 在泛型上下文中，我们需要使用 unsafe 转换来访问数据库特定的方法
401                        // 这是安全的，因为我们已经通过 DB::get_driver() 确认了数据库类型
402                        // 并且我们知道 DB = MySql，所以 result 的类型是 MySqlQueryResult
403                        unsafe {
404                            use sqlx::mysql::MySqlQueryResult;
405                            let ptr: *const DB::QueryResult = &result;
406                            let mysql_ptr = ptr as *const MySqlQueryResult;
407                            Ok((*mysql_ptr).last_insert_id() as i64)
408                        }
409                    }
410                    DbDriver::Sqlite => {
411                        let mut query = sqlx::query(&sql);
412                        // 非 Option 字段：始终绑定
413                        #(
414                            query = query.bind(&self.#insert_normal_field_names);
415                        )*
416                        // Option 字段：仅当为 Some 时绑定
417                        #(
418                            if let Some(ref val) = self.#insert_option_field_names {
419                                query = query.bind(val);
420                            }
421                        )*
422                        let result = query.execute(executor).await?;
423                        // 在泛型上下文中，我们需要使用 unsafe 转换来访问数据库特定的方法
424                        unsafe {
425                            use sqlx::sqlite::SqliteQueryResult;
426                            let ptr: *const DB::QueryResult = &result;
427                            let sqlite_ptr = ptr as *const SqliteQueryResult;
428                            Ok((*sqlite_ptr).last_insert_rowid() as i64)
429                        }
430                    }
431                }
432            }
433
434            // 泛型版本的 update（自动类型推断）
435            async fn update<'e, 'c: 'e, DB, E>(&self, executor: E) -> sqlxplus::Result<()>
436            where
437                DB: sqlx::Database + sqlxplus::DatabaseInfo,
438                for<'a> DB::Arguments<'a>: sqlx::IntoArguments<'a, DB>,
439                E: sqlxplus::DatabaseType<DB = DB>
440                    + sqlx::Executor<'c, Database = DB>
441                    + Send,
442                // 基本类型必须实现 Type<DB> 和 Encode<DB>（用于绑定值）
443                String: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
444                i64: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
445                i32: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
446                i16: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
447                Option<String>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
448                Option<i64>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
449                Option<i32>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
450                Option<i16>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
451                chrono::DateTime<chrono::Utc>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
452                Option<chrono::DateTime<chrono::Utc>>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
453                serde_json::Value: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
454                Option<serde_json::Value>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
455            {
456                use sqlxplus::Model;
457                use sqlxplus::DatabaseInfo;
458                let table = Self::TABLE;
459                let pk = Self::PK;
460                let escaped_table = DB::escape_identifier(table);
461                let escaped_pk = DB::escape_identifier(pk);
462
463                // 构建 UPDATE SET 子句（Patch 语义）
464                let mut set_parts: Vec<String> = Vec::new();
465                let mut placeholder_index = 0;
466
467                // 非 Option 字段
468                #(
469                    set_parts.push(format!("{} = {}", DB::escape_identifier(#update_normal_field_columns), DB::placeholder(placeholder_index)));
470                    placeholder_index += 1;
471                )*
472
473                // Option 字段
474                #(
475                    if self.#update_option_field_names.is_some() {
476                        set_parts.push(format!("{} = {}", DB::escape_identifier(#update_option_field_columns), DB::placeholder(placeholder_index)));
477                        placeholder_index += 1;
478                    }
479                )*
480
481                if set_parts.is_empty() {
482                    return Ok(());
483                }
484
485                let sql = format!(
486                    "UPDATE {} SET {} WHERE {} = {}",
487                    escaped_table,
488                    set_parts.join(", "),
489                    escaped_pk,
490                    DB::placeholder(placeholder_index)
491                );
492
493                let mut query = sqlx::query(&sql);
494                // 非 Option 字段：始终绑定
495                #(
496                    query = query.bind(&self.#update_normal_field_names);
497                )*
498                // Option 字段：仅当为 Some 时绑定
499                #(
500                    if let Some(ref val) = self.#update_option_field_names {
501                        query = query.bind(val);
502                    }
503                )*
504                query = query.bind(&self.#pk_ident);
505                query.execute(executor).await?;
506                Ok(())
507            }
508
509            // 泛型版本的 update_with_none（自动类型推断）
510            async fn update_with_none<'e, 'c: 'e, DB, E>(&self, executor: E) -> sqlxplus::Result<()>
511            where
512                DB: sqlx::Database + sqlxplus::DatabaseInfo,
513                for<'a> DB::Arguments<'a>: sqlx::IntoArguments<'a, DB>,
514                E: sqlxplus::DatabaseType<DB = DB>
515                    + sqlx::Executor<'c, Database = DB>
516                    + Send,
517                // 基本类型必须实现 Type<DB> 和 Encode<DB>（用于绑定值）
518                String: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
519                i64: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
520                i32: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
521                i16: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
522                Option<String>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
523                Option<i64>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
524                Option<i32>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
525                Option<i16>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
526                chrono::DateTime<chrono::Utc>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
527                Option<chrono::DateTime<chrono::Utc>>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
528                serde_json::Value: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
529                Option<serde_json::Value>: sqlx::Type<DB> + for<'b> sqlx::Encode<'b, DB>,
530            {
531                use sqlxplus::Model;
532                use sqlxplus::DatabaseInfo;
533                use sqlxplus::db_pool::DbDriver;
534                let table = Self::TABLE;
535                let pk = Self::PK;
536                let escaped_table = DB::escape_identifier(table);
537                let escaped_pk = DB::escape_identifier(pk);
538
539                // 构建 UPDATE SET 子句（Reset 语义）
540                let mut set_parts: Vec<String> = Vec::new();
541                let mut placeholder_index = 0;
542
543                // 非 Option 字段：始终更新为当前值
544                #(
545                    set_parts.push(format!("{} = {}", DB::escape_identifier(#update_normal_field_columns), DB::placeholder(placeholder_index)));
546                    placeholder_index += 1;
547                )*
548
549                // Option 字段：根据数据库类型处理
550                match DB::get_driver() {
551                    DbDriver::Sqlite => {
552                        // SQLite 不支持 DEFAULT，跳过 None 字段
553                        #(
554                            if self.#update_option_field_names.is_some() {
555                                set_parts.push(format!("{} = {}", DB::escape_identifier(#update_option_field_columns), DB::placeholder(placeholder_index)));
556                                placeholder_index += 1;
557                            }
558                        )*
559                    }
560                    _ => {
561                        // MySQL 和 PostgreSQL 使用 DEFAULT
562                        #(
563                            if self.#update_option_field_names.is_some() {
564                                set_parts.push(format!("{} = {}", DB::escape_identifier(#update_option_field_columns), DB::placeholder(placeholder_index)));
565                                placeholder_index += 1;
566                            } else {
567                                set_parts.push(format!("{} = DEFAULT", DB::escape_identifier(#update_option_field_columns)));
568                            }
569                        )*
570                    }
571                }
572
573                if set_parts.is_empty() {
574                    return Ok(());
575                }
576
577                let sql = format!(
578                    "UPDATE {} SET {} WHERE {} = {}",
579                    escaped_table,
580                    set_parts.join(", "),
581                    escaped_pk,
582                    DB::placeholder(placeholder_index)
583                );
584
585                let mut query = sqlx::query(&sql);
586                // 非 Option 字段：始终绑定
587                #(
588                    query = query.bind(&self.#update_normal_field_names);
589                )*
590                // Option 字段：仅当为 Some 时绑定（None 使用 DEFAULT 或跳过）
591                #(
592                    if let Some(ref val) = self.#update_option_field_names {
593                        query = query.bind(val);
594                    }
595                )*
596                query = query.bind(&self.#pk_ident);
597                query.execute(executor).await?;
598                Ok(())
599            }
600        }
601    };
602
603    TokenStream::from(expanded)
604}
605
606/// 判断字段类型是否为 Option<T>
607fn is_option_type(ty: &syn::Type) -> bool {
608    if let syn::Type::Path(type_path) = ty {
609        if let Some(seg) = type_path.path.segments.last() {
610            if seg.ident == "Option" {
611                if let syn::PathArguments::AngleBracketed(args) = &seg.arguments {
612                    return args.args.len() == 1;
613                }
614            }
615        }
616    }
617    false
618}
sqlxplus_derive/lib.rs

sqlxplus_derive/
lib.rs
