scythe_codegen/backends/
csharp_mysqlconnector.rs

1use std::fmt::Write;
2use std::path::Path;
3
4use scythe_backend::manifest::{BackendManifest, load_manifest};
5use scythe_backend::naming::{
6    enum_type_name, enum_variant_name, fn_name, row_struct_name, to_pascal_case,
7};
8use scythe_backend::types::resolve_type;
9
10use scythe_core::analyzer::{AnalyzedQuery, CompositeInfo, EnumInfo};
11use scythe_core::errors::{ErrorCode, ScytheError};
12use scythe_core::parser::QueryCommand;
13
14use crate::backend_trait::{CodegenBackend, ResolvedColumn, ResolvedParam};
15
16const DEFAULT_MANIFEST_TOML: &str = include_str!("../../manifests/csharp-mysqlconnector.toml");
17
18pub struct CsharpMysqlConnectorBackend {
19    manifest: BackendManifest,
20}
21
22impl CsharpMysqlConnectorBackend {
23    pub fn new(engine: &str) -> Result<Self, ScytheError> {
24        match engine {
25            "mysql" | "mariadb" => {}
26            _ => {
27                return Err(ScytheError::new(
28                    ErrorCode::InternalError,
29                    format!(
30                        "csharp-mysqlconnector only supports MySQL, got engine '{}'",
31                        engine
32                    ),
33                ));
34            }
35        }
36        let manifest_path = Path::new("backends/csharp-mysqlconnector/manifest.toml");
37        let manifest = if manifest_path.exists() {
38            load_manifest(manifest_path)
39                .map_err(|e| ScytheError::new(ErrorCode::InternalError, format!("manifest: {e}")))?
40        } else {
41            toml::from_str(DEFAULT_MANIFEST_TOML)
42                .map_err(|e| ScytheError::new(ErrorCode::InternalError, format!("manifest: {e}")))?
43        };
44        Ok(Self { manifest })
45    }
46}
47
48/// Map a neutral type to a MySqlDataReader method.
49fn reader_method(neutral_type: &str) -> &'static str {
50    match neutral_type {
51        "bool" => "GetBoolean",
52        "int16" => "GetInt16",
53        "int32" => "GetInt32",
54        "int64" => "GetInt64",
55        "float32" => "GetFloat",
56        "float64" => "GetDouble",
57        "string" | "json" | "inet" | "interval" | "uuid" => "GetString",
58        "decimal" => "GetDecimal",
59        "date" => "GetFieldValue<DateOnly>",
60        "time" | "time_tz" => "GetFieldValue<TimeOnly>",
61        "datetime" => "GetDateTime",
62        "datetime_tz" => "GetFieldValue<DateTimeOffset>",
63        _ => "GetValue",
64    }
65}
66
67/// Rewrite $1, $2, ... to @p1, @p2, ...
68fn rewrite_params(sql: &str) -> String {
69    let mut result = sql.to_string();
70    for i in (1..=99).rev() {
71        let from = format!("${}", i);
72        let to = format!("@p{}", i);
73        result = result.replace(&from, &to);
74    }
75    result
76}
77
78/// Build the expression to read a column from MySqlDataReader.
79fn column_read_expr(col: &ResolvedColumn, ordinal: usize) -> String {
80    if col.neutral_type.starts_with("enum::") {
81        format!(
82            "Enum.Parse<{}>(reader.GetString({}), true)",
83            col.lang_type, ordinal
84        )
85    } else {
86        let method = reader_method(&col.neutral_type);
87        format!("reader.{}({})", method, ordinal)
88    }
89}
90
91impl CodegenBackend for CsharpMysqlConnectorBackend {
92    fn name(&self) -> &str {
93        "csharp-mysqlconnector"
94    }
95
96    fn manifest(&self) -> &scythe_backend::manifest::BackendManifest {
97        &self.manifest
98    }
99
100    fn supported_engines(&self) -> &[&str] {
101        &["mysql"]
102    }
103
104    fn file_header(&self) -> String {
105        "// Auto-generated by scythe. Do not edit.\nusing MySqlConnector;\n\npublic static class Queries {"
106            .to_string()
107    }
108
109    fn file_footer(&self) -> String {
110        "}".to_string()
111    }
112
113    fn generate_row_struct(
114        &self,
115        query_name: &str,
116        columns: &[ResolvedColumn],
117    ) -> Result<String, ScytheError> {
118        let struct_name = row_struct_name(query_name, &self.manifest.naming);
119        let mut out = String::new();
120        let _ = writeln!(out, "public record {}(", struct_name);
121        for (i, c) in columns.iter().enumerate() {
122            let field = to_pascal_case(&c.field_name);
123            let sep = if i + 1 < columns.len() { "," } else { "" };
124            let _ = writeln!(out, "    {} {}{}", c.full_type, field, sep);
125        }
126        let _ = write!(out, ");");
127        Ok(out)
128    }
129
130    fn generate_model_struct(
131        &self,
132        table_name: &str,
133        columns: &[ResolvedColumn],
134    ) -> Result<String, ScytheError> {
135        let name = to_pascal_case(table_name);
136        self.generate_row_struct(&name, columns)
137    }
138
139    fn generate_query_fn(
140        &self,
141        analyzed: &AnalyzedQuery,
142        struct_name: &str,
143        columns: &[ResolvedColumn],
144        params: &[ResolvedParam],
145    ) -> Result<String, ScytheError> {
146        let func_name = fn_name(&analyzed.name, &self.manifest.naming);
147        let sql = rewrite_params(&super::clean_sql_oneline(&analyzed.sql));
148        let mut out = String::new();
149
150        let param_list = params
151            .iter()
152            .map(|p| format!("{} {}", p.full_type, p.field_name))
153            .collect::<Vec<_>>()
154            .join(", ");
155        let sep = if param_list.is_empty() { "" } else { ", " };
156
157        let return_type = match &analyzed.command {
158            QueryCommand::One => format!("{}?", struct_name),
159            QueryCommand::Many | QueryCommand::Batch => {
160                format!("List<{}>", struct_name)
161            }
162            QueryCommand::Exec => "void".to_string(),
163            QueryCommand::ExecResult | QueryCommand::ExecRows => "int".to_string(),
164        };
165
166        let is_async_void = return_type == "void";
167        let task_type = if is_async_void {
168            "Task".to_string()
169        } else {
170            format!("Task<{}>", return_type)
171        };
172
173        let _ = writeln!(
174            out,
175            "public static async {} {}(MySqlConnection conn{}{}) {{",
176            task_type, func_name, sep, param_list
177        );
178
179        let _ = writeln!(
180            out,
181            "    await using var cmd = new MySqlCommand(\"{}\", conn);",
182            sql
183        );
184        for (i, p) in params.iter().enumerate() {
185            let value_expr = if p.neutral_type.starts_with("enum::") {
186                format!("{}.ToString().ToLower()", p.field_name)
187            } else {
188                p.field_name.clone()
189            };
190            let _ = writeln!(
191                out,
192                "    cmd.Parameters.AddWithValue(\"@p{}\", {});",
193                i + 1,
194                value_expr
195            );
196        }
197
198        match &analyzed.command {
199            QueryCommand::One => {
200                let _ = writeln!(
201                    out,
202                    "    await using var reader = await cmd.ExecuteReaderAsync();"
203                );
204                let _ = writeln!(out, "    if (!await reader.ReadAsync()) return null;");
205                let _ = writeln!(out, "    return new {}(", struct_name);
206                for (i, col) in columns.iter().enumerate() {
207                    let expr = column_read_expr(col, i);
208                    let sep = if i + 1 < columns.len() { "," } else { "" };
209                    if col.nullable {
210                        let _ = writeln!(out, "        reader.IsDBNull({i}) ? null : {expr}{sep}");
211                    } else {
212                        let _ = writeln!(out, "        {expr}{sep}");
213                    }
214                }
215                let _ = writeln!(out, "    );");
216            }
217            QueryCommand::Many | QueryCommand::Batch => {
218                let _ = writeln!(
219                    out,
220                    "    await using var reader = await cmd.ExecuteReaderAsync();"
221                );
222                let _ = writeln!(out, "    var results = new List<{}>();", struct_name);
223                let _ = writeln!(out, "    while (await reader.ReadAsync()) {{");
224                let _ = writeln!(out, "        results.Add(new {}(", struct_name);
225                for (i, col) in columns.iter().enumerate() {
226                    let expr = column_read_expr(col, i);
227                    let sep = if i + 1 < columns.len() { "," } else { "" };
228                    if col.nullable {
229                        let _ =
230                            writeln!(out, "            reader.IsDBNull({i}) ? null : {expr}{sep}");
231                    } else {
232                        let _ = writeln!(out, "            {expr}{sep}");
233                    }
234                }
235                let _ = writeln!(out, "        ));");
236                let _ = writeln!(out, "    }}");
237                let _ = writeln!(out, "    return results;");
238            }
239            QueryCommand::Exec => {
240                let _ = writeln!(out, "    await cmd.ExecuteNonQueryAsync();");
241            }
242            QueryCommand::ExecResult | QueryCommand::ExecRows => {
243                let _ = writeln!(out, "    return await cmd.ExecuteNonQueryAsync();");
244            }
245        }
246
247        let _ = write!(out, "}}");
248        Ok(out)
249    }
250
251    fn generate_enum_def(&self, enum_info: &EnumInfo) -> Result<String, ScytheError> {
252        let type_name = enum_type_name(&enum_info.sql_name, &self.manifest.naming);
253        let mut out = String::new();
254        let _ = writeln!(out, "public enum {} {{", type_name);
255        for value in &enum_info.values {
256            let variant = enum_variant_name(value, &self.manifest.naming);
257            let _ = writeln!(out, "    {},", variant);
258        }
259        let _ = write!(out, "}}");
260        Ok(out)
261    }
262
263    fn generate_composite_def(&self, composite: &CompositeInfo) -> Result<String, ScytheError> {
264        let name = to_pascal_case(&composite.sql_name);
265        let mut out = String::new();
266        if composite.fields.is_empty() {
267            let _ = writeln!(out, "public record {}();", name);
268        } else {
269            let _ = writeln!(out, "public record {}(", name);
270            for (i, field) in composite.fields.iter().enumerate() {
271                let cs_type = resolve_type(&field.neutral_type, &self.manifest, false)
272                    .map(|t| t.into_owned())
273                    .unwrap_or_else(|_| "object".to_string());
274                let field_name = to_pascal_case(&field.name);
275                let sep = if i + 1 < composite.fields.len() {
276                    ","
277                } else {
278                    ""
279                };
280                let _ = writeln!(out, "    {} {}{}", cs_type, field_name, sep);
281            }
282            let _ = write!(out, ");");
283        }
284        Ok(out)
285    }
286}
scythe_codegen/backends/csharp_mysqlconnector.rs

scythe_codegen/backends/
csharp_mysqlconnector.rs
