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

scythe_codegen/backends/
csharp_microsoft_sqlite.rs
